1 /* $NetBSD: fdt_intr.c,v 1.11 2017/06/11 12:56:36 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2015 Jared D. McNeill <jmcneill@invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: fdt_intr.c,v 1.11 2017/06/11 12:56:36 jmcneill Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/bus.h> 34 #include <sys/kmem.h> 35 36 #include <libfdt.h> 37 #include <dev/fdt/fdtvar.h> 38 39 struct fdtbus_interrupt_controller { 40 device_t ic_dev; 41 int ic_phandle; 42 const struct fdtbus_interrupt_controller_func *ic_funcs; 43 44 struct fdtbus_interrupt_controller *ic_next; 45 }; 46 47 struct fdtbus_interrupt_cookie { 48 struct fdtbus_interrupt_controller *c_ic; 49 void *c_ih; 50 }; 51 52 static struct fdtbus_interrupt_controller *fdtbus_ic = NULL; 53 54 static bool has_interrupt_map(int); 55 static u_int * get_specifier_by_index(int, int, int *); 56 static u_int * get_specifier_from_map(int, int, int *); 57 58 static int 59 fdtbus_get_interrupt_parent(int phandle) 60 { 61 u_int interrupt_parent; 62 63 while (phandle >= 0) { 64 if (of_getprop_uint32(phandle, "interrupt-parent", 65 &interrupt_parent) == 0) { 66 break; 67 } 68 if (phandle == 0) { 69 return -1; 70 } 71 phandle = OF_parent(phandle); 72 } 73 if (phandle < 0) { 74 return -1; 75 } 76 77 const void *data = fdtbus_get_data(); 78 const int off = fdt_node_offset_by_phandle(data, interrupt_parent); 79 if (off < 0) { 80 return -1; 81 } 82 83 return fdtbus_offset2phandle(off); 84 } 85 86 static struct fdtbus_interrupt_controller * 87 fdtbus_get_interrupt_controller(int phandle) 88 { 89 struct fdtbus_interrupt_controller * ic; 90 for (ic = fdtbus_ic; ic; ic = ic->ic_next) { 91 if (ic->ic_phandle == phandle) { 92 return ic; 93 } 94 } 95 return NULL; 96 } 97 98 int 99 fdtbus_register_interrupt_controller(device_t dev, int phandle, 100 const struct fdtbus_interrupt_controller_func *funcs) 101 { 102 struct fdtbus_interrupt_controller *ic; 103 104 ic = kmem_alloc(sizeof(*ic), KM_SLEEP); 105 ic->ic_dev = dev; 106 ic->ic_phandle = phandle; 107 ic->ic_funcs = funcs; 108 109 ic->ic_next = fdtbus_ic; 110 fdtbus_ic = ic; 111 112 return 0; 113 } 114 115 void * 116 fdtbus_intr_establish(int phandle, u_int index, int ipl, int flags, 117 int (*func)(void *), void *arg) 118 { 119 struct fdtbus_interrupt_controller *ic; 120 struct fdtbus_interrupt_cookie *c = NULL; 121 u_int *specifier; 122 int ihandle; 123 void *ih; 124 125 specifier = get_specifier_by_index(phandle, index, &ihandle); 126 if (specifier == NULL) 127 return NULL; 128 129 ic = fdtbus_get_interrupt_controller(ihandle); 130 if (ic == NULL) 131 return NULL; 132 133 ih = ic->ic_funcs->establish(ic->ic_dev, specifier, 134 ipl, flags, func, arg); 135 if (ih != NULL) { 136 c = kmem_alloc(sizeof(*c), KM_SLEEP); 137 c->c_ic = ic; 138 c->c_ih = ih; 139 } 140 141 return c; 142 } 143 144 void 145 fdtbus_intr_disestablish(int phandle, void *cookie) 146 { 147 struct fdtbus_interrupt_cookie *c = cookie; 148 struct fdtbus_interrupt_controller *ic = c->c_ic; 149 void *ih = c->c_ih; 150 151 return ic->ic_funcs->disestablish(ic->ic_dev, ih); 152 } 153 154 bool 155 fdtbus_intr_str(int phandle, u_int index, char *buf, size_t buflen) 156 { 157 struct fdtbus_interrupt_controller *ic; 158 u_int *specifier; 159 int ihandle; 160 161 specifier = get_specifier_by_index(phandle, index, &ihandle); 162 163 ic = fdtbus_get_interrupt_controller(ihandle); 164 if (ic == NULL) 165 return false; 166 167 return ic->ic_funcs->intrstr(ic->ic_dev, specifier, buf, buflen); 168 } 169 170 static int 171 find_interrupt_map(int phandle) 172 { 173 while (phandle > 0) { 174 if (of_hasprop(phandle, "interrupt-map")) 175 return phandle; 176 phandle = OF_parent(phandle); 177 } 178 return -1; 179 } 180 181 static int 182 find_address_cells(int phandle) 183 { 184 uint32_t cells; 185 186 if (of_getprop_uint32(phandle, "#address-cells", &cells) != 0) 187 cells = 2; 188 189 return cells; 190 } 191 192 static int 193 find_interrupt_cells(int phandle) 194 { 195 uint32_t cells; 196 197 while (phandle > 0) { 198 if (of_getprop_uint32(phandle, "#interrupt-cells", &cells) == 0) 199 return cells; 200 phandle = OF_parent(phandle); 201 } 202 return 0; 203 } 204 205 static bool 206 has_interrupt_map(int phandle) 207 { 208 return find_interrupt_map(OF_parent(phandle)) != -1; 209 } 210 211 static u_int * 212 get_specifier_from_map(int phandle, int pindex, int *piphandle) 213 { 214 const u_int *node_specifier = NULL; 215 u_int *result = NULL; 216 int len, resid; 217 218 const u_int interrupt_cells = find_interrupt_cells(phandle); 219 if (interrupt_cells < 1) 220 return NULL; 221 222 node_specifier = fdt_getprop(fdtbus_get_data(), fdtbus_phandle2offset(phandle), 223 "interrupts", &len); 224 if (node_specifier == NULL) 225 return NULL; 226 227 const u_int spec_length = len / 4; 228 const u_int nintr = spec_length / interrupt_cells; 229 if (pindex >= nintr) 230 return NULL; 231 232 node_specifier += (interrupt_cells * pindex); 233 234 const int nexus_phandle = find_interrupt_map(OF_parent(phandle)); 235 236 const u_int *data = fdt_getprop(fdtbus_get_data(), fdtbus_phandle2offset(nexus_phandle), 237 "interrupt-map", &len); 238 if (data == NULL || len <= 0) { 239 printf("%s: can't get property interrupt-map.\n", __func__); 240 return NULL; 241 } 242 resid = len; 243 244 /* child unit address: #address-cells prop of child bus node */ 245 const int cua_cells = find_address_cells(nexus_phandle); 246 /* child interrupt specifier: #interrupt-cells of the nexus node */ 247 const int cis_cells = find_interrupt_cells(nexus_phandle); 248 249 /* Offset (in cells) from map entry to child unit address specifier */ 250 const u_int cua_off = 0; 251 /* Offset (in cells) from map entry to child interrupt specifier */ 252 const u_int cis_off = cua_off + cua_cells; 253 /* Offset (in cells) from map entry to interrupt parent phandle */ 254 const u_int ip_off = cis_off + cis_cells; 255 /* Offset (in cells) from map entry to parent unit specifier */ 256 const u_int pus_off = ip_off + 1; 257 258 #ifdef FDT_INTR_DEBUG 259 printf("%s: phandle=%s nexus_phandle=%s\n", __func__, 260 fdt_get_name(fdtbus_get_data(), fdtbus_phandle2offset(phandle), NULL), 261 fdt_get_name(fdtbus_get_data(), fdtbus_phandle2offset(nexus_phandle), NULL)); 262 printf("cua_cells: %d, cis_cells: %d, ip_off = %d\n", cua_cells, cis_cells, ip_off); 263 printf("searching for interrupt in map (data %p, len %d):", data, len); 264 for (int i = 0; i < interrupt_cells; i++) 265 printf(" %08x", node_specifier[i]); 266 printf("\n"); 267 #endif 268 269 const u_int *p = (const u_int *)data; 270 while (resid > 0) { 271 /* Interrupt parent phandle */ 272 const u_int iparent = fdtbus_get_phandle_from_native(be32toh(p[ip_off])); 273 274 /* parent unit specifier: #address-cells of the interrupt parent */ 275 const u_int pus_cells = find_address_cells(iparent); 276 /* parent interrupt specifier: #interrupt-cells of the interrupt parent */ 277 const u_int pis_cells = find_interrupt_cells(iparent); 278 279 /* Offset (in cells) from map entry to parent interrupt specifier */ 280 const u_int pis_off = pus_off + pus_cells; 281 282 #ifdef FDT_INTR_DEBUG 283 printf(" intr map (len %d):", pis_off + pis_cells); 284 for (int i = 0; i < pis_off + pis_cells; i++) 285 printf(" %08x", p[i]); 286 printf("\n"); 287 #endif 288 289 if (cis_cells == interrupt_cells && memcmp(&p[cis_off], node_specifier, interrupt_cells * 4) == 0) { 290 const int slen = pus_cells + pis_cells; 291 #ifdef FDT_INTR_DEBUG 292 printf(" intr map match iparent %08x slen %d:", iparent, slen); 293 for (int i = 0; i < slen; i++) 294 printf(" %08x", p[pus_off + i]); 295 printf("\n"); 296 #endif 297 result = kmem_alloc(slen, KM_SLEEP); 298 memcpy(result, &p[pus_off], slen * 4); 299 *piphandle = iparent; 300 goto done; 301 } 302 /* Determine the length of the entry and skip that many 303 * 32 bit words 304 */ 305 const u_int reclen = pis_off + pis_cells; 306 resid -= reclen * sizeof(u_int); 307 p += reclen; 308 } 309 310 done: 311 return result; 312 } 313 314 static u_int * 315 get_specifier_by_index(int phandle, int pindex, int *piphandle) 316 { 317 const u_int *node_specifier; 318 u_int *specifier; 319 int interrupt_parent, interrupt_cells, len; 320 321 if (has_interrupt_map(phandle)) 322 return get_specifier_from_map(phandle, pindex, piphandle); 323 324 interrupt_parent = fdtbus_get_interrupt_parent(phandle); 325 if (interrupt_parent <= 0) 326 return NULL; 327 328 interrupt_cells = find_interrupt_cells(interrupt_parent); 329 if (interrupt_cells <= 0) 330 return NULL; 331 332 node_specifier = fdt_getprop(fdtbus_get_data(), fdtbus_phandle2offset(phandle), 333 "interrupts", &len); 334 if (node_specifier == NULL) 335 return NULL; 336 337 const u_int spec_length = len / 4; 338 const u_int nintr = spec_length / interrupt_cells; 339 if (pindex >= nintr) 340 return NULL; 341 342 node_specifier += (interrupt_cells * pindex); 343 344 specifier = kmem_alloc(interrupt_cells * sizeof(u_int), KM_SLEEP); 345 memcpy(specifier, node_specifier, interrupt_cells * 4); 346 347 *piphandle = interrupt_parent; 348 349 return specifier; 350 } 351