Merge tag 'mac80211-for-davem-2018-09-27' of git://git.kernel.org/pub/scm/linux/kerne...
[linux-2.6-microblaze.git] / lib / logic_pio.c
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  */
7
8 #define pr_fmt(fmt)     "LOGIC PIO: " fmt
9
10 #include <linux/of.h>
11 #include <linux/io.h>
12 #include <linux/logic_pio.h>
13 #include <linux/mm.h>
14 #include <linux/rculist.h>
15 #include <linux/sizes.h>
16 #include <linux/slab.h>
17
18 /* The unique hardware address list */
19 static LIST_HEAD(io_range_list);
20 static DEFINE_MUTEX(io_range_mutex);
21
22 /* Consider a kernel general helper for this */
23 #define in_range(b, first, len)        ((b) >= (first) && (b) < (first) + (len))
24
25 /**
26  * logic_pio_register_range - register logical PIO range for a host
27  * @new_range: pointer to the IO range to be registered.
28  *
29  * Returns 0 on success, the error code in case of failure.
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_sz = 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                 return -EINVAL;
44
45         start = new_range->hw_start;
46         end = new_range->hw_start + new_range->size;
47
48         mutex_lock(&io_range_mutex);
49         list_for_each_entry_rcu(range, &io_range_list, list) {
50                 if (range->fwnode == new_range->fwnode) {
51                         /* range already there */
52                         goto end_register;
53                 }
54                 if (range->flags == LOGIC_PIO_CPU_MMIO &&
55                     new_range->flags == LOGIC_PIO_CPU_MMIO) {
56                         /* for MMIO ranges we need to check for overlap */
57                         if (start >= range->hw_start + range->size ||
58                             end < range->hw_start) {
59                                 mmio_sz += range->size;
60                         } else {
61                                 ret = -EFAULT;
62                                 goto end_register;
63                         }
64                 } else if (range->flags == LOGIC_PIO_INDIRECT &&
65                            new_range->flags == LOGIC_PIO_INDIRECT) {
66                         iio_sz += range->size;
67                 }
68         }
69
70         /* range not registered yet, check for available space */
71         if (new_range->flags == LOGIC_PIO_CPU_MMIO) {
72                 if (mmio_sz + new_range->size - 1 > MMIO_UPPER_LIMIT) {
73                         /* if it's too big check if 64K space can be reserved */
74                         if (mmio_sz + SZ_64K - 1 > MMIO_UPPER_LIMIT) {
75                                 ret = -E2BIG;
76                                 goto end_register;
77                         }
78                         new_range->size = SZ_64K;
79                         pr_warn("Requested IO range too big, new size set to 64K\n");
80                 }
81                 new_range->io_start = mmio_sz;
82         } else if (new_range->flags == LOGIC_PIO_INDIRECT) {
83                 if (iio_sz + new_range->size - 1 > IO_SPACE_LIMIT) {
84                         ret = -E2BIG;
85                         goto end_register;
86                 }
87                 new_range->io_start = iio_sz;
88         } else {
89                 /* invalid flag */
90                 ret = -EINVAL;
91                 goto end_register;
92         }
93
94         list_add_tail_rcu(&new_range->list, &io_range_list);
95
96 end_register:
97         mutex_unlock(&io_range_mutex);
98         return ret;
99 }
100
101 /**
102  * find_io_range_by_fwnode - find logical PIO range for given FW node
103  * @fwnode: FW node handle associated with logical PIO range
104  *
105  * Returns pointer to node on success, NULL otherwise.
106  *
107  * Traverse the io_range_list to find the registered node for @fwnode.
108  */
109 struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode)
110 {
111         struct logic_pio_hwaddr *range;
112
113         list_for_each_entry_rcu(range, &io_range_list, list) {
114                 if (range->fwnode == fwnode)
115                         return range;
116         }
117         return NULL;
118 }
119
120 /* Return a registered range given an input PIO token */
121 static struct logic_pio_hwaddr *find_io_range(unsigned long pio)
122 {
123         struct logic_pio_hwaddr *range;
124
125         list_for_each_entry_rcu(range, &io_range_list, list) {
126                 if (in_range(pio, range->io_start, range->size))
127                         return range;
128         }
129         pr_err("PIO entry token %lx invalid\n", pio);
130         return NULL;
131 }
132
133 /**
134  * logic_pio_to_hwaddr - translate logical PIO to HW address
135  * @pio: logical PIO value
136  *
137  * Returns HW address if valid, ~0 otherwise.
138  *
139  * Translate the input logical PIO to the corresponding hardware address.
140  * The input PIO should be unique in the whole logical PIO space.
141  */
142 resource_size_t logic_pio_to_hwaddr(unsigned long pio)
143 {
144         struct logic_pio_hwaddr *range;
145
146         range = find_io_range(pio);
147         if (range)
148                 return range->hw_start + pio - range->io_start;
149
150         return (resource_size_t)~0;
151 }
152
153 /**
154  * logic_pio_trans_hwaddr - translate HW address to logical PIO
155  * @fwnode: FW node reference for the host
156  * @addr: Host-relative HW address
157  * @size: size to translate
158  *
159  * Returns Logical PIO value if successful, ~0UL otherwise
160  */
161 unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode,
162                                      resource_size_t addr, resource_size_t size)
163 {
164         struct logic_pio_hwaddr *range;
165
166         range = find_io_range_by_fwnode(fwnode);
167         if (!range || range->flags == LOGIC_PIO_CPU_MMIO) {
168                 pr_err("IO range not found or invalid\n");
169                 return ~0UL;
170         }
171         if (range->size < size) {
172                 pr_err("resource size %pa cannot fit in IO range size %pa\n",
173                        &size, &range->size);
174                 return ~0UL;
175         }
176         return addr - range->hw_start + range->io_start;
177 }
178
179 unsigned long logic_pio_trans_cpuaddr(resource_size_t addr)
180 {
181         struct logic_pio_hwaddr *range;
182
183         list_for_each_entry_rcu(range, &io_range_list, list) {
184                 if (range->flags != LOGIC_PIO_CPU_MMIO)
185                         continue;
186                 if (in_range(addr, range->hw_start, range->size))
187                         return addr - range->hw_start + range->io_start;
188         }
189         pr_err("addr %llx not registered in io_range_list\n",
190                (unsigned long long) addr);
191         return ~0UL;
192 }
193
194 #if defined(CONFIG_INDIRECT_PIO) && defined(PCI_IOBASE)
195 #define BUILD_LOGIC_IO(bw, type)                                        \
196 type logic_in##bw(unsigned long addr)                                   \
197 {                                                                       \
198         type ret = (type)~0;                                            \
199                                                                         \
200         if (addr < MMIO_UPPER_LIMIT) {                                  \
201                 ret = read##bw(PCI_IOBASE + addr);                      \
202         } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
203                 struct logic_pio_hwaddr *entry = find_io_range(addr);   \
204                                                                         \
205                 if (entry && entry->ops)                                \
206                         ret = entry->ops->in(entry->hostdata,           \
207                                         addr, sizeof(type));            \
208                 else                                                    \
209                         WARN_ON_ONCE(1);                                \
210         }                                                               \
211         return ret;                                                     \
212 }                                                                       \
213                                                                         \
214 void logic_out##bw(type value, unsigned long addr)                      \
215 {                                                                       \
216         if (addr < MMIO_UPPER_LIMIT) {                                  \
217                 write##bw(value, PCI_IOBASE + addr);                    \
218         } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
219                 struct logic_pio_hwaddr *entry = find_io_range(addr);   \
220                                                                         \
221                 if (entry && entry->ops)                                \
222                         entry->ops->out(entry->hostdata,                \
223                                         addr, value, sizeof(type));     \
224                 else                                                    \
225                         WARN_ON_ONCE(1);                                \
226         }                                                               \
227 }                                                                       \
228                                                                         \
229 void logic_ins##bw(unsigned long addr, void *buffer,            \
230                    unsigned int count)                                  \
231 {                                                                       \
232         if (addr < MMIO_UPPER_LIMIT) {                                  \
233                 reads##bw(PCI_IOBASE + addr, buffer, count);            \
234         } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
235                 struct logic_pio_hwaddr *entry = find_io_range(addr);   \
236                                                                         \
237                 if (entry && entry->ops)                                \
238                         entry->ops->ins(entry->hostdata,                \
239                                 addr, buffer, sizeof(type), count);     \
240                 else                                                    \
241                         WARN_ON_ONCE(1);                                \
242         }                                                               \
243                                                                         \
244 }                                                                       \
245                                                                         \
246 void logic_outs##bw(unsigned long addr, const void *buffer,             \
247                     unsigned int count)                                 \
248 {                                                                       \
249         if (addr < MMIO_UPPER_LIMIT) {                                  \
250                 writes##bw(PCI_IOBASE + addr, buffer, count);           \
251         } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \
252                 struct logic_pio_hwaddr *entry = find_io_range(addr);   \
253                                                                         \
254                 if (entry && entry->ops)                                \
255                         entry->ops->outs(entry->hostdata,               \
256                                 addr, buffer, sizeof(type), count);     \
257                 else                                                    \
258                         WARN_ON_ONCE(1);                                \
259         }                                                               \
260 }
261
262 BUILD_LOGIC_IO(b, u8)
263 EXPORT_SYMBOL(logic_inb);
264 EXPORT_SYMBOL(logic_insb);
265 EXPORT_SYMBOL(logic_outb);
266 EXPORT_SYMBOL(logic_outsb);
267
268 BUILD_LOGIC_IO(w, u16)
269 EXPORT_SYMBOL(logic_inw);
270 EXPORT_SYMBOL(logic_insw);
271 EXPORT_SYMBOL(logic_outw);
272 EXPORT_SYMBOL(logic_outsw);
273
274 BUILD_LOGIC_IO(l, u32)
275 EXPORT_SYMBOL(logic_inl);
276 EXPORT_SYMBOL(logic_insl);
277 EXPORT_SYMBOL(logic_outl);
278 EXPORT_SYMBOL(logic_outsl);
279
280 #endif /* CONFIG_INDIRECT_PIO && PCI_IOBASE */