Linux那些事儿之我是UHCI(5)传说中的DMA

下一个函数,usb_add_hcd,drivers/usb/core/hcd.c中:

   1548 /**

   1549  * usb_add_hcd - finish generic HCD structure initialization and register

   1550  * @hcd: the usb_hcd structure to initialize

   1551  * @irqnum: Interrupt line to allocate

   1552  * @irqflags: Interrupt type flags

   1553  *

   1554  * Finish the remaining parts of generic HCD initialization: allocate the

   1555  * buffers of consistent memory, register the bus, request the IRQ line,

   1556  * and call the driver's reset() and start() routines.

   1557  */

   1558 int usb_add_hcd(struct usb_hcd *hcd,

   1559                 unsigned int irqnum, unsigned long irqflags)

   1560 {

   1561         int retval;

   1562         struct usb_device *rhdev;

   1563

   1564         dev_info(hcd->self.controller, "%s/n", hcd->product_desc);

   1565

   1566         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);

   1567

   1568         /* HC is in reset state, but accessible.  Now do the one-time init,

   1569          * bottom up so that hcds can customize the root hubs before khubd

   1570          * starts talking to them.  (Note, bus id is assigned early too.)

   1571          */

   1572         if ((retval = hcd_buffer_create(hcd)) != 0) {

   1573                 dev_dbg(hcd->self.controller, "pool alloc failed/n");

   1574                 return retval;

   1575         }

   1576

   1577         if ((retval = usb_register_bus(&hcd->self)) < 0)

   1578                 goto err_register_bus;

   1579

   1580         if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {

   1581                 dev_err(hcd->self.controller, "unable to allocate root hub/n");

   1582                 retval = -ENOMEM;

   1583                 goto err_allocate_root_hub;

   1584         }

   1585         rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH :

   1586                         USB_SPEED_FULL;

   1587         hcd->self.root_hub = rhdev;

   1588

   1589         /* wakeup flag init defaults to "everything works" for root hubs,

   1590          * but drivers can override it in reset() if needed, along with

   1591          * recording the overall controller's system wakeup capability.

   1592          */

   1593         device_init_wakeup(&rhdev->dev, 1);

   1594

   1595         /* "reset" is misnamed; its role is now one-time init. the controller

   1596          * should already have been reset (and boot firmware kicked off etc).

   1597          */

   1598         if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {

   1599                 dev_err(hcd->self.controller, "can't setup/n");

   1600                 goto err_hcd_driver_setup;

   1601         }

   1602

   1603         /* NOTE: root hub and controller capabilities may not be the same */

   1604         if (device_can_wakeup(hcd->self.controller)

   1605                         && device_can_wakeup(&hcd->self.root_hub->dev))

   1606                 dev_dbg(hcd->self.controller, "supports USB remote wakeup/n");

   1607

   1608         /* enable irqs just before we start the controller */

   1609         if (hcd->driver->irq) {

   1610                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",

   1611                                 hcd->driver->description, hcd->self.busnum);

   1612                 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,

   1613                                 hcd->irq_descr, hcd)) != 0) {

   1614                         dev_err(hcd->self.controller,

   1615                                         "request interrupt %d failed/n", irqnum);

   1616                         goto err_request_irq;

   1617                 }

   1618                 hcd->irq = irqnum;

   1619                 dev_info(hcd->self.controller, "irq %d, %s 0x%08llx/n", irqnum,

   1620                                 (hcd->driver->flags & HCD_MEMORY) ?

   1621                                         "io mem" : "io base",

   1622                                         (unsigned long long)hcd->rsrc_start);

   1623         } else {

   1624                 hcd->irq = -1;

   1625                 if (hcd->rsrc_start)

   1626                         dev_info(hcd->self.controller, "%s 0x%08llx/n",

   1627                                         (hcd->driver->flags & HCD_MEMORY) ?

   1628                                         "io mem" : "io base",

   1629                                         (unsigned long long)hcd->rsrc_start);

   1630         }

   1631

   1632         if ((retval = hcd->driver->start(hcd)) < 0) {

   1633                 dev_err(hcd->self.controller, "startup error %d/n", retval);

   1634                 goto err_hcd_driver_start;

   1635         }

   1636

   1637         /* starting here, usbcore will pay attention to this root hub */

   1638         rhdev->bus_mA = min(500u, hcd->power_budget);

   1639         if ((retval = register_root_hub(hcd)) != 0)

   1640                 goto err_register_root_hub;

   1641

   1642         if (hcd->uses_new_polling && hcd->poll_rh)

   1643                 usb_hcd_poll_rh_status(hcd);

   1644         return retval;

   1645

   1646 err_register_root_hub:

   1647         hcd->driver->stop(hcd);

   1648 err_hcd_driver_start:

   1649         if (hcd->irq >= 0)

   1650                 free_irq(irqnum, hcd);

   1651 err_request_irq:

   1652 err_hcd_driver_setup:

   1653         hcd->self.root_hub = NULL;

   1654         usb_put_dev(rhdev);

   1655 err_allocate_root_hub:

   1656         usb_deregister_bus(&hcd->self);

   1657 err_register_bus:

   1658         hcd_buffer_destroy(hcd);

   1659         return retval;

   1660 }

