usb平台驱动

weixin_39296862

已于 2023-06-08 09:03:03 修改

阅读量66

点赞数

文章标签： java c++ 开发语言驱动开发

于 2023-05-15 10:22:13 首次发布

本文链接：https://blog.csdn.net/weixin_39296862/article/details/130673085

版权

  1907  static struct platform_driver ti81xx_musb_driver = {
  1908          .remove         = __exit_p(ti81xx_remove),
  1909          .driver         = {
  1910                  .name   = "musb-ti81xx",
  1911                  .pm     = DEV_PM_OPS,
  1912          },
  1913  };
  1914
  1915  MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>");
  1916  MODULE_DESCRIPTION("AM35x MUSB Glue Layer");
  1917  MODULE_LICENSE("GPL v2");
  1918
  1919  static int __init ti81xx_glue_init(void)
  1920  {
  1921          return platform_driver_probe(&ti81xx_musb_driver, ti81xx_probe);
  1922  }
  1923  subsys_initcall(ti81xx_glue_init);

平台name = “musb-ti81xx”

运行ti81xx_probe

  1545  static int __init ti81xx_probe(struct platform_device *pdev)
  1546  {
  1547          struct ti81xx_glue *glue;
  1548          struct device *dev = &pdev->dev;
  1549          struct musb_hdrc_platform_data *plat = dev->platform_data;
  1550          struct omap_musb_board_data *data = plat->board_data;
  1551          int ret = 0, i;
  1552          struct resource *res;
  1553
  1554          /* allocate glue */
  1555          glue = kzalloc(sizeof(*glue), GFP_KERNEL);
  1556          if (!glue) {
  1557                  dev_err(&pdev->dev, "unable to allocate glue memory\n");
  1558                  ret = -ENOMEM;
  1559                  goto err0;
  1560          }
  1561
  1562          /* get memory resource */
  1563          glue->mem_pa = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  1564          if (!glue->mem_pa) {
  1565                  dev_err(&pdev->dev, "failed to get usbss mem resourse\n");
  1566                  ret = -ENODEV;
  1567                  goto err1;
  1568          }
  1569
  1570          /* get memory resource */
  1571          res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usbss-irq");
  1572          if (!res) {
  1573                  dev_err(&pdev->dev, "failed to get usbss irq resourse\n");
  1574                  ret = -ENODEV;
  1575                  goto err1;
  1576          }
  1577          glue->irq = res->start;
  1578
  1579          /* iomap for usbss mem space */
  1580          glue->mem_va =
  1581                  ioremap(glue->mem_pa->start, resource_size(glue->mem_pa));
  1582          if (!glue->mem_va) {
  1583                  dev_err(&pdev->dev, "usbss ioremap failed\n");
  1584                  ret = -ENOMEM;
  1585                  goto err1;
  1586          }
  1587          usbss_virt_base = glue->mem_va;
  1588
  1589          glue->first = 1;
  1590          glue->dev = &pdev->dev;
  1591          platform_set_drvdata(pdev, glue);
  1592
  1593          /* enable clocks */
  1594          pm_runtime_enable(&pdev->dev);
  1595          ret = pm_runtime_get_sync(&pdev->dev);
  1596          if (ret < 0) {
  1597                  dev_err(dev, "pm_runtime_get_sync FAILED");
  1598                  goto err2;
  1599          }
  1600
  1601          /* usb subsystem init */
  1602          usbotg_ss_init();
  1603
  1604          /* clear any USBSS interrupts */
  1605          writel(0, glue->mem_va + USBSS_IRQ_EOI);
  1606          writel(readl(glue->mem_va + USBSS_IRQ_STATUS),
  1607                                          glue->mem_va + USBSS_IRQ_STATUS);
  1608
  1609          /* create the child platform device for mulitple instances of musb */
  1610          for (i = 0; i <= data->instances; ++i) {
  1611  #ifdef CONFIG_USB_TI_CPPI41_DMA
  1612                  /* initialize the cppi41dma init */
  1613                  cppi41_init(i, glue->irq, data->instances+1);
  1614  #endif
  1615                  ret = ti81xx_create_musb_pdev(glue, i);
  1616                  if (ret != 0)
  1617                          goto err3;
  1618          }
  1619
  1620          return 0;
  1621
  1622  err3:
  1623          pm_runtime_put_sync(&pdev->dev);
  1624  err2:
  1625          pm_runtime_disable(&pdev->dev);
  1626          iounmap(glue->mem_va);
  1627  err1:
  1628          kfree(glue);
  1629  err0:
  1630          return ret;
  1631  }
  1632

