Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * DMA memory management for framework level HCD code (hc_driver)
       4                 :            :  *
       5                 :            :  * This implementation plugs in through generic "usb_bus" level methods,
       6                 :            :  * and should work with all USB controllers, regardless of bus type.
       7                 :            :  *
       8                 :            :  * Released under the GPLv2 only.
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/module.h>
      12                 :            : #include <linux/kernel.h>
      13                 :            : #include <linux/slab.h>
      14                 :            : #include <linux/device.h>
      15                 :            : #include <linux/mm.h>
      16                 :            : #include <linux/io.h>
      17                 :            : #include <linux/dma-mapping.h>
      18                 :            : #include <linux/dmapool.h>
      19                 :            : #include <linux/genalloc.h>
      20                 :            : #include <linux/usb.h>
      21                 :            : #include <linux/usb/hcd.h>
      22                 :            : 
      23                 :            : 
      24                 :            : /*
      25                 :            :  * DMA-Coherent Buffers
      26                 :            :  */
      27                 :            : 
      28                 :            : /* FIXME tune these based on pool statistics ... */
      29                 :            : static size_t pool_max[HCD_BUFFER_POOLS] = {
      30                 :            :         32, 128, 512, 2048,
      31                 :            : };
      32                 :            : 
      33                 :          3 : void __init usb_init_pool_max(void)
      34                 :            : {
      35                 :            :         /*
      36                 :            :          * The pool_max values must never be smaller than
      37                 :            :          * ARCH_KMALLOC_MINALIGN.
      38                 :            :          */
      39                 :            :         if (ARCH_KMALLOC_MINALIGN <= 32)
      40                 :            :                 ;                       /* Original value is okay */
      41                 :            :         else if (ARCH_KMALLOC_MINALIGN <= 64)
      42                 :          3 :                 pool_max[0] = 64;
      43                 :            :         else if (ARCH_KMALLOC_MINALIGN <= 128)
      44                 :            :                 pool_max[0] = 0;        /* Don't use this pool */
      45                 :            :         else
      46                 :            :                 BUILD_BUG();            /* We don't allow this */
      47                 :          3 : }
      48                 :            : 
      49                 :            : /* SETUP primitives */
      50                 :            : 
      51                 :            : /**
      52                 :            :  * hcd_buffer_create - initialize buffer pools
      53                 :            :  * @hcd: the bus whose buffer pools are to be initialized
      54                 :            :  * Context: !in_interrupt()
      55                 :            :  *
      56                 :            :  * Call this as part of initializing a host controller that uses the dma
      57                 :            :  * memory allocators.  It initializes some pools of dma-coherent memory that
      58                 :            :  * will be shared by all drivers using that controller.
      59                 :            :  *
      60                 :            :  * Call hcd_buffer_destroy() to clean up after using those pools.
      61                 :            :  *
      62                 :            :  * Return: 0 if successful. A negative errno value otherwise.
      63                 :            :  */
      64                 :          3 : int hcd_buffer_create(struct usb_hcd *hcd)
      65                 :            : {
      66                 :            :         char            name[16];
      67                 :            :         int             i, size;
      68                 :            : 
      69                 :          3 :         if (hcd->localmem_pool || !hcd_uses_dma(hcd))
      70                 :            :                 return 0;
      71                 :            : 
      72                 :          3 :         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
      73                 :          3 :                 size = pool_max[i];
      74                 :          3 :                 if (!size)
      75                 :          0 :                         continue;
      76                 :          3 :                 snprintf(name, sizeof(name), "buffer-%d", size);
      77                 :          3 :                 hcd->pool[i] = dma_pool_create(name, hcd->self.sysdev,
      78                 :            :                                 size, size, 0);
      79                 :          3 :                 if (!hcd->pool[i]) {
      80                 :            :                         hcd_buffer_destroy(hcd);
      81                 :            :                         return -ENOMEM;
      82                 :            :                 }
      83                 :            :         }
      84                 :            :         return 0;
      85                 :            : }
      86                 :            : 
      87                 :            : 
      88                 :            : /**
      89                 :            :  * hcd_buffer_destroy - deallocate buffer pools
      90                 :            :  * @hcd: the bus whose buffer pools are to be destroyed
      91                 :            :  * Context: !in_interrupt()
      92                 :            :  *
      93                 :            :  * This frees the buffer pools created by hcd_buffer_create().
      94                 :            :  */
      95                 :          0 : void hcd_buffer_destroy(struct usb_hcd *hcd)
      96                 :            : {
      97                 :            :         int i;
      98                 :            : 
      99                 :            :         if (!IS_ENABLED(CONFIG_HAS_DMA))
     100                 :          0 :                 return;
     101                 :            : 
     102                 :          0 :         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
     103                 :          0 :                 dma_pool_destroy(hcd->pool[i]);
     104                 :          0 :                 hcd->pool[i] = NULL;
     105                 :            :         }
     106                 :            : }
     107                 :            : 
     108                 :            : 
     109                 :            : /* sometimes alloc/free could use kmalloc with GFP_DMA, for
     110                 :            :  * better sharing and to leverage mm/slab.c intelligence.
     111                 :            :  */
     112                 :            : 
     113                 :          3 : void *hcd_buffer_alloc(
     114                 :            :         struct usb_bus          *bus,
     115                 :            :         size_t                  size,
     116                 :            :         gfp_t                   mem_flags,
     117                 :            :         dma_addr_t              *dma
     118                 :            : )
     119                 :            : {
     120                 :            :         struct usb_hcd          *hcd = bus_to_hcd(bus);
     121                 :            :         int                     i;
     122                 :            : 
     123                 :          3 :         if (size == 0)
     124                 :            :                 return NULL;
     125                 :            : 
     126                 :          3 :         if (hcd->localmem_pool)
     127                 :          0 :                 return gen_pool_dma_alloc(hcd->localmem_pool, size, dma);
     128                 :            : 
     129                 :            :         /* some USB hosts just use PIO */
     130                 :          3 :         if (!hcd_uses_dma(hcd)) {
     131                 :          0 :                 *dma = ~(dma_addr_t) 0;
     132                 :          0 :                 return kmalloc(size, mem_flags);
     133                 :            :         }
     134                 :            : 
     135                 :          0 :         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
     136                 :          3 :                 if (size <= pool_max[i])
     137                 :          3 :                         return dma_pool_alloc(hcd->pool[i], mem_flags, dma);
     138                 :            :         }
     139                 :          0 :         return dma_alloc_coherent(hcd->self.sysdev, size, dma, mem_flags);
     140                 :            : }
     141                 :            : 
     142                 :          0 : void hcd_buffer_free(
     143                 :            :         struct usb_bus          *bus,
     144                 :            :         size_t                  size,
     145                 :            :         void                    *addr,
     146                 :            :         dma_addr_t              dma
     147                 :            : )
     148                 :            : {
     149                 :            :         struct usb_hcd          *hcd = bus_to_hcd(bus);
     150                 :            :         int                     i;
     151                 :            : 
     152                 :          0 :         if (!addr)
     153                 :            :                 return;
     154                 :            : 
     155                 :          0 :         if (hcd->localmem_pool) {
     156                 :          0 :                 gen_pool_free(hcd->localmem_pool, (unsigned long)addr, size);
     157                 :            :                 return;
     158                 :            :         }
     159                 :            : 
     160                 :          0 :         if (!hcd_uses_dma(hcd)) {
     161                 :          0 :                 kfree(addr);
     162                 :          0 :                 return;
     163                 :            :         }
     164                 :            : 
     165                 :          0 :         for (i = 0; i < HCD_BUFFER_POOLS; i++) {
     166                 :          0 :                 if (size <= pool_max[i]) {
     167                 :          0 :                         dma_pool_free(hcd->pool[i], addr, dma);
     168                 :          0 :                         return;
     169                 :            :                 }
     170                 :            :         }
     171                 :          0 :         dma_free_coherent(hcd->self.sysdev, size, addr, dma);
     172                 :            : }