1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Copyright (C) 2017 HiSilicon Limited, All Rights Reserved. |
4 | * Author: Gabriele Paoloni <gabriele.paoloni@huawei.com> |
5 | * Author: Zhichang Yuan <yuanzhichang@hisilicon.com> |
6 | * Author: John Garry <john.garry@huawei.com> |
7 | */ |
8 | |
9 | #define pr_fmt(fmt) "LOGIC PIO: " fmt |
10 | |
11 | #include <linux/of.h> |
12 | #include <linux/io.h> |
13 | #include <linux/logic_pio.h> |
14 | #include <linux/mm.h> |
15 | #include <linux/rculist.h> |
16 | #include <linux/sizes.h> |
17 | #include <linux/slab.h> |
18 | |
19 | /* The unique hardware address list */ |
20 | static LIST_HEAD(io_range_list); |
21 | static DEFINE_MUTEX(io_range_mutex); |
22 | |
23 | /** |
24 | * logic_pio_register_range - register logical PIO range for a host |
25 | * @new_range: pointer to the IO range to be registered. |
26 | * |
27 | * Returns 0 on success, the error code in case of failure. |
28 | * If the range already exists, -EEXIST will be returned, which should be |
29 | * considered a success. |
30 | * |
31 | * Register a new IO range node in the IO range list. |
32 | */ |
33 | int logic_pio_register_range(struct logic_pio_hwaddr *new_range) |
34 | { |
35 | struct logic_pio_hwaddr *range; |
36 | resource_size_t start; |
37 | resource_size_t end; |
38 | resource_size_t mmio_end = 0; |
39 | resource_size_t iio_sz = MMIO_UPPER_LIMIT; |
40 | int ret = 0; |
41 | |
42 | if (!new_range || !new_range->fwnode || !new_range->size || |
43 | (new_range->flags == LOGIC_PIO_INDIRECT && !new_range->ops)) |
44 | return -EINVAL; |
45 | |
46 | start = new_range->hw_start; |
47 | end = new_range->hw_start + new_range->size; |
48 | |
49 | mutex_lock(&io_range_mutex); |
50 | list_for_each_entry(range, &io_range_list, list) { |
51 | if (range->fwnode == new_range->fwnode) { |
52 | /* range already there */ |
53 | ret = -EEXIST; |
54 | goto end_register; |
55 | } |
56 | if (range->flags == LOGIC_PIO_CPU_MMIO && |
57 | new_range->flags == LOGIC_PIO_CPU_MMIO) { |
58 | /* for MMIO ranges we need to check for overlap */ |
59 | if (start >= range->hw_start + range->size || |
60 | end < range->hw_start) { |
61 | mmio_end = range->io_start + range->size; |
62 | } else { |
63 | ret = -EFAULT; |
64 | goto end_register; |
65 | } |
66 | } else if (range->flags == LOGIC_PIO_INDIRECT && |
67 | new_range->flags == LOGIC_PIO_INDIRECT) { |
68 | iio_sz += range->size; |
69 | } |
70 | } |
71 | |
72 | /* range not registered yet, check for available space */ |
73 | if (new_range->flags == LOGIC_PIO_CPU_MMIO) { |
74 | if (mmio_end + new_range->size - 1 > MMIO_UPPER_LIMIT) { |
75 | /* if it's too big check if 64K space can be reserved */ |
76 | if (mmio_end + SZ_64K - 1 > MMIO_UPPER_LIMIT) { |
77 | ret = -E2BIG; |
78 | goto end_register; |
79 | } |
80 | new_range->size = SZ_64K; |
81 | pr_warn("Requested IO range too big, new size set to 64K\n" ); |
82 | } |
83 | new_range->io_start = mmio_end; |
84 | } else if (new_range->flags == LOGIC_PIO_INDIRECT) { |
85 | if (iio_sz + new_range->size - 1 > IO_SPACE_LIMIT) { |
86 | ret = -E2BIG; |
87 | goto end_register; |
88 | } |
89 | new_range->io_start = iio_sz; |
90 | } else { |
91 | /* invalid flag */ |
92 | ret = -EINVAL; |
93 | goto end_register; |
94 | } |
95 | |
96 | list_add_tail_rcu(new: &new_range->list, head: &io_range_list); |
97 | |
98 | end_register: |
99 | mutex_unlock(lock: &io_range_mutex); |
100 | return ret; |
101 | } |
102 | |
103 | /** |
104 | * logic_pio_unregister_range - unregister a logical PIO range for a host |
105 | * @range: pointer to the IO range which has been already registered. |
106 | * |
107 | * Unregister a previously-registered IO range node. |
108 | */ |
109 | void logic_pio_unregister_range(struct logic_pio_hwaddr *range) |
110 | { |
111 | mutex_lock(&io_range_mutex); |
112 | list_del_rcu(entry: &range->list); |
113 | mutex_unlock(lock: &io_range_mutex); |
114 | synchronize_rcu(); |
115 | } |
116 | |
117 | /** |
118 | * find_io_range_by_fwnode - find logical PIO range for given FW node |
119 | * @fwnode: FW node handle associated with logical PIO range |
120 | * |
121 | * Returns pointer to node on success, NULL otherwise. |
122 | * |
123 | * Traverse the io_range_list to find the registered node for @fwnode. |
124 | */ |
125 | struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode) |
126 | { |
127 | struct logic_pio_hwaddr *range, *found_range = NULL; |
128 | |
129 | rcu_read_lock(); |
130 | list_for_each_entry_rcu(range, &io_range_list, list) { |
131 | if (range->fwnode == fwnode) { |
132 | found_range = range; |
133 | break; |
134 | } |
135 | } |
136 | rcu_read_unlock(); |
137 | |
138 | return found_range; |
139 | } |
140 | |
141 | /* Return a registered range given an input PIO token */ |
142 | static struct logic_pio_hwaddr *find_io_range(unsigned long pio) |
143 | { |
144 | struct logic_pio_hwaddr *range, *found_range = NULL; |
145 | |
146 | rcu_read_lock(); |
147 | list_for_each_entry_rcu(range, &io_range_list, list) { |
148 | if (in_range(pio, range->io_start, range->size)) { |
149 | found_range = range; |
150 | break; |
151 | } |
152 | } |
153 | rcu_read_unlock(); |
154 | |
155 | if (!found_range) |
156 | pr_err("PIO entry token 0x%lx invalid\n" , pio); |
157 | |
158 | return found_range; |
159 | } |
160 | |
161 | /** |
162 | * logic_pio_to_hwaddr - translate logical PIO to HW address |
163 | * @pio: logical PIO value |
164 | * |
165 | * Returns HW address if valid, ~0 otherwise. |
166 | * |
167 | * Translate the input logical PIO to the corresponding hardware address. |
168 | * The input PIO should be unique in the whole logical PIO space. |
169 | */ |
170 | resource_size_t logic_pio_to_hwaddr(unsigned long pio) |
171 | { |
172 | struct logic_pio_hwaddr *range; |
173 | |
174 | range = find_io_range(pio); |
175 | if (range) |
176 | return range->hw_start + pio - range->io_start; |
177 | |
178 | return (resource_size_t)~0; |
179 | } |
180 | |
181 | /** |
182 | * logic_pio_trans_hwaddr - translate HW address to logical PIO |
183 | * @fwnode: FW node reference for the host |
184 | * @addr: Host-relative HW address |
185 | * @size: size to translate |
186 | * |
187 | * Returns Logical PIO value if successful, ~0UL otherwise |
188 | */ |
189 | unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode, |
190 | resource_size_t addr, resource_size_t size) |
191 | { |
192 | struct logic_pio_hwaddr *range; |
193 | |
194 | range = find_io_range_by_fwnode(fwnode); |
195 | if (!range || range->flags == LOGIC_PIO_CPU_MMIO) { |
196 | pr_err("IO range not found or invalid\n" ); |
197 | return ~0UL; |
198 | } |
199 | if (range->size < size) { |
200 | pr_err("resource size %pa cannot fit in IO range size %pa\n" , |
201 | &size, &range->size); |
202 | return ~0UL; |
203 | } |
204 | return addr - range->hw_start + range->io_start; |
205 | } |
206 | |
207 | unsigned long logic_pio_trans_cpuaddr(resource_size_t addr) |
208 | { |
209 | struct logic_pio_hwaddr *range; |
210 | |
211 | rcu_read_lock(); |
212 | list_for_each_entry_rcu(range, &io_range_list, list) { |
213 | if (range->flags != LOGIC_PIO_CPU_MMIO) |
214 | continue; |
215 | if (in_range(addr, range->hw_start, range->size)) { |
216 | unsigned long cpuaddr; |
217 | |
218 | cpuaddr = addr - range->hw_start + range->io_start; |
219 | |
220 | rcu_read_unlock(); |
221 | return cpuaddr; |
222 | } |
223 | } |
224 | rcu_read_unlock(); |
225 | |
226 | pr_err("addr %pa not registered in io_range_list\n" , &addr); |
227 | |
228 | return ~0UL; |
229 | } |
230 | |
231 | #if defined(CONFIG_INDIRECT_PIO) && defined(PCI_IOBASE) |
232 | #define BUILD_LOGIC_IO(bwl, type) \ |
233 | type logic_in##bwl(unsigned long addr) \ |
234 | { \ |
235 | type ret = (type)~0; \ |
236 | \ |
237 | if (addr < MMIO_UPPER_LIMIT) { \ |
238 | ret = _in##bwl(addr); \ |
239 | } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ |
240 | struct logic_pio_hwaddr *entry = find_io_range(addr); \ |
241 | \ |
242 | if (entry) \ |
243 | ret = entry->ops->in(entry->hostdata, \ |
244 | addr, sizeof(type)); \ |
245 | else \ |
246 | WARN_ON_ONCE(1); \ |
247 | } \ |
248 | return ret; \ |
249 | } \ |
250 | \ |
251 | void logic_out##bwl(type value, unsigned long addr) \ |
252 | { \ |
253 | if (addr < MMIO_UPPER_LIMIT) { \ |
254 | _out##bwl(value, addr); \ |
255 | } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ |
256 | struct logic_pio_hwaddr *entry = find_io_range(addr); \ |
257 | \ |
258 | if (entry) \ |
259 | entry->ops->out(entry->hostdata, \ |
260 | addr, value, sizeof(type)); \ |
261 | else \ |
262 | WARN_ON_ONCE(1); \ |
263 | } \ |
264 | } \ |
265 | \ |
266 | void logic_ins##bwl(unsigned long addr, void *buffer, \ |
267 | unsigned int count) \ |
268 | { \ |
269 | if (addr < MMIO_UPPER_LIMIT) { \ |
270 | reads##bwl(PCI_IOBASE + addr, buffer, count); \ |
271 | } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ |
272 | struct logic_pio_hwaddr *entry = find_io_range(addr); \ |
273 | \ |
274 | if (entry) \ |
275 | entry->ops->ins(entry->hostdata, \ |
276 | addr, buffer, sizeof(type), count); \ |
277 | else \ |
278 | WARN_ON_ONCE(1); \ |
279 | } \ |
280 | \ |
281 | } \ |
282 | \ |
283 | void logic_outs##bwl(unsigned long addr, const void *buffer, \ |
284 | unsigned int count) \ |
285 | { \ |
286 | if (addr < MMIO_UPPER_LIMIT) { \ |
287 | writes##bwl(PCI_IOBASE + addr, buffer, count); \ |
288 | } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ |
289 | struct logic_pio_hwaddr *entry = find_io_range(addr); \ |
290 | \ |
291 | if (entry) \ |
292 | entry->ops->outs(entry->hostdata, \ |
293 | addr, buffer, sizeof(type), count); \ |
294 | else \ |
295 | WARN_ON_ONCE(1); \ |
296 | } \ |
297 | } |
298 | |
299 | BUILD_LOGIC_IO(b, u8) |
300 | EXPORT_SYMBOL(logic_inb); |
301 | EXPORT_SYMBOL(logic_insb); |
302 | EXPORT_SYMBOL(logic_outb); |
303 | EXPORT_SYMBOL(logic_outsb); |
304 | |
305 | BUILD_LOGIC_IO(w, u16) |
306 | EXPORT_SYMBOL(logic_inw); |
307 | EXPORT_SYMBOL(logic_insw); |
308 | EXPORT_SYMBOL(logic_outw); |
309 | EXPORT_SYMBOL(logic_outsw); |
310 | |
311 | BUILD_LOGIC_IO(l, u32) |
312 | EXPORT_SYMBOL(logic_inl); |
313 | EXPORT_SYMBOL(logic_insl); |
314 | EXPORT_SYMBOL(logic_outl); |
315 | EXPORT_SYMBOL(logic_outsl); |
316 | |
317 | #endif /* CONFIG_INDIRECT_PIO && PCI_IOBASE */ |
318 | |