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