1555行给ti81xx_glue 分配内存。

1563行：获取资源; glue->mem_pa = 0x47400000;

1571行：获取中断资源：res->start = 17;

glue->irq = res->start;

1580行：物理内存映射 glue->mem_va = 0x47400000;的虚拟内存

1587行：usbss_virt_base = glue->mem_va;

glue->first = 1;
1590 glue->dev = &pdev->dev;

1591行：pdev->dev->p->driver_data =glue;

1602行：usbotg_ss_init

 142  static void usbotg_ss_init(void)
   143  {
   144          if (!usbss_init_done) {
   145                  usbss_init_done = 1;
   146
   147                  /* clear any USBSS interrupts */
   148                  usbss_write(USBSS_IRQ_EOI, 0);
   149                  usbss_write(USBSS_IRQ_STATUS, usbss_read(USBSS_IRQ_STATUS));
   150          }
   151  }

144行这个变量定义在本文件

static u8 usbss_init_done;初始化为0；

148和149行：

static inline void usbss_write(u32 offset, u32 data)
{
	if (!usbss_init_done)
		return ;
	writel(data, usbss_virt_base + offset);
}

就是给寄存器写入数据

/* USBSS EOI interrupt register */
#define USBSS_IRQ_EOI			0x0020
/* USBSS interrupt generation/status register */
#define USBSS_IRQ_STATUS_RAW		0x0024
/* USBSS interrupt status register */
#define USBSS_IRQ_STATUS		0x0028

这个函数就是clear any USBSS interrupts

1611行：这个for循环只有一次instances=1；