1566行,设置一个flag,至于设了干嘛用,等遇到了再说.

1572行,hcd_buffer_create,初始化一个buffer池.现在是时候说一说DMA了.我们知道一个USB主机控制器控制着一条USB总线,而USB主机控制器的一项重要工作是什么呢?在内存和USB总线之间传输数据.这个过程可以使用DMA或者不使用DMA,不使用DMA的方式即所谓的PIO方式.DMA代表着Direct Memory Access,即直接内存访问.那么使用DMA如何做呢?不需要CPU干预对吧,内存总是需要的吧,我比如说我有一个UHCI控制器,我告诉它,内存中某个地方放了一堆数据,你去取吧,然后它就自己去取,取完了它就跟我说一声,告诉我它取完了.

那么在整个USB子系统中是如何处理这些事情的呢?好,苦等了这么久,我终于有机会来向你解释这个问题了,现在我终于可以说电视剧中男主角对女主角常说的那句话,你听我解释,你听我解释呀!回去看我们在usb-storage中,在hub driver中,我们调用过一个函数usb_buffer_alloc,当时很多网友问我这个函数究竟是如何处理DMA或不DMA的?

关于DMA,合理的做法是先创建一个内存池,然后每次都从池子里要内存.具体说就是先由HCD这边建池子,然后设备驱动那边就直接索取.我们来看代码,来自drivers/usb/core/buffer.c中的hcd_buffer_create,

     40 /**

     41  * hcd_buffer_create - initialize buffer pools

     42  * @hcd: the bus whose buffer pools are to be initialized

     43  * Context: !in_interrupt()

     44  *

     45  * Call this as part of initializing a host controller that uses the dma

     46  * memory allocators.  It initializes some pools of dma-coherent memory that

     47  * will be shared by all drivers using that controller, or returns a negative

     48  * errno value on error.

     49  *

     50  * Call hcd_buffer_destroy() to clean up after using those pools.

     51  */

     52 int hcd_buffer_create(struct usb_hcd *hcd)

     53 {

     54         char            name[16];

     55         int             i, size;

     56

     57         if (!hcd->self.controller->dma_mask)

     58                 return 0;

     59

     60         for (i = 0; i < HCD_BUFFER_POOLS; i++) {

     61                 if (!(size = pool_max [i]))

     62                         continue;

     63                 snprintf(name, sizeof name, "buffer-%d", size);

     64                 hcd->pool[i] = dma_pool_create(name, hcd->self.controller,

     65                                 size, size, 0);

     66                 if (!hcd->pool [i]) {

     67                         hcd_buffer_destroy(hcd);

     68                         return -ENOMEM;

     69                 }

     70         }

     71         return 0;

     72 }

别的我们先不说,先看64行,调用了dma_pool_create函数,这个函数就是真正去创建内存池的函数,或者更准确地讲,创建一个DMA池,内核中定义了一个结构体,struct dma_pool,就是专门代表一个DMA池的,而这个函数的返回值就是生成的那个DMA池.如果创建失败就调用hcd_buffer_destroy,还是来自同一个文件,

     75 /**

     76  * hcd_buffer_destroy - deallocate buffer pools

     77  * @hcd: the bus whose buffer pools are to be destroyed

     78  * Context: !in_interrupt()

     79  *

     80  * This frees the buffer pools created by hcd_buffer_create().

     81  */

     82 void hcd_buffer_destroy(struct usb_hcd *hcd)

     83 {

     84         int             i;

     85

     86         for (i = 0; i < HCD_BUFFER_POOLS; i++) {

     87                 struct dma_pool         *pool = hcd->pool[i];

     88                 if (pool) {

     89                         dma_pool_destroy(pool);

     90                         hcd->pool[i] = NULL;

     91                 }

     92         }

     93 }

