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 /**
 119  * pci_epc_mem_init() - Initialize the pci_epc_mem structure
 120  * @epc: the EPC device that invoked pci_epc_mem_init
 121  * @base: Physical address of the window region
 122  * @size: Total Size of the window region
 123  * @page_size: Page size of the window region
 124  *
 125  * Invoke to initialize a single pci_epc_mem structure used by the
 126  * endpoint functions to allocate memory for mapping the PCI host memory
 127  */
 128 int pci_epc_mem_init(struct pci_epc *epc, phys_addr_t base,
 129                      size_t size, size_t page_size)
 130 {
 131         struct pci_epc_mem_window mem_window;
 132
 133         mem_window.phys_base = base;
 134         mem_window.size = size;
 135         mem_window.page_size = page_size;
 136
 137         return pci_epc_multi_mem_init(epc, &mem_window, 1);
 138 }
 139 EXPORT_SYMBOL_GPL(pci_epc_mem_init);
 140
 141 /**
 142  * pci_epc_mem_exit() - cleanup the pci_epc_mem structure
 143  * @epc: the EPC device that invoked pci_epc_mem_exit
 144  *
 145  * Invoke to cleanup the pci_epc_mem structure allocated in
 146  * pci_epc_mem_init().
 147  */
 148 void pci_epc_mem_exit(struct pci_epc *epc)
 149 {
 150         struct pci_epc_mem *mem;
 151         int i;
 152
 153         if (!epc->num_windows)
 154                 return;
 155
 156         for (i = 0; i < epc->num_windows; i++) {
 157                 mem = epc->windows[i];
 158                 kfree(mem->bitmap);
 159                 kfree(mem);
 160         }
 161         kfree(epc->windows);
 162
 163         epc->windows = NULL;
 164         epc->mem = NULL;
 165         epc->num_windows = 0;
 166 }
 167 EXPORT_SYMBOL_GPL(pci_epc_mem_exit);
 168
 169 /**
 170  * pci_epc_mem_alloc_addr() - allocate memory address from EPC addr space
 171  * @epc: the EPC device on which memory has to be allocated
 172  * @phys_addr: populate the allocated physical address here
 173  * @size: the size of the address space that has to be allocated
 174  *
 175  * Invoke to allocate memory address from the EPC address space. This
 176  * is usually done to map the remote RC address into the local system.
 177  */
 178 void __iomem *pci_epc_mem_alloc_addr(struct pci_epc *epc,
 179                                      phys_addr_t *phys_addr, size_t size)
 180 {
 181         void __iomem *virt_addr;
 182         struct pci_epc_mem *mem;
 183         unsigned int page_shift;
 184         size_t align_size;
 185         int pageno;
 186         int order;
 187         int i;
 188
 189         for (i = 0; i < epc->num_windows; i++) {
 190                 mem = epc->windows[i];
 191                 if (size > mem->window.size)
 192                         continue;
 193
 194                 align_size = ALIGN(size, mem->window.page_size);
 195                 order = pci_epc_mem_get_order(mem, align_size);
 196
 197                 mutex_lock(&mem->lock);
 198                 pageno = bitmap_find_free_region(mem->bitmap, mem->pages,
 199                                                  order);
 200                 if (pageno >= 0) {
 201                         page_shift = ilog2(mem->window.page_size);
 202                         *phys_addr = mem->window.phys_base +
 203                                 ((phys_addr_t)pageno << page_shift);
 204                         virt_addr = ioremap(*phys_addr, align_size);
 205                         if (!virt_addr) {
 206                                 bitmap_release_region(mem->bitmap,
 207                                                       pageno, order);
 208                                 mutex_unlock(&mem->lock);
 209                                 continue;
 210                         }
 211                         mutex_unlock(&mem->lock);
 212                         return virt_addr;
 213                 }
 214                 mutex_unlock(&mem->lock);
 215         }
 216
 217         return NULL;
 218 }
 219 EXPORT_SYMBOL_GPL(pci_epc_mem_alloc_addr);
 220
 221 static struct pci_epc_mem *pci_epc_get_matching_window(struct pci_epc *epc,
 222                                                        phys_addr_t phys_addr)
 223 {
 224         struct pci_epc_mem *mem;
 225         int i;
 226
 227         for (i = 0; i < epc->num_windows; i++) {
 228                 mem = epc->windows[i];
 229
 230                 if (phys_addr >= mem->window.phys_base &&
 231                     phys_addr < (mem->window.phys_base + mem->window.size))
 232                         return mem;
 233         }
 234
 235         return NULL;
 236 }
 237
 238 /**
 239  * pci_epc_mem_free_addr() - free the allocated memory address
 240  * @epc: the EPC device on which memory was allocated
 241  * @phys_addr: the allocated physical address
 242  * @virt_addr: virtual address of the allocated mem space
 243  * @size: the size of the allocated address space
 244  *
 245  * Invoke to free the memory allocated using pci_epc_mem_alloc_addr.
 246  */
 247 void pci_epc_mem_free_addr(struct pci_epc *epc, phys_addr_t phys_addr,
 248                            void __iomem *virt_addr, size_t size)
 249 {
 250         struct pci_epc_mem *mem;
 251         unsigned int page_shift;
 252         size_t page_size;
 253         int pageno;
 254         int order;
 255
 256         mem = pci_epc_get_matching_window(epc, phys_addr);
 257         if (!mem) {
 258                 pr_err("failed to get matching window\n");
 259                 return;
 260         }
 261
 262         page_size = mem->window.page_size;
 263         page_shift = ilog2(page_size);
 264         iounmap(virt_addr);
 265         pageno = (phys_addr - mem->window.phys_base) >> page_shift;
 266         size = ALIGN(size, page_size);
 267         order = pci_epc_mem_get_order(mem, size);
 268         mutex_lock(&mem->lock);
 269         bitmap_release_region(mem->bitmap, pageno, order);
 270         mutex_unlock(&mem->lock);
 271 }
 272 EXPORT_SYMBOL_GPL(pci_epc_mem_free_addr);
 273
 274 MODULE_DESCRIPTION("PCI EPC Address Space Management");
 275 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");