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->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_mem_init() - initialize the pci_epc_mem structure 40 * @epc: the EPC device that invoked pci_epc_mem_init 41 * @phys_base: the physical address of the base 42 * @size: the size of the address space 43 * @page_size: size of each page 44 * 45 * Invoke to initialize the pci_epc_mem structure used by the 46 * endpoint functions to allocate mapped PCI address. 47 */ 48 int __pci_epc_mem_init(struct pci_epc *epc, phys_addr_t phys_base, size_t size, 49 size_t page_size) 50 { 51 int ret; 52 struct pci_epc_mem *mem; 53 unsigned long *bitmap; 54 unsigned int page_shift; 55 int pages; 56 int bitmap_size; 57 58 if (page_size < PAGE_SIZE) 59 page_size = PAGE_SIZE; 60 61 page_shift = ilog2(page_size); 62 pages = size >> page_shift; 63 bitmap_size = BITS_TO_LONGS(pages) * sizeof(long); 64 65 mem = kzalloc(sizeof(*mem), GFP_KERNEL); 66 if (!mem) { 67 ret = -ENOMEM; 68 goto err; 69 } 70 71 bitmap = kzalloc(bitmap_size, GFP_KERNEL); 72 if (!bitmap) { 73 ret = -ENOMEM; 74 goto err_mem; 75 } 76 77 mem->bitmap = bitmap; 78 mem->phys_base = phys_base; 79 mem->page_size = page_size; 80 mem->pages = pages; 81 mem->size = size; 82 83 epc->mem = mem; 84 85 return 0; 86 87 err_mem: 88 kfree(mem); 89 90 err: 91 return ret; 92 } 93 EXPORT_SYMBOL_GPL(__pci_epc_mem_init); 94 95 /** 96 * pci_epc_mem_exit() - cleanup the pci_epc_mem structure 97 * @epc: the EPC device that invoked pci_epc_mem_exit 98 * 99 * Invoke to cleanup the pci_epc_mem structure allocated in 100 * pci_epc_mem_init(). 101 */ 102 void pci_epc_mem_exit(struct pci_epc *epc) 103 { 104 struct pci_epc_mem *mem = epc->mem; 105 106 epc->mem = NULL; 107 kfree(mem->bitmap); 108 kfree(mem); 109 } 110 EXPORT_SYMBOL_GPL(pci_epc_mem_exit); 111 112 /** 113 * pci_epc_mem_alloc_addr() - allocate memory address from EPC addr space 114 * @epc: the EPC device on which memory has to be allocated 115 * @phys_addr: populate the allocated physical address here 116 * @size: the size of the address space that has to be allocated 117 * 118 * Invoke to allocate memory address from the EPC address space. This 119 * is usually done to map the remote RC address into the local system. 120 */ 121 void __iomem *pci_epc_mem_alloc_addr(struct pci_epc *epc, 122 phys_addr_t *phys_addr, size_t size) 123 { 124 int pageno; 125 void __iomem *virt_addr; 126 struct pci_epc_mem *mem = epc->mem; 127 unsigned int page_shift = ilog2(mem->page_size); 128 int order; 129 130 size = ALIGN(size, mem->page_size); 131 order = pci_epc_mem_get_order(mem, size); 132 133 pageno = bitmap_find_free_region(mem->bitmap, mem->pages, order); 134 if (pageno < 0) 135 return NULL; 136 137 *phys_addr = mem->phys_base + ((phys_addr_t)pageno << page_shift); 138 virt_addr = ioremap(*phys_addr, size); 139 if (!virt_addr) 140 bitmap_release_region(mem->bitmap, pageno, order); 141 142 return virt_addr; 143 } 144 EXPORT_SYMBOL_GPL(pci_epc_mem_alloc_addr); 145 146 /** 147 * pci_epc_mem_free_addr() - free the allocated memory address 148 * @epc: the EPC device on which memory was allocated 149 * @phys_addr: the allocated physical address 150 * @virt_addr: virtual address of the allocated mem space 151 * @size: the size of the allocated address space 152 * 153 * Invoke to free the memory allocated using pci_epc_mem_alloc_addr. 154 */ 155 void pci_epc_mem_free_addr(struct pci_epc *epc, phys_addr_t phys_addr, 156 void __iomem *virt_addr, size_t size) 157 { 158 int pageno; 159 struct pci_epc_mem *mem = epc->mem; 160 unsigned int page_shift = ilog2(mem->page_size); 161 int order; 162 163 iounmap(virt_addr); 164 pageno = (phys_addr - mem->phys_base) >> page_shift; 165 size = ALIGN(size, mem->page_size); 166 order = pci_epc_mem_get_order(mem, size); 167 bitmap_release_region(mem->bitmap, pageno, order); 168 } 169 EXPORT_SYMBOL_GPL(pci_epc_mem_free_addr); 170 171 MODULE_DESCRIPTION("PCI EPC Address Space Management"); 172 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>"); 173 MODULE_LICENSE("GPL v2"); 174