看得出这里调用的是dma_pool_destroy,其作用不言自明.

那么创建池子和销毁池子的函数我们知道了,如何从池子里索取或者把索取的释放回去呢?对应的两个函数分别是,dma_pool_alloc和dma_pool_free,而这两个函数正是与我们说的usb_buffer_alloc以及usb_buffer_free相联系的.于是我们来看这两个函数的代码,来自drivers/usb/core/usb.c:

    568 /**

    569  * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP

    570  * @dev: device the buffer will be used with

    571  * @size: requested buffer size

    572  * @mem_flags: affect whether allocation may block

    573  * @dma: used to return DMA address of buffer

    574  *

    575  * Return value is either null (indicating no buffer could be allocated), or

    576  * the cpu-space pointer to a buffer that may be used to perform DMA to the

    577  * specified device.  Such cpu-space buffers are returned along with the DMA

    578  * address (through the pointer provided).

    579  *

    580  * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags

    581  * to avoid behaviors like using "DMA bounce buffers", or tying down I/O

    582  * mapping hardware for long idle periods.  The implementation varies between

    583  * platforms, depending on details of how DMA will work to this device.

    584  * Using these buffers also helps prevent cacheline sharing problems on

    585  * architectures where CPU caches are not DMA-coherent.

    586  *

    587  * When the buffer is no longer used, free it with usb_buffer_free().

    588  */

    589 void *usb_buffer_alloc(

    590         struct usb_device *dev,

    591         size_t size,

    592         gfp_t mem_flags,

    593         dma_addr_t *dma

    594 )

    595 {

    596         if (!dev || !dev->bus)

    597                 return NULL;

    598         return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);

    599 }

    600

    601 /**

    602  * usb_buffer_free - free memory allocated with usb_buffer_alloc()

    603  * @dev: device the buffer was used with

    604  * @size: requested buffer size

    605  * @addr: CPU address of buffer

606  * @dma: DMA address of buffer

    607  *

    608  * This reclaims an I/O buffer, letting it be reused.  The memory must have

    609  * been allocated using usb_buffer_alloc(), and the parameters must match

    610  * those provided in that allocation request.

    611  */

    612 void usb_buffer_free(

    613         struct usb_device *dev,

    614         size_t size,

    615         void *addr,

    616         dma_addr_t dma

    617 )

    618 {

    619         if (!dev || !dev->bus)

    620                 return;

    621         if (!addr)

    622                 return;

    623         hcd_buffer_free(dev->bus, size, addr, dma);

    624 }

很显然,它们调用的就是hcd_buffer_alloc和hcd_buffer_free,于是进一步跟踪,来自drivers/usb/core/buffer.c:

     96 /* sometimes alloc/free could use kmalloc with GFP_DMA, for

     97  * better sharing and to leverage mm/slab.c intelligence.

     98  */

     99

    100 void *hcd_buffer_alloc(

    101         struct usb_bus  *bus,

    102         size_t                  size,

    103         gfp_t                   mem_flags,

    104         dma_addr_t              *dma

    105 )

    106 {

    107         struct usb_hcd          *hcd = bus_to_hcd(bus);

    108         int                     i;

    109

    110         /* some USB hosts just use PIO */

    111         if (!bus->controller->dma_mask) {

    112                 *dma = ~(dma_addr_t) 0;

    113                 return kmalloc(size, mem_flags);

    114         }

    115

    116         for (i = 0; i < HCD_BUFFER_POOLS; i++) {

    117                 if (size <= pool_max [i])

    118                         return dma_pool_alloc(hcd->pool [i], mem_flags, dma);

    119         }

    120         return dma_alloc_coherent(hcd->self.controller, size, dma, 0);

    121 }

    122

    123 void hcd_buffer_free(

    124         struct usb_bus  *bus,

    125         size_t                  size,

    126         void                    *addr,

    127         dma_addr_t              dma

    128 )

    129 {

    130         struct usb_hcd          *hcd = bus_to_hcd(bus);

    131         int                     i;

    132

    133         if (!addr)

    134                 return;

    135

    136         if (!bus->controller->dma_mask) {

    137                 kfree(addr);

    138                 return;

    139         }

    140

    141         for (i = 0; i < HCD_BUFFER_POOLS; i++) {

    142                 if (size <= pool_max [i]) {

    143                         dma_pool_free(hcd->pool [i], addr, dma);

    144                         return;

    145                 }

    146         }

    147         dma_free_coherent(hcd->self.controller, size, addr, dma);

    148 }