cppi41_init(i, glue->irq, data->instances+1);

  460  int __devinit cppi41_init(u8 id, u8 irq, int num_instances)
   461  {
   462          struct usb_cppi41_info *cppi_info = &usb_cppi41_info[id];
   463          u16 numch, blknum, order;
   464          u32 i;
   465
   466          /* init cppi info structure  */
   467          cppi_info->dma_block = 0;
   468          for (i = 0 ; i < USB_CPPI41_NUM_CH ; i++)
   469                  cppi_info->ep_dma_ch[i] = i + (15 * id);
   470
   471          cppi_info->q_mgr = 0;
   472          cppi_info->num_tx_comp_q = 15;
   473          cppi_info->num_rx_comp_q = 15;
   474          cppi_info->tx_comp_q = id ? tx_comp_q1 : tx_comp_q;
   475          cppi_info->rx_comp_q = id ? rx_comp_q1 : rx_comp_q;
   476          cppi_info->bd_intr_ctrl = 1;
   477          cppi_info->sched_tbl_ctrl = 0;
   478          cppi_info->version = usbss_read(USBSS_REVISION);
   479
   480          if (cppi41_init_done)
   481                  return 0;
   482
   483          blknum = cppi_info->dma_block;
   484
   485          /* Queue manager information */
   486          cppi41_queue_mgr[0].num_queue = 159;
   487          cppi41_queue_mgr[0].queue_types = CPPI41_FREE_DESC_BUF_QUEUE |
   488                                                  CPPI41_UNASSIGNED_QUEUE;
   489          cppi41_queue_mgr[0].base_fdbq_num = 0;
   490          cppi41_queue_mgr[0].assigned = assigned_queues;
   491
   492          /* init DMA block */
   493          cppi41_dma_block[0].num_tx_ch = 30;
   494          cppi41_dma_block[0].num_rx_ch = 30;
   495          cppi41_dma_block[0].tx_ch_info = tx_ch_info;
   496
   497          /* initilize cppi41 dma & Qmgr address */
   498          cppi41_dma_base = ioremap(TI81XX_USB_CPPIDMA_BASE,
   499                                          TI81XX_USB_CPPIDMA_LEN);
   500
   501          cppi41_queue_mgr[0].q_mgr_rgn_base = CPPI41_ADDR(QMGR_RGN_OFFS);
   502          cppi41_queue_mgr[0].desc_mem_rgn_base = CPPI41_ADDR(QMRG_DESCRGN_OFFS);
   503          cppi41_queue_mgr[0].q_mgmt_rgn_base = CPPI41_ADDR(QMGR_REG_OFFS);
   504          cppi41_queue_mgr[0].q_stat_rgn_base = CPPI41_ADDR(QMGR_STAT_OFFS);
   505          cppi41_dma_block[0].global_ctrl_base = CPPI41_ADDR(DMA_GLBCTRL_OFFS);
   506          cppi41_dma_block[0].ch_ctrl_stat_base = CPPI41_ADDR(DMA_CHCTRL_OFFS);
   507          cppi41_dma_block[0].sched_ctrl_base = CPPI41_ADDR(DMA_SCHED_OFFS);
   508          cppi41_dma_block[0].sched_table_base = CPPI41_ADDR(DMA_SCHEDTBL_OFFS);
   509
   510          /* Initialize for Linking RAM region 0 alone */
   511          cppi41_queue_mgr_init(cppi_info->q_mgr, 0, 0x3fff);
   512
   513          numch =  USB_CPPI41_NUM_CH * 2 * num_instances;
   514          cppi41_dma_block[0].num_max_ch = numch;
   515
   516          order = get_count_order(numch);
   517
   518          /* TODO: check two teardown desc per channel (5 or 7 ?)*/
   519          if (order < 5)
   520                  order = 5;
   521
   522          cppi41_dma_block_init(blknum, cppi_info->q_mgr, order,
   523                          dma_sched_table, numch);
   524
   525          /* attach to the IRQ */
   526          if (request_irq(irq, cppi41dma_Interrupt, 0, "cppi41_dma", 0))
   527                  printk(KERN_INFO "request_irq %d failed!\n", irq);
   528          else
   529                  printk(KERN_INFO "registerd cppi-dma Intr @ IRQ %d\n", irq);
   530
   531          cppi41_init_done = 1;
   532
   533          printk(KERN_INFO "Cppi41 Init Done Qmgr-base(%p) dma-base(%p)\n",
   534                  cppi41_queue_mgr[0].q_mgr_rgn_base,
   535                  cppi41_dma_block[0].global_ctrl_base);
   536
   537          /* enable all usbss the interrupts */
   538          usbss_write(USBSS_IRQ_EOI, 0);
   539          usbss_write(USBSS_IRQ_ENABLE_SET, USBSS_INTR_FLAGS);
   540          usbss_write(USBSS_IRQ_DMA_ENABLE_0, 0xFFFeFFFe);
   541
   542          printk(KERN_INFO "Cppi41 Init Done\n");
   543
   544          return 0;
   545  }
   546

467 cppi_info->dma_block = 0;
468 for (i = 0 ; i < USB_CPPI41_NUM_CH ; i++)//循环15次
469 cppi_info->ep_dma_ch[i] = i + (15 * id);
470
471 cppi_info->q_mgr = 0;
472 cppi_info->num_tx_comp_q = 15;
473 cppi_info->num_rx_comp_q = 15;
474 cppi_info->tx_comp_q = id ? tx_comp_q1 : tx_comp_q;//tx_comp_q
475 cppi_info->rx_comp_q = id ? rx_comp_q1 : rx_comp_q;//rx_comp_q
476 cppi_info->bd_intr_ctrl = 1;
477 cppi_info->sched_tbl_ctrl = 0;

blknum = cppi_info->dma_block;

/* Queue manager information */

cppi41_queue_mgr[0].num_queue = 159;

cppi41_queue_mgr[0].queue_types = CPPI41_FREE_DESC_BUF_QUEUE |

CPPI41_UNASSIGNED_QUEUE;

cppi41_queue_mgr[0].base_fdbq_num = 0;

cppi41_queue_mgr[0].assigned = assigned_queues;

/* init DMA block */

cppi41_dma_block[0].num_tx_ch = 30;

cppi41_dma_block[0].num_rx_ch = 30;

cppi41_dma_block[0].tx_ch_info = tx_ch_info;

498行：映射内存cppi41_dma_base //0x47402000

500~508行：#define CPPI41_ADDR(offs) ((void *)((u32)cppi41_dma_base + (offs - 0x2000)))

501 cppi41_queue_mgr[0].q_mgr_rgn_base (0x47404000)
502 cppi41_queue_mgr[0].desc_mem_rgn_base//(0x47405000)
503 cppi41_queue_mgr[0].q_mgmt_rgn_base//(0x47406000)
504 cppi41_queue_mgr[0].q_stat_rgn_base //
505 cppi41_dma_block[0].global_ctrl_base
506 cppi41_dma_block[0].ch_ctrl_stat_base
507 cppi41_dma_block[0].sched_ctrl_base
508 cppi41_dma_block[0].sched_table_base

511行：511 cppi41_queue_mgr_init(cppi_info->q_mgr, 0, 0x3fff);

 81
    82  int cppi41_queue_mgr_init(u8 q_mgr, dma_addr_t rgn0_base, u16 rgn0_size)
    83  {
    84          void __iomem *q_mgr_regs;
    85          void *ptr;
    86
    87          if (q_mgr >= cppi41_num_queue_mgr)
    88                  return -EINVAL;
    89
    90          q_mgr_regs = cppi41_queue_mgr[q_mgr].q_mgr_rgn_base;
    91          ptr = dma_alloc_coherent(NULL, rgn0_size * 4,
    92                                   &linking_ram[q_mgr].phys_addr,
    93                                   GFP_KERNEL | GFP_DMA);
    94          if (ptr == NULL) {
    95                  printk(KERN_ERR "ERROR: %s: Unable to allocate "
    96                         "linking RAM.\n", __func__);
    97                  return -ENOMEM;
    98          }
    99          linking_ram[q_mgr].virt_addr = ptr;
   100          linking_ram[q_mgr].size = rgn0_size * 4;
   101
   102          cppi_writel(linking_ram[q_mgr].phys_addr,
   103                          q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG);
   104          DBG("Linking RAM region 0 base @ %p, value: %x\n",
   105              q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG,
   106              cppi_readl(q_mgr_regs + QMGR_LINKING_RAM_RGN0_BASE_REG));
   107
   108          cppi_writel(rgn0_size, q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG);
   109          DBG("Linking RAM region 0 size @ %p, value: %x\n",
   110              q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG,
   111              cppi_readl(q_mgr_regs + QMGR_LINKING_RAM_RGN0_SIZE_REG));
   112
   113          ptr = kzalloc(BITS_TO_LONGS(cppi41_queue_mgr[q_mgr].num_queue) *
   114                          sizeof(long), GFP_KERNEL);
   115          if (ptr == NULL) {
   116                  printk(KERN_ERR "ERROR: %s: Unable to allocate queue bitmap.\n",
   117                         __func__);
   118                  dma_free_coherent(NULL, rgn0_size * 4,
   119                                    linking_ram[q_mgr].virt_addr,
   120                                    linking_ram[q_mgr].phys_addr);
   121                  return -ENOMEM;
   122          }
   123          allocated_queues[q_mgr] = ptr;
   124
   125          return 0;
   126  }
   127  EXPORT_SYMBOL(cppi41_queue_mgr_init);
   128

87行：q_mgr >= cppi41_num_queue_mgr（q_mgr =0；cppi41_num_queue_mgr =1）

91行：分配dma

102行：写入dma物理地址

108行：写入大小

113行给队列分配内存，赋值

退出

514行 cppi41_dma_block[0].num_max_ch =60

order =6；

522行： cppi41_dma_block_init(blknum, cppi_info->q_mgr, order,dma_sched_table, numch);

队列初始化

526行申请中断

接下来使能enable all usbss the interrupts

退出cppi41_init

进入ti81xx_create_musb_pdev

  1460  static int __devinit ti81xx_create_musb_pdev(struct ti81xx_glue *glue, u8 id)
  1461  {
  1462          struct device *dev = glue->dev;
  1463          struct platform_device *pdev = to_platform_device(dev);
  1464          struct musb_hdrc_platform_data  *pdata = dev->platform_data;
  1465          struct omap_musb_board_data *bdata = pdata->board_data;
  1466          struct platform_device  *musb;
  1467          struct resource *res;
  1468          struct resource resources[2];
  1469          char res_name[10];
  1470          int ret = 0;
  1471
  1472          /* get memory resource */
  1473          sprintf(res_name, "musb%d", id);
  1474          res = platform_get_resource_byname(pdev, IORESOURCE_MEM, res_name);
  1475          if (!res) {
  1476                  dev_err(dev, "%s get mem resource failed\n", res_name);
  1477                  ret = -ENODEV;
  1478                  goto err0;
  1479          }
  1480          res->parent = NULL;
  1481          resources[0] = *res;
  1482
  1483          /* get irq resource */
  1484          sprintf(res_name, "musb%d-irq", id);
  1485          res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, res_name);
  1486          if (!res) {
  1487                  dev_err(dev, "%s get irq resource failed\n", res_name);
  1488                  ret = -ENODEV;
  1489                  goto err0;
  1490          }
  1491          res->parent = NULL;
  1492          resources[1] = *res;
  1493
  1494          /* allocate the child platform device */
  1495          musb = platform_device_alloc("musb-hdrc", id);
  1496          if (!musb) {
  1497                  dev_err(dev, "failed to allocate musb device\n");
  1498                  goto err0;
  1499          }
  1500
  1501          musb->id                        = id;
  1502          musb->dev.parent                = dev;
  1503          musb->dev.dma_mask              = &musb_dmamask;
  1504          musb->dev.coherent_dma_mask     = musb_dmamask;
  1505
  1506          glue->musb[id]                  = musb;
  1507
  1508          pdata->platform_ops             = &ti81xx_ops;
  1509
  1510          ret = platform_device_add_resources(musb, resources, 2);
  1511          if (ret) {
  1512                  dev_err(dev, "failed to add resources\n");
  1513                  goto err1;
  1514          }
  1515
  1516          if (id == 0)
  1517                  pdata->mode = bdata->mode & USB0PORT_MODEMASK;
  1518          else
  1519                  pdata->mode = (bdata->mode & USB1PORT_MODEMASK)
  1520                                          >> USB1PORT_MODESHIFT;
  1521
  1522          dev_info(dev, "musb%d, board_mode=0x%x, plat_mode=0x%x\n",
  1523                                          id, bdata->mode, pdata->mode);
  1524
  1525          ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
  1526          if (ret) {
  1527                  dev_err(dev, "failed to add platform_data\n");
  1528                  goto err1;
  1529          }
  1530
  1531          ret = platform_device_add(musb);
  1532          if (ret) {
  1533                  dev_err(dev, "failed to register musb device\n");
  1534                  goto err1;
  1535          }
  1536
  1537          return 0;
  1538
  1539  err1:
  1540          platform_device_put(musb);
  1541  err0:
  1542          return ret;
  1543  }
  1544

看到这里创建平台设备，名称分别为“musb0”“musb1”