1031e3601SZhichang Yuan // SPDX-License-Identifier: GPL-2.0+
2031e3601SZhichang Yuan /*
3031e3601SZhichang Yuan * Copyright (C) 2017 HiSilicon Limited, All Rights Reserved.
4031e3601SZhichang Yuan * Author: Gabriele Paoloni <gabriele.paoloni@huawei.com>
5031e3601SZhichang Yuan * Author: Zhichang Yuan <yuanzhichang@hisilicon.com>
60376fa72SJohn Garry * Author: John Garry <john.garry@huawei.com>
7031e3601SZhichang Yuan */
8031e3601SZhichang Yuan
9031e3601SZhichang Yuan #define pr_fmt(fmt) "LOGIC PIO: " fmt
10031e3601SZhichang Yuan
11031e3601SZhichang Yuan #include <linux/of.h>
12031e3601SZhichang Yuan #include <linux/io.h>
13031e3601SZhichang Yuan #include <linux/logic_pio.h>
14031e3601SZhichang Yuan #include <linux/mm.h>
15031e3601SZhichang Yuan #include <linux/rculist.h>
16031e3601SZhichang Yuan #include <linux/sizes.h>
17031e3601SZhichang Yuan #include <linux/slab.h>
18031e3601SZhichang Yuan
19031e3601SZhichang Yuan /* The unique hardware address list */
20031e3601SZhichang Yuan static LIST_HEAD(io_range_list);
21031e3601SZhichang Yuan static DEFINE_MUTEX(io_range_mutex);
22031e3601SZhichang Yuan
23031e3601SZhichang Yuan /**
24031e3601SZhichang Yuan * logic_pio_register_range - register logical PIO range for a host
25031e3601SZhichang Yuan * @new_range: pointer to the IO range to be registered.
26031e3601SZhichang Yuan *
27031e3601SZhichang Yuan * Returns 0 on success, the error code in case of failure.
28*f6bda644SGeert Uytterhoeven * If the range already exists, -EEXIST will be returned, which should be
29*f6bda644SGeert Uytterhoeven * considered a success.
30031e3601SZhichang Yuan *
31031e3601SZhichang Yuan * Register a new IO range node in the IO range list.
32031e3601SZhichang Yuan */
logic_pio_register_range(struct logic_pio_hwaddr * new_range)33031e3601SZhichang Yuan int logic_pio_register_range(struct logic_pio_hwaddr *new_range)
34031e3601SZhichang Yuan {
35031e3601SZhichang Yuan struct logic_pio_hwaddr *range;
36031e3601SZhichang Yuan resource_size_t start;
37031e3601SZhichang Yuan resource_size_t end;
380a27142bSJohn Garry resource_size_t mmio_end = 0;
39031e3601SZhichang Yuan resource_size_t iio_sz = MMIO_UPPER_LIMIT;
40031e3601SZhichang Yuan int ret = 0;
41031e3601SZhichang Yuan
420376fa72SJohn Garry if (!new_range || !new_range->fwnode || !new_range->size ||
430376fa72SJohn Garry (new_range->flags == LOGIC_PIO_INDIRECT && !new_range->ops))
44031e3601SZhichang Yuan return -EINVAL;
45031e3601SZhichang Yuan
46031e3601SZhichang Yuan start = new_range->hw_start;
47031e3601SZhichang Yuan end = new_range->hw_start + new_range->size;
48031e3601SZhichang Yuan
49031e3601SZhichang Yuan mutex_lock(&io_range_mutex);
5006709e81SJohn Garry list_for_each_entry(range, &io_range_list, list) {
51031e3601SZhichang Yuan if (range->fwnode == new_range->fwnode) {
52031e3601SZhichang Yuan /* range already there */
53*f6bda644SGeert Uytterhoeven ret = -EEXIST;
54031e3601SZhichang Yuan goto end_register;
55031e3601SZhichang Yuan }
56031e3601SZhichang Yuan if (range->flags == LOGIC_PIO_CPU_MMIO &&
57031e3601SZhichang Yuan new_range->flags == LOGIC_PIO_CPU_MMIO) {
58031e3601SZhichang Yuan /* for MMIO ranges we need to check for overlap */
59031e3601SZhichang Yuan if (start >= range->hw_start + range->size ||
60031e3601SZhichang Yuan end < range->hw_start) {
610a27142bSJohn Garry mmio_end = range->io_start + range->size;
62031e3601SZhichang Yuan } else {
63031e3601SZhichang Yuan ret = -EFAULT;
64031e3601SZhichang Yuan goto end_register;
65031e3601SZhichang Yuan }
66031e3601SZhichang Yuan } else if (range->flags == LOGIC_PIO_INDIRECT &&
67031e3601SZhichang Yuan new_range->flags == LOGIC_PIO_INDIRECT) {
68031e3601SZhichang Yuan iio_sz += range->size;
69031e3601SZhichang Yuan }
70031e3601SZhichang Yuan }
71031e3601SZhichang Yuan
72031e3601SZhichang Yuan /* range not registered yet, check for available space */
73031e3601SZhichang Yuan if (new_range->flags == LOGIC_PIO_CPU_MMIO) {
740a27142bSJohn Garry if (mmio_end + new_range->size - 1 > MMIO_UPPER_LIMIT) {
75031e3601SZhichang Yuan /* if it's too big check if 64K space can be reserved */
760a27142bSJohn Garry if (mmio_end + SZ_64K - 1 > MMIO_UPPER_LIMIT) {
77031e3601SZhichang Yuan ret = -E2BIG;
78031e3601SZhichang Yuan goto end_register;
79031e3601SZhichang Yuan }
80031e3601SZhichang Yuan new_range->size = SZ_64K;
81031e3601SZhichang Yuan pr_warn("Requested IO range too big, new size set to 64K\n");
82031e3601SZhichang Yuan }
830a27142bSJohn Garry new_range->io_start = mmio_end;
84031e3601SZhichang Yuan } else if (new_range->flags == LOGIC_PIO_INDIRECT) {
85031e3601SZhichang Yuan if (iio_sz + new_range->size - 1 > IO_SPACE_LIMIT) {
86031e3601SZhichang Yuan ret = -E2BIG;
87031e3601SZhichang Yuan goto end_register;
88031e3601SZhichang Yuan }
89031e3601SZhichang Yuan new_range->io_start = iio_sz;
90031e3601SZhichang Yuan } else {
91031e3601SZhichang Yuan /* invalid flag */
92031e3601SZhichang Yuan ret = -EINVAL;
93031e3601SZhichang Yuan goto end_register;
94031e3601SZhichang Yuan }
95031e3601SZhichang Yuan
96031e3601SZhichang Yuan list_add_tail_rcu(&new_range->list, &io_range_list);
97031e3601SZhichang Yuan
98031e3601SZhichang Yuan end_register:
99031e3601SZhichang Yuan mutex_unlock(&io_range_mutex);
100031e3601SZhichang Yuan return ret;
101031e3601SZhichang Yuan }
102031e3601SZhichang Yuan
103031e3601SZhichang Yuan /**
104b884e2deSJohn Garry * logic_pio_unregister_range - unregister a logical PIO range for a host
105b884e2deSJohn Garry * @range: pointer to the IO range which has been already registered.
106b884e2deSJohn Garry *
107b884e2deSJohn Garry * Unregister a previously-registered IO range node.
108b884e2deSJohn Garry */
logic_pio_unregister_range(struct logic_pio_hwaddr * range)109b884e2deSJohn Garry void logic_pio_unregister_range(struct logic_pio_hwaddr *range)
110b884e2deSJohn Garry {
111b884e2deSJohn Garry mutex_lock(&io_range_mutex);
112b884e2deSJohn Garry list_del_rcu(&range->list);
113b884e2deSJohn Garry mutex_unlock(&io_range_mutex);
114b884e2deSJohn Garry synchronize_rcu();
115b884e2deSJohn Garry }
116b884e2deSJohn Garry
117b884e2deSJohn Garry /**
118031e3601SZhichang Yuan * find_io_range_by_fwnode - find logical PIO range for given FW node
119031e3601SZhichang Yuan * @fwnode: FW node handle associated with logical PIO range
120031e3601SZhichang Yuan *
121031e3601SZhichang Yuan * Returns pointer to node on success, NULL otherwise.
122031e3601SZhichang Yuan *
123031e3601SZhichang Yuan * Traverse the io_range_list to find the registered node for @fwnode.
124031e3601SZhichang Yuan */
find_io_range_by_fwnode(struct fwnode_handle * fwnode)125031e3601SZhichang Yuan struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode)
126031e3601SZhichang Yuan {
12706709e81SJohn Garry struct logic_pio_hwaddr *range, *found_range = NULL;
128031e3601SZhichang Yuan
12906709e81SJohn Garry rcu_read_lock();
130031e3601SZhichang Yuan list_for_each_entry_rcu(range, &io_range_list, list) {
13106709e81SJohn Garry if (range->fwnode == fwnode) {
13206709e81SJohn Garry found_range = range;
13306709e81SJohn Garry break;
134031e3601SZhichang Yuan }
13506709e81SJohn Garry }
13606709e81SJohn Garry rcu_read_unlock();
13706709e81SJohn Garry
13806709e81SJohn Garry return found_range;
139031e3601SZhichang Yuan }
140031e3601SZhichang Yuan
141031e3601SZhichang Yuan /* Return a registered range given an input PIO token */
find_io_range(unsigned long pio)142031e3601SZhichang Yuan static struct logic_pio_hwaddr *find_io_range(unsigned long pio)
143031e3601SZhichang Yuan {
14406709e81SJohn Garry struct logic_pio_hwaddr *range, *found_range = NULL;
145031e3601SZhichang Yuan
14606709e81SJohn Garry rcu_read_lock();
147031e3601SZhichang Yuan list_for_each_entry_rcu(range, &io_range_list, list) {
14806709e81SJohn Garry if (in_range(pio, range->io_start, range->size)) {
14906709e81SJohn Garry found_range = range;
15006709e81SJohn Garry break;
151031e3601SZhichang Yuan }
15206709e81SJohn Garry }
15306709e81SJohn Garry rcu_read_unlock();
15406709e81SJohn Garry
15506709e81SJohn Garry if (!found_range)
15606709e81SJohn Garry pr_err("PIO entry token 0x%lx invalid\n", pio);
15706709e81SJohn Garry
15806709e81SJohn Garry return found_range;
159031e3601SZhichang Yuan }
160031e3601SZhichang Yuan
161031e3601SZhichang Yuan /**
162031e3601SZhichang Yuan * logic_pio_to_hwaddr - translate logical PIO to HW address
163031e3601SZhichang Yuan * @pio: logical PIO value
164031e3601SZhichang Yuan *
165031e3601SZhichang Yuan * Returns HW address if valid, ~0 otherwise.
166031e3601SZhichang Yuan *
167031e3601SZhichang Yuan * Translate the input logical PIO to the corresponding hardware address.
168031e3601SZhichang Yuan * The input PIO should be unique in the whole logical PIO space.
169031e3601SZhichang Yuan */
logic_pio_to_hwaddr(unsigned long pio)170031e3601SZhichang Yuan resource_size_t logic_pio_to_hwaddr(unsigned long pio)
171031e3601SZhichang Yuan {
172031e3601SZhichang Yuan struct logic_pio_hwaddr *range;
173031e3601SZhichang Yuan
174031e3601SZhichang Yuan range = find_io_range(pio);
175031e3601SZhichang Yuan if (range)
176031e3601SZhichang Yuan return range->hw_start + pio - range->io_start;
177031e3601SZhichang Yuan
178031e3601SZhichang Yuan return (resource_size_t)~0;
179031e3601SZhichang Yuan }
180031e3601SZhichang Yuan
181031e3601SZhichang Yuan /**
182031e3601SZhichang Yuan * logic_pio_trans_hwaddr - translate HW address to logical PIO
183031e3601SZhichang Yuan * @fwnode: FW node reference for the host
184031e3601SZhichang Yuan * @addr: Host-relative HW address
185031e3601SZhichang Yuan * @size: size to translate
186031e3601SZhichang Yuan *
187031e3601SZhichang Yuan * Returns Logical PIO value if successful, ~0UL otherwise
188031e3601SZhichang Yuan */
logic_pio_trans_hwaddr(struct fwnode_handle * fwnode,resource_size_t addr,resource_size_t size)189031e3601SZhichang Yuan unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode,
190031e3601SZhichang Yuan resource_size_t addr, resource_size_t size)
191031e3601SZhichang Yuan {
192031e3601SZhichang Yuan struct logic_pio_hwaddr *range;
193031e3601SZhichang Yuan
194031e3601SZhichang Yuan range = find_io_range_by_fwnode(fwnode);
195031e3601SZhichang Yuan if (!range || range->flags == LOGIC_PIO_CPU_MMIO) {
196031e3601SZhichang Yuan pr_err("IO range not found or invalid\n");
197031e3601SZhichang Yuan return ~0UL;
198031e3601SZhichang Yuan }
199031e3601SZhichang Yuan if (range->size < size) {
200031e3601SZhichang Yuan pr_err("resource size %pa cannot fit in IO range size %pa\n",
201031e3601SZhichang Yuan &size, &range->size);
202031e3601SZhichang Yuan return ~0UL;
203031e3601SZhichang Yuan }
204031e3601SZhichang Yuan return addr - range->hw_start + range->io_start;
205031e3601SZhichang Yuan }
206031e3601SZhichang Yuan
logic_pio_trans_cpuaddr(resource_size_t addr)207031e3601SZhichang Yuan unsigned long logic_pio_trans_cpuaddr(resource_size_t addr)
208031e3601SZhichang Yuan {
209031e3601SZhichang Yuan struct logic_pio_hwaddr *range;
210031e3601SZhichang Yuan
21106709e81SJohn Garry rcu_read_lock();
212031e3601SZhichang Yuan list_for_each_entry_rcu(range, &io_range_list, list) {
213031e3601SZhichang Yuan if (range->flags != LOGIC_PIO_CPU_MMIO)
214031e3601SZhichang Yuan continue;
21506709e81SJohn Garry if (in_range(addr, range->hw_start, range->size)) {
21606709e81SJohn Garry unsigned long cpuaddr;
21706709e81SJohn Garry
21806709e81SJohn Garry cpuaddr = addr - range->hw_start + range->io_start;
21906709e81SJohn Garry
22006709e81SJohn Garry rcu_read_unlock();
22106709e81SJohn Garry return cpuaddr;
222031e3601SZhichang Yuan }
22306709e81SJohn Garry }
22406709e81SJohn Garry rcu_read_unlock();
22506709e81SJohn Garry
22606709e81SJohn Garry pr_err("addr %pa not registered in io_range_list\n", &addr);
22706709e81SJohn Garry
228031e3601SZhichang Yuan return ~0UL;
229031e3601SZhichang Yuan }
230031e3601SZhichang Yuan
231031e3601SZhichang Yuan #if defined(CONFIG_INDIRECT_PIO) && defined(PCI_IOBASE)
23226c4c6ceSJohn Garry #define BUILD_LOGIC_IO(bwl, type) \
23326c4c6ceSJohn Garry type logic_in##bwl(unsigned long addr) \
234031e3601SZhichang Yuan { \
235031e3601SZhichang Yuan type ret = (type)~0; \
236031e3601SZhichang Yuan \
237031e3601SZhichang Yuan if (addr < MMIO_UPPER_LIMIT) { \
2384acaa93eSJohn Garry ret = _in##bwl(addr); \
239031e3601SZhichang Yuan } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
240031e3601SZhichang Yuan struct logic_pio_hwaddr *entry = find_io_range(addr); \
241031e3601SZhichang Yuan \
2420376fa72SJohn Garry if (entry) \
243031e3601SZhichang Yuan ret = entry->ops->in(entry->hostdata, \
244031e3601SZhichang Yuan addr, sizeof(type)); \
245031e3601SZhichang Yuan else \
246031e3601SZhichang Yuan WARN_ON_ONCE(1); \
247031e3601SZhichang Yuan } \
248031e3601SZhichang Yuan return ret; \
249031e3601SZhichang Yuan } \
250031e3601SZhichang Yuan \
25126c4c6ceSJohn Garry void logic_out##bwl(type value, unsigned long addr) \
252031e3601SZhichang Yuan { \
253031e3601SZhichang Yuan if (addr < MMIO_UPPER_LIMIT) { \
2544acaa93eSJohn Garry _out##bwl(value, addr); \
255031e3601SZhichang Yuan } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
256031e3601SZhichang Yuan struct logic_pio_hwaddr *entry = find_io_range(addr); \
257031e3601SZhichang Yuan \
2580376fa72SJohn Garry if (entry) \
259031e3601SZhichang Yuan entry->ops->out(entry->hostdata, \
260031e3601SZhichang Yuan addr, value, sizeof(type)); \
261031e3601SZhichang Yuan else \
262031e3601SZhichang Yuan WARN_ON_ONCE(1); \
263031e3601SZhichang Yuan } \
264031e3601SZhichang Yuan } \
265031e3601SZhichang Yuan \
26626c4c6ceSJohn Garry void logic_ins##bwl(unsigned long addr, void *buffer, \
267031e3601SZhichang Yuan unsigned int count) \
268031e3601SZhichang Yuan { \
269031e3601SZhichang Yuan if (addr < MMIO_UPPER_LIMIT) { \
27026c4c6ceSJohn Garry reads##bwl(PCI_IOBASE + addr, buffer, count); \
271031e3601SZhichang Yuan } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
272031e3601SZhichang Yuan struct logic_pio_hwaddr *entry = find_io_range(addr); \
273031e3601SZhichang Yuan \
2740376fa72SJohn Garry if (entry) \
275031e3601SZhichang Yuan entry->ops->ins(entry->hostdata, \
276031e3601SZhichang Yuan addr, buffer, sizeof(type), count); \
277031e3601SZhichang Yuan else \
278031e3601SZhichang Yuan WARN_ON_ONCE(1); \
279031e3601SZhichang Yuan } \
280031e3601SZhichang Yuan \
281031e3601SZhichang Yuan } \
282031e3601SZhichang Yuan \
28326c4c6ceSJohn Garry void logic_outs##bwl(unsigned long addr, const void *buffer, \
284031e3601SZhichang Yuan unsigned int count) \
285031e3601SZhichang Yuan { \
286031e3601SZhichang Yuan if (addr < MMIO_UPPER_LIMIT) { \
28726c4c6ceSJohn Garry writes##bwl(PCI_IOBASE + addr, buffer, count); \
288031e3601SZhichang Yuan } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
289031e3601SZhichang Yuan struct logic_pio_hwaddr *entry = find_io_range(addr); \
290031e3601SZhichang Yuan \
2910376fa72SJohn Garry if (entry) \
292031e3601SZhichang Yuan entry->ops->outs(entry->hostdata, \
293031e3601SZhichang Yuan addr, buffer, sizeof(type), count); \
294031e3601SZhichang Yuan else \
295031e3601SZhichang Yuan WARN_ON_ONCE(1); \
296031e3601SZhichang Yuan } \
297031e3601SZhichang Yuan }
298031e3601SZhichang Yuan
299031e3601SZhichang Yuan BUILD_LOGIC_IO(b, u8)
300031e3601SZhichang Yuan EXPORT_SYMBOL(logic_inb);
301031e3601SZhichang Yuan EXPORT_SYMBOL(logic_insb);
302031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outb);
303031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outsb);
304031e3601SZhichang Yuan
305031e3601SZhichang Yuan BUILD_LOGIC_IO(w, u16)
306031e3601SZhichang Yuan EXPORT_SYMBOL(logic_inw);
307031e3601SZhichang Yuan EXPORT_SYMBOL(logic_insw);
308031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outw);
309031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outsw);
310031e3601SZhichang Yuan
311031e3601SZhichang Yuan BUILD_LOGIC_IO(l, u32)
312031e3601SZhichang Yuan EXPORT_SYMBOL(logic_inl);
313031e3601SZhichang Yuan EXPORT_SYMBOL(logic_insl);
314031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outl);
315031e3601SZhichang Yuan EXPORT_SYMBOL(logic_outsl);
316031e3601SZhichang Yuan
317031e3601SZhichang Yuan #endif /* CONFIG_INDIRECT_PIO && PCI_IOBASE */
318