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_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 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(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_end = range->io_start + 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_end + new_range->size - 1 > MMIO_UPPER_LIMIT) { 73 /* if it's too big check if 64K space can be reserved */ 74 if (mmio_end + 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_end; 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 * logic_pio_unregister_range - unregister a logical PIO range for a host 103 * @range: pointer to the IO range which has been already registered. 104 * 105 * Unregister a previously-registered IO range node. 106 */ 107 void logic_pio_unregister_range(struct logic_pio_hwaddr *range) 108 { 109 mutex_lock(&io_range_mutex); 110 list_del_rcu(&range->list); 111 mutex_unlock(&io_range_mutex); 112 synchronize_rcu(); 113 } 114 115 /** 116 * find_io_range_by_fwnode - find logical PIO range for given FW node 117 * @fwnode: FW node handle associated with logical PIO range 118 * 119 * Returns pointer to node on success, NULL otherwise. 120 * 121 * Traverse the io_range_list to find the registered node for @fwnode. 122 */ 123 struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode) 124 { 125 struct logic_pio_hwaddr *range, *found_range = NULL; 126 127 rcu_read_lock(); 128 list_for_each_entry_rcu(range, &io_range_list, list) { 129 if (range->fwnode == fwnode) { 130 found_range = range; 131 break; 132 } 133 } 134 rcu_read_unlock(); 135 136 return found_range; 137 } 138 139 /* Return a registered range given an input PIO token */ 140 static struct logic_pio_hwaddr *find_io_range(unsigned long pio) 141 { 142 struct logic_pio_hwaddr *range, *found_range = NULL; 143 144 rcu_read_lock(); 145 list_for_each_entry_rcu(range, &io_range_list, list) { 146 if (in_range(pio, range->io_start, range->size)) { 147 found_range = range; 148 break; 149 } 150 } 151 rcu_read_unlock(); 152 153 if (!found_range) 154 pr_err("PIO entry token 0x%lx invalid\n", pio); 155 156 return found_range; 157 } 158 159 /** 160 * logic_pio_to_hwaddr - translate logical PIO to HW address 161 * @pio: logical PIO value 162 * 163 * Returns HW address if valid, ~0 otherwise. 164 * 165 * Translate the input logical PIO to the corresponding hardware address. 166 * The input PIO should be unique in the whole logical PIO space. 167 */ 168 resource_size_t logic_pio_to_hwaddr(unsigned long pio) 169 { 170 struct logic_pio_hwaddr *range; 171 172 range = find_io_range(pio); 173 if (range) 174 return range->hw_start + pio - range->io_start; 175 176 return (resource_size_t)~0; 177 } 178 179 /** 180 * logic_pio_trans_hwaddr - translate HW address to logical PIO 181 * @fwnode: FW node reference for the host 182 * @addr: Host-relative HW address 183 * @size: size to translate 184 * 185 * Returns Logical PIO value if successful, ~0UL otherwise 186 */ 187 unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode, 188 resource_size_t addr, resource_size_t size) 189 { 190 struct logic_pio_hwaddr *range; 191 192 range = find_io_range_by_fwnode(fwnode); 193 if (!range || range->flags == LOGIC_PIO_CPU_MMIO) { 194 pr_err("IO range not found or invalid\n"); 195 return ~0UL; 196 } 197 if (range->size < size) { 198 pr_err("resource size %pa cannot fit in IO range size %pa\n", 199 &size, &range->size); 200 return ~0UL; 201 } 202 return addr - range->hw_start + range->io_start; 203 } 204 205 unsigned long logic_pio_trans_cpuaddr(resource_size_t addr) 206 { 207 struct logic_pio_hwaddr *range; 208 209 rcu_read_lock(); 210 list_for_each_entry_rcu(range, &io_range_list, list) { 211 if (range->flags != LOGIC_PIO_CPU_MMIO) 212 continue; 213 if (in_range(addr, range->hw_start, range->size)) { 214 unsigned long cpuaddr; 215 216 cpuaddr = addr - range->hw_start + range->io_start; 217 218 rcu_read_unlock(); 219 return cpuaddr; 220 } 221 } 222 rcu_read_unlock(); 223 224 pr_err("addr %pa not registered in io_range_list\n", &addr); 225 226 return ~0UL; 227 } 228 229 #if defined(CONFIG_INDIRECT_PIO) && defined(PCI_IOBASE) 230 #define BUILD_LOGIC_IO(bw, type) \ 231 type logic_in##bw(unsigned long addr) \ 232 { \ 233 type ret = (type)~0; \ 234 \ 235 if (addr < MMIO_UPPER_LIMIT) { \ 236 ret = read##bw(PCI_IOBASE + addr); \ 237 } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ 238 struct logic_pio_hwaddr *entry = find_io_range(addr); \ 239 \ 240 if (entry && entry->ops) \ 241 ret = entry->ops->in(entry->hostdata, \ 242 addr, sizeof(type)); \ 243 else \ 244 WARN_ON_ONCE(1); \ 245 } \ 246 return ret; \ 247 } \ 248 \ 249 void logic_out##bw(type value, unsigned long addr) \ 250 { \ 251 if (addr < MMIO_UPPER_LIMIT) { \ 252 write##bw(value, PCI_IOBASE + addr); \ 253 } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ 254 struct logic_pio_hwaddr *entry = find_io_range(addr); \ 255 \ 256 if (entry && entry->ops) \ 257 entry->ops->out(entry->hostdata, \ 258 addr, value, sizeof(type)); \ 259 else \ 260 WARN_ON_ONCE(1); \ 261 } \ 262 } \ 263 \ 264 void logic_ins##bw(unsigned long addr, void *buffer, \ 265 unsigned int count) \ 266 { \ 267 if (addr < MMIO_UPPER_LIMIT) { \ 268 reads##bw(PCI_IOBASE + addr, buffer, count); \ 269 } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ 270 struct logic_pio_hwaddr *entry = find_io_range(addr); \ 271 \ 272 if (entry && entry->ops) \ 273 entry->ops->ins(entry->hostdata, \ 274 addr, buffer, sizeof(type), count); \ 275 else \ 276 WARN_ON_ONCE(1); \ 277 } \ 278 \ 279 } \ 280 \ 281 void logic_outs##bw(unsigned long addr, const void *buffer, \ 282 unsigned int count) \ 283 { \ 284 if (addr < MMIO_UPPER_LIMIT) { \ 285 writes##bw(PCI_IOBASE + addr, buffer, count); \ 286 } else if (addr >= MMIO_UPPER_LIMIT && addr < IO_SPACE_LIMIT) { \ 287 struct logic_pio_hwaddr *entry = find_io_range(addr); \ 288 \ 289 if (entry && entry->ops) \ 290 entry->ops->outs(entry->hostdata, \ 291 addr, buffer, sizeof(type), count); \ 292 else \ 293 WARN_ON_ONCE(1); \ 294 } \ 295 } 296 297 BUILD_LOGIC_IO(b, u8) 298 EXPORT_SYMBOL(logic_inb); 299 EXPORT_SYMBOL(logic_insb); 300 EXPORT_SYMBOL(logic_outb); 301 EXPORT_SYMBOL(logic_outsb); 302 303 BUILD_LOGIC_IO(w, u16) 304 EXPORT_SYMBOL(logic_inw); 305 EXPORT_SYMBOL(logic_insw); 306 EXPORT_SYMBOL(logic_outw); 307 EXPORT_SYMBOL(logic_outsw); 308 309 BUILD_LOGIC_IO(l, u32) 310 EXPORT_SYMBOL(logic_inl); 311 EXPORT_SYMBOL(logic_insl); 312 EXPORT_SYMBOL(logic_outl); 313 EXPORT_SYMBOL(logic_outsl); 314 315 #endif /* CONFIG_INDIRECT_PIO && PCI_IOBASE */ 316