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");
264