drivers/pci/endpoint/pci-epc-mem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * PCI Endpoint *Controller* Address Space Management
   4  *
   5  * Copyright (C) 2017 Texas Instruments
   6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
   7  */
   8
   9 #include <linux/io.h>
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12
  13 #include <linux/pci-epc.h>
  14
  15 /**
  16  * pci_epc_mem_get_order() - determine the allocation order of a memory size
  17  * @mem: address space of the endpoint controller
  18  * @size: the size for which to get the order
  19  *
  20  * Reimplement get_order() for mem->page_size since the generic get_order
  21  * always gets order with a constant PAGE_SIZE.
  22  */
  23 static int pci_epc_mem_get_order(struct pci_epc_mem *mem, size_t size)
  24 {
  25         int order;
  26         unsigned int page_shift = ilog2(mem->window.page_size);
  27
  28         size--;
  29         size >>= page_shift;
  30 #if BITS_PER_LONG == 32
  31         order = fls(size);
  32 #else
  33         order = fls64(size);
  34 #endif
  35         return order;
  36 }
  37
  38 /**
  39  * pci_epc_multi_mem_init() - initialize the pci_epc_mem structure
  40  * @epc: the EPC device that invoked pci_epc_mem_init
  41  * @windows: pointer to windows supported by the device
  42  * @num_windows: number of windows device supports
  43  *
  44  * Invoke to initialize the pci_epc_mem structure used by the
  45  * endpoint functions to allocate mapped PCI address.
  46  */
  47 int pci_epc_multi_mem_init(struct pci_epc *epc,
  48                            struct pci_epc_mem_window *windows,
  49                            unsigned int num_windows)
  50 {
  51         struct pci_epc_mem *mem = NULL;
  52         unsigned long *bitmap = NULL;
  53         unsigned int page_shift;
  54         size_t page_size;
  55         int bitmap_size;
  56         int pages;
  57         int ret;
  58         int i;
  59
  60         epc->num_windows = 0;
  61
  62         if (!windows || !num_windows)
  63                 return -EINVAL;
  64
  65         epc->windows = kcalloc(num_windows, sizeof(*epc->windows), GFP_KERNEL);
  66         if (!epc->windows)
  67                 return -ENOMEM;
  68
  69         for (i = 0; i < num_windows; i++) {
  70                 page_size = windows[i].page_size;
  71                 if (page_size < PAGE_SIZE)
  72                         page_size = PAGE_SIZE;
  73                 page_shift = ilog2(page_size);
  74                 pages = windows[i].size >> page_shift;
  75                 bitmap_size = BITS_TO_LONGS(pages) * sizeof(long);
  76
  77                 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
  78                 if (!mem) {
  79                         ret = -ENOMEM;
  80                         i--;
  81                         goto err_mem;
  82                 }
  83
  84                 bitmap = kzalloc(bitmap_size, GFP_KERNEL);
  85                 if (!bitmap) {
  86                         ret = -ENOMEM;
  87                         kfree(mem);
  88                         i--;
  89                         goto err_mem;
  90                 }
  91
  92                 mem->window.phys_base = windows[i].phys_base;
  93                 mem->window.size = windows[i].size;
  94                 mem->window.page_size = page_size;
  95                 mem->bitmap = bitmap;
  96                 mem->pages = pages;
  97                 mutex_init(&mem->lock);
  98                 epc->windows[i] = mem;
  99         }
 100
 101         epc->mem = epc->windows[0];
 102         epc->num_windows = num_windows;
 103
 104         return 0;
 105
 106 err_mem:
 107         for (; i >= 0; i--) {
 108                 mem = epc->windows[i];
 109                 kfree(mem->bitmap);
 110                 kfree(mem);
 111         }
 112         kfree(epc->windows);
 113
 114         return ret;
 115 }
 116 EXPORT_SYMBOL_GPL(pci_epc_multi_mem_init);
 117
 118 int pci_epc_mem_init(struct pci_epc *epc, phys_addr_t base,
 119                      size_t size, size_t page_size)
 120 {
 121         struct pci_epc_mem_window mem_window;
 122
 123         mem_window.phys_base = base;
 124         mem_window.size = size;
 125         mem_window.page_size = page_size;
 126
 127         return pci_epc_multi_mem_init(epc, &mem_window, 1);
 128 }
 129 EXPORT_SYMBOL_GPL(pci_epc_mem_init);
 130
 131 /**
 132  * pci_epc_mem_exit() - cleanup the pci_epc_mem structure
 133  * @epc: the EPC device that invoked pci_epc_mem_exit
 134  *
 135  * Invoke to cleanup the pci_epc_mem structure allocated in
 136  * pci_epc_mem_init().
 137  */
 138 void pci_epc_mem_exit(struct pci_epc *epc)
 139 {
 140         struct pci_epc_mem *mem;
 141         int i;
 142
 143         if (!epc->num_windows)
 144                 return;
 145
 146         for (i = 0; i < epc->num_windows; i++) {
 147                 mem = epc->windows[i];
 148                 kfree(mem->bitmap);
 149                 kfree(mem);
 150         }
 151         kfree(epc->windows);
 152
 153         epc->windows = NULL;
 154         epc->mem = NULL;
 155         epc->num_windows = 0;
 156 }
 157 EXPORT_SYMBOL_GPL(pci_epc_mem_exit);
 158
 159 /**
 160  * pci_epc_mem_alloc_addr() - allocate memory address from EPC addr space
 161  * @epc: the EPC device on which memory has to be allocated
 162  * @phys_addr: populate the allocated physical address here
 163  * @size: the size of the address space that has to be allocated
 164  *
 165  * Invoke to allocate memory address from the EPC address space. This
 166  * is usually done to map the remote RC address into the local system.
 167  */
 168 void __iomem *pci_epc_mem_alloc_addr(struct pci_epc *epc,
 169                                      phys_addr_t *phys_addr, size_t size)
 170 {
 171         void __iomem *virt_addr = NULL;
 172         struct pci_epc_mem *mem;
 173         unsigned int page_shift;
 174         size_t align_size;
 175         int pageno;
 176         int order;
 177         int i;
 178
 179         for (i = 0; i < epc->num_windows; i++) {
 180                 mem = epc->windows[i];
 181                 mutex_lock(&mem->lock);
 182                 align_size = ALIGN(size, mem->window.page_size);
 183                 order = pci_epc_mem_get_order(mem, align_size);
 184
 185                 pageno = bitmap_find_free_region(mem->bitmap, mem->pages,
 186                                                  order);
 187                 if (pageno >= 0) {
 188                         page_shift = ilog2(mem->window.page_size);
 189                         *phys_addr = mem->window.phys_base +
 190                                 ((phys_addr_t)pageno << page_shift);
 191                         virt_addr = ioremap(*phys_addr, align_size);
 192                         if (!virt_addr) {
 193                                 bitmap_release_region(mem->bitmap,
 194                                                       pageno, order);
 195                                 mutex_unlock(&mem->lock);
 196                                 continue;
 197                         }
 198                         mutex_unlock(&mem->lock);
 199                         return virt_addr;
 200                 }
 201                 mutex_unlock(&mem->lock);
 202         }
 203
 204         return virt_addr;
 205 }
 206 EXPORT_SYMBOL_GPL(pci_epc_mem_alloc_addr);
 207
 208 static struct pci_epc_mem *pci_epc_get_matching_window(struct pci_epc *epc,
 209                                                        phys_addr_t phys_addr)
 210 {
 211         struct pci_epc_mem *mem;
 212         int i;
 213
 214         for (i = 0; i < epc->num_windows; i++) {
 215                 mem = epc->windows[i];
 216
 217                 if (phys_addr >= mem->window.phys_base &&
 218                     phys_addr < (mem->window.phys_base + mem->window.size))
 219                         return mem;
 220         }
 221
 222         return NULL;
 223 }
 224
 225 /**
 226  * pci_epc_mem_free_addr() - free the allocated memory address
 227  * @epc: the EPC device on which memory was allocated
 228  * @phys_addr: the allocated physical address
 229  * @virt_addr: virtual address of the allocated mem space
 230  * @size: the size of the allocated address space
 231  *
 232  * Invoke to free the memory allocated using pci_epc_mem_alloc_addr.
 233  */
 234 void pci_epc_mem_free_addr(struct pci_epc *epc, phys_addr_t phys_addr,
 235                            void __iomem *virt_addr, size_t size)
 236 {
 237         struct pci_epc_mem *mem;
 238         unsigned int page_shift;
 239         size_t page_size;
 240         int pageno;
 241         int order;
 242
 243         mem = pci_epc_get_matching_window(epc, phys_addr);
 244         if (!mem) {
 245                 pr_err("failed to get matching window\n");
 246                 return;
 247         }
 248
 249         page_size = mem->window.page_size;
 250         page_shift = ilog2(page_size);
 251         iounmap(virt_addr);
 252         pageno = (phys_addr - mem->window.phys_base) >> page_shift;
 253         size = ALIGN(size, page_size);
 254         order = pci_epc_mem_get_order(mem, size);
 255         mutex_lock(&mem->lock);
 256         bitmap_release_region(mem->bitmap, pageno, order);
 257         mutex_unlock(&mem->lock);
 258 }
 259 EXPORT_SYMBOL_GPL(pci_epc_mem_free_addr);
 260
 261 MODULE_DESCRIPTION("PCI EPC Address Space Management");
 262 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
 263 MODULE_LICENSE("GPL v2");