看见了吧,最终调用的就是dma_pool_alloc和dma_pool_free.那么主机控制器到底支持不支持DMA操作呢?看见上面这个dma_mask了么?默认情况下,dma_mask在总线枚举的时候被函数pci_scan_device中设置为了0xffffffff.struct device结构体有一个成员u64 *dma_mask,如果一个PCI设备不能支持DMA,那么应该在probe函数中调用pci_set_dma_mask把这个dma_mask设置为NULL.不过一个没有精神分裂症的PCI设备通常是支持DMA的.这个掩码更多的作用是,比如你的设备只能支持24位的寻址,那你就得通过设置dma_mask来告诉PCI层,你需要把dma_mask设置为0x00ffffff.因为标准的PCI设备都是32位的寻址的,所以标准情况就是设置的0xffffffff.不过开发者们的建议是不要直接使用这些数字,而是使用它们定义在include/linux/dma-mapping.h中的这些宏:

     16 #define DMA_64BIT_MASK  0xffffffffffffffffULL

     17 #define DMA_48BIT_MASK  0x0000ffffffffffffULL

     18 #define DMA_40BIT_MASK  0x000000ffffffffffULL

     19 #define DMA_39BIT_MASK  0x0000007fffffffffULL

     20 #define DMA_32BIT_MASK  0x00000000ffffffffULL

     21 #define DMA_31BIT_MASK  0x000000007fffffffULL

     22 #define DMA_30BIT_MASK  0x000000003fffffffULL

     23 #define DMA_29BIT_MASK  0x000000001fffffffULL

     24 #define DMA_28BIT_MASK  0x000000000fffffffULL

     25 #define DMA_24BIT_MASK  0x0000000000ffffffULL

不过目前在drivers/usb/目录下面没有哪个驱动会调用pci_set_dma_mask,因为现代总线上的大部分设备都能够处理32位地址,换句话说大家的设备都还算是正经,但如果你们家生产出来一个不伦不类的设备那么你就别忘了在probe阶段用pci_set_dma_mask设置一下,否则你就甭指望设备能够正确的进行DMA传输.关于这个函数的使用,可以参考drivers/net下面的那些驱动,很多网卡驱动都调用了这个函数,虽然其中很多其实就是设置32位.

要不,总结一下?以上这几个DMA函数我们就不细讲了.但需要对某些地方单独拿出来讲.

第一,hcd_buffer_alloc函数中,111行,判断,如果dma_mask为NULL,说明这个主机控制器不支持DMA,那么使用原始的方法申请内存,即kmalloc.然后申请好了就直接返回,而不会继续去执行下面的那个dma_pool_alloc函数.同样的判断在hcd_buffer_free中也是一样的,没有DMA的就直接调用kfree释放内存,而不需要调用dma_pool_free了.

第二,你应该注意到这里还有另外两个函数我们根本没提起, dma_alloc_coherent和dma_free_coherent,这两个函数也是用来申请DMA内存的,但是它们适合申请比较大的内存,比如N个page的那种,而DMA池的作用本来就是提供给小打小闹式的内存申请的.当前的USB子系统里在drivers/usb/core/buffer.c中定义了一个数组:

     25 /* FIXME tune these based on pool statistics ... */

     26 static const size_t     pool_max [HCD_BUFFER_POOLS] = {

     27         /* platforms without dma-friendly caches might need to

     28          * prevent cacheline sharing...

     29          */

     30         32,

     31         128,

     32         512,

     33         PAGE_SIZE / 2

     34         /* bigger --> allocate pages */

     35 };

HCD_BUFFER_POOLS这个宏的值为4.结合hcd_buffer_alloc函数里面那个循环来看,可以知道,你要是申请个32个字节以内,128个字节以内,512个字节以内,或者最多二分之一个PAGE_SIZE以内的,就直接使用这个内存池了,否则的话,就得用那个dma_alloc_coherent了.释放的时候也一样.

第三,struct usb_hcd结构体有这么一个成员,struct dma_pool         *pool [HCD_BUFFER_POOLS], 这个数组的值是在hcd_buffer_create中赋上的,即当时以这个pool_max为模型创建了4个池子,所以hcd_buffer_alloc里就可以这样用.

第四,至于像dma_pool_create/dma_pool_alloc/dma_alloc_coherent这些函数具体怎么实现的我想任何一个写设备驱动程序的都不用关心吧,倒是我有两个同事会比较感兴趣,因为他们是研究内存管理的.

Ok,讲完了hcd_buffer_create让我们还是回到usb_add_hcd中来,继续往下走.