1 /* $NetBSD: eisa_machdep.c,v 1.14 2021/09/25 20:16:17 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 34 __KERNEL_RCSID(0, "$NetBSD: eisa_machdep.c,v 1.14 2021/09/25 20:16:17 thorpej Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/device.h> 39 #include <sys/kmem.h> 40 #include <sys/queue.h> 41 42 #include <machine/intr.h> 43 #include <machine/rpb.h> 44 45 #include <dev/eisa/eisareg.h> 46 #include <dev/eisa/eisavar.h> 47 48 void 49 eisa_attach_hook(device_t parent, device_t self, 50 struct eisabus_attach_args *eba) 51 { 52 eba->eba_ec->ec_attach_hook(parent, self, eba); 53 } 54 55 int 56 eisa_maxslots(eisa_chipset_tag_t ec) 57 { 58 return ec->ec_maxslots(ec->ec_v); 59 } 60 61 int 62 eisa_intr_map(eisa_chipset_tag_t ec, u_int irq, eisa_intr_handle_t *ihp) 63 { 64 return ec->ec_intr_map(ec->ec_v, irq, ihp); 65 } 66 67 const char * 68 eisa_intr_string(eisa_chipset_tag_t ec, eisa_intr_handle_t ih, char *buf, 69 size_t len) 70 { 71 return ec->ec_intr_string(ec->ec_v, ih, buf, len); 72 } 73 74 const struct evcnt * 75 eisa_intr_evcnt(eisa_chipset_tag_t ec, eisa_intr_handle_t ih) 76 { 77 return ec->ec_intr_evcnt(ec->ec_v, ih); 78 } 79 80 void * 81 eisa_intr_establish(eisa_chipset_tag_t ec, eisa_intr_handle_t ih, 82 int type, int level, int (*func)(void *), void *arg) 83 { 84 return ec->ec_intr_establish(ec->ec_v, ih, type, level, func, arg); 85 } 86 87 void 88 eisa_intr_disestablish(eisa_chipset_tag_t ec, void *cookie) 89 { 90 return ec->ec_intr_disestablish(ec->ec_v, cookie); 91 } 92 93 #define EISA_SLOT_HEADER_SIZE 31 94 #define EISA_SLOT_INFO_OFFSET 20 95 96 #define EISA_FUNC_INFO_OFFSET 34 97 #define EISA_CONFIG_BLOCK_SIZE 320 98 99 #define ECUF_TYPE_STRING 0x01 100 #define ECUF_MEM_ENTRY 0x02 101 #define ECUF_IRQ_ENTRY 0x04 102 #define ECUF_DMA_ENTRY 0x08 103 #define ECUF_IO_ENTRY 0x10 104 #define ECUF_INIT_ENTRY 0x20 105 #define ECUF_DISABLED 0x80 106 107 #define ECUF_SELECTIONS_SIZE 26 108 #define ECUF_TYPE_STRING_SIZE 80 109 #define ECUF_MEM_ENTRY_SIZE 7 110 #define ECUF_IRQ_ENTRY_SIZE 2 111 #define ECUF_DMA_ENTRY_SIZE 2 112 #define ECUF_IO_ENTRY_SIZE 3 113 #define ECUF_INIT_ENTRY_SIZE 60 114 115 #define ECUF_MEM_ENTRY_CNT 9 116 #define ECUF_IRQ_ENTRY_CNT 7 117 #define ECUF_DMA_ENTRY_CNT 4 118 #define ECUF_IO_ENTRY_CNT 20 119 120 #define CBUFSIZE 512 121 122 /* 123 * EISA configuration space, as set up by the ECU, may be sparse. 124 */ 125 bus_size_t eisa_config_stride; 126 paddr_t eisa_config_addr; /* defaults to 0 */ 127 paddr_t eisa_config_header_addr; 128 129 struct ecu_mem { 130 SIMPLEQ_ENTRY(ecu_mem) ecum_list; 131 struct eisa_cfg_mem ecum_mem; 132 }; 133 134 struct ecu_irq { 135 SIMPLEQ_ENTRY(ecu_irq) ecui_list; 136 struct eisa_cfg_irq ecui_irq; 137 }; 138 139 struct ecu_dma { 140 SIMPLEQ_ENTRY(ecu_dma) ecud_list; 141 struct eisa_cfg_dma ecud_dma; 142 }; 143 144 struct ecu_io { 145 SIMPLEQ_ENTRY(ecu_io) ecuio_list; 146 struct eisa_cfg_io ecuio_io; 147 }; 148 149 struct ecu_func { 150 SIMPLEQ_ENTRY(ecu_func) ecuf_list; 151 int ecuf_funcno; 152 uint32_t ecuf_id; 153 uint16_t ecuf_slot_info; 154 uint16_t ecuf_cfg_ext; 155 uint8_t ecuf_selections[ECUF_SELECTIONS_SIZE]; 156 uint8_t ecuf_func_info; 157 uint8_t ecuf_type_string[ECUF_TYPE_STRING_SIZE]; 158 uint8_t ecuf_init[ECUF_INIT_ENTRY_SIZE]; 159 SIMPLEQ_HEAD(, ecu_mem) ecuf_mem; 160 SIMPLEQ_HEAD(, ecu_irq) ecuf_irq; 161 SIMPLEQ_HEAD(, ecu_dma) ecuf_dma; 162 SIMPLEQ_HEAD(, ecu_io) ecuf_io; 163 }; 164 165 struct ecu_data { 166 SIMPLEQ_ENTRY(ecu_data) ecud_list; 167 int ecud_slot; 168 uint8_t ecud_eisaid[EISA_IDSTRINGLEN]; 169 uint32_t ecud_offset; 170 171 /* General slot info. */ 172 uint8_t ecud_slot_info; 173 uint16_t ecud_ecu_major_rev; 174 uint16_t ecud_ecu_minor_rev; 175 uint16_t ecud_cksum; 176 uint16_t ecud_ndevfuncs; 177 uint8_t ecud_funcinfo; 178 uint32_t ecud_comp_id; 179 180 /* The functions */ 181 SIMPLEQ_HEAD(, ecu_func) ecud_funcs; 182 }; 183 184 SIMPLEQ_HEAD(, ecu_data) ecu_data_list = 185 SIMPLEQ_HEAD_INITIALIZER(ecu_data_list); 186 187 static void 188 ecuf_init(struct ecu_func *ecuf) 189 { 190 191 memset(ecuf, 0, sizeof(*ecuf)); 192 SIMPLEQ_INIT(&ecuf->ecuf_mem); 193 SIMPLEQ_INIT(&ecuf->ecuf_irq); 194 SIMPLEQ_INIT(&ecuf->ecuf_dma); 195 SIMPLEQ_INIT(&ecuf->ecuf_io); 196 } 197 198 static void 199 eisa_parse_mem(struct ecu_func *ecuf, uint8_t *dp) 200 { 201 struct ecu_mem *ecum; 202 int i; 203 204 for (i = 0; i < ECUF_MEM_ENTRY_CNT; i++) { 205 ecum = kmem_zalloc(sizeof(*ecum), KM_SLEEP); 206 ecum->ecum_mem.ecm_isram = dp[0] & 0x1; 207 ecum->ecum_mem.ecm_unitsize = dp[1] & 0x3; 208 ecum->ecum_mem.ecm_decode = (dp[1] >> 2) & 0x3; 209 ecum->ecum_mem.ecm_addr = 210 (dp[2] | (dp[3] << 8) | (dp[4] << 16)) << 8; 211 ecum->ecum_mem.ecm_size = (dp[5] | (dp[6] << 8)) << 10; 212 if (ecum->ecum_mem.ecm_size == 0) 213 ecum->ecum_mem.ecm_size = (1 << 26); 214 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_mem, ecum, ecum_list); 215 216 #ifdef EISA_DEBUG 217 printf("MEM 0x%lx 0x%lx %d %d %d\n", 218 ecum->ecum_mem.ecm_addr, ecum->ecum_mem.ecm_size, 219 ecum->ecum_mem.ecm_isram, ecum->ecum_mem.ecm_unitsize, 220 ecum->ecum_mem.ecm_decode); 221 #endif 222 223 if ((dp[0] & 0x80) == 0) 224 break; 225 dp += ECUF_MEM_ENTRY_SIZE; 226 } 227 } 228 229 static void 230 eisa_parse_irq(struct ecu_func *ecuf, uint8_t *dp) 231 { 232 struct ecu_irq *ecui; 233 int i; 234 235 for (i = 0; i < ECUF_IRQ_ENTRY_CNT; i++) { 236 ecui = kmem_zalloc(sizeof(*ecui), KM_SLEEP); 237 ecui->ecui_irq.eci_irq = dp[0] & 0xf; 238 ecui->ecui_irq.eci_ist = (dp[0] & 0x20) ? IST_LEVEL : IST_EDGE; 239 ecui->ecui_irq.eci_shared = (dp[0] & 0x40) ? 1 : 0; 240 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_irq, ecui, ecui_list); 241 242 #ifdef EISA_DEBUG 243 printf("IRQ %d %s%s\n", ecui->ecui_irq.eci_irq, 244 ecui->ecui_irq.eci_ist == IST_LEVEL ? "level" : "edge", 245 ecui->ecui_irq.eci_shared ? " shared" : ""); 246 #endif 247 248 if ((dp[0] & 0x80) == 0) 249 break; 250 dp += ECUF_IRQ_ENTRY_SIZE; 251 } 252 } 253 254 static void 255 eisa_parse_dma(struct ecu_func *ecuf, uint8_t *dp) 256 { 257 struct ecu_dma *ecud; 258 int i; 259 260 for (i = 0; i < ECUF_DMA_ENTRY_CNT; i++) { 261 ecud = kmem_zalloc(sizeof(*ecud), KM_SLEEP); 262 ecud->ecud_dma.ecd_drq = dp[0] & 0x7; 263 ecud->ecud_dma.ecd_shared = dp[0] & 0x40; 264 ecud->ecud_dma.ecd_size = (dp[1] >> 2) & 0x3; 265 ecud->ecud_dma.ecd_timing = (dp[1] >> 4) & 0x3; 266 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_dma, ecud, ecud_list); 267 268 #ifdef EISA_DEBUG 269 printf("DRQ %d%s %d %d\n", ecud->ecud_dma.ecd_drq, 270 ecud->ecud_dma.ecd_shared ? " shared" : "", 271 ecud->ecud_dma.ecd_size, ecud->ecud_dma.ecd_timing); 272 #endif 273 274 if ((dp[0] & 0x80) == 0) 275 break; 276 dp += ECUF_DMA_ENTRY_SIZE; 277 } 278 } 279 280 static void 281 eisa_parse_io(struct ecu_func *ecuf, uint8_t *dp) 282 { 283 struct ecu_io *ecuio; 284 int i; 285 286 for (i = 0; i < ECUF_IO_ENTRY_CNT; i++) { 287 ecuio = kmem_zalloc(sizeof(*ecuio), KM_SLEEP); 288 ecuio->ecuio_io.ecio_addr = dp[1] | (dp[2] << 8); 289 ecuio->ecuio_io.ecio_size = (dp[0] & 0x1f) + 1; 290 ecuio->ecuio_io.ecio_shared = (dp[0] & 0x40) ? 1 : 0; 291 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_io, ecuio, ecuio_list); 292 293 #ifdef EISA_DEBUG 294 printf("IO 0x%lx 0x%lx%s\n", ecuio->ecuio_io.ecio_addr, 295 ecuio->ecuio_io.ecio_size, 296 ecuio->ecuio_io.ecio_shared ? " shared" : ""); 297 #endif 298 299 if ((dp[0] & 0x80) == 0) 300 break; 301 dp += ECUF_IO_ENTRY_SIZE; 302 } 303 } 304 305 static void 306 eisa_read_config_bytes(paddr_t addr, void *buf, size_t count) 307 { 308 const uint8_t *src = (const uint8_t *)ALPHA_PHYS_TO_K0SEG(addr); 309 uint8_t *dst = buf; 310 311 for (; count != 0; count--) { 312 *dst++ = *src; 313 src += eisa_config_stride; 314 } 315 } 316 317 static void 318 eisa_read_config_word(paddr_t addr, uint32_t *valp) 319 { 320 const uint8_t *src = (const uint8_t *)ALPHA_PHYS_TO_K0SEG(addr); 321 uint32_t val = 0; 322 int i; 323 324 for (i = 0; i < sizeof(val); i++) { 325 val |= (uint32_t)*src << (i * 8); 326 src += eisa_config_stride; 327 } 328 329 *valp = val; 330 } 331 332 static size_t 333 eisa_uncompress(void *cbufp, void *ucbufp, size_t count) 334 { 335 const uint8_t *cbuf = cbufp; 336 uint8_t *ucbuf = ucbufp; 337 u_int zeros = 0; 338 339 while (count--) { 340 if (zeros) { 341 zeros--; 342 *ucbuf++ = '\0'; 343 } else if (*cbuf == '\0') { 344 *ucbuf++ = *cbuf++; 345 zeros = *cbuf++ - 1; 346 } else 347 *ucbuf++ = *cbuf++; 348 } 349 350 return ((size_t)cbuf - (size_t)cbufp); 351 } 352 353 void 354 eisa_init(eisa_chipset_tag_t ec) 355 { 356 struct ecu_data *ecud; 357 paddr_t cfgaddr; 358 uint32_t offset; 359 uint8_t eisaid[EISA_IDSTRINGLEN]; 360 uint8_t *cdata, *data; 361 uint8_t *cdp, *dp; 362 struct ecu_func *ecuf; 363 int i, func; 364 365 /* 366 * Locate EISA configuration space. 367 */ 368 if (hwrpb->rpb_condat_off == 0UL || 369 (hwrpb->rpb_condat_off >> 63) != 0) { 370 printf(": WARNING: no EISA configuration space"); 371 return; 372 } 373 374 if (eisa_config_header_addr) { 375 printf("\n"); 376 panic("eisa_init: EISA config space already initialized"); 377 } 378 379 eisa_config_header_addr = hwrpb->rpb_condat_off; 380 if (eisa_config_stride == 0) 381 eisa_config_stride = 1; 382 383 #ifdef EISA_DEBUG 384 printf("\nEISA config header at 0x%lx\n", eisa_config_header_addr); 385 printf("EISA config at 0x%lx\n", eisa_config_addr); 386 printf("EISA config stride: %ld\n", eisa_config_stride); 387 #endif 388 389 /* 390 * Read the slot headers, and allocate config structures for 391 * valid slots. 392 */ 393 for (cfgaddr = eisa_config_header_addr, i = 0; 394 i < eisa_maxslots(ec); i++) { 395 eisa_read_config_bytes(cfgaddr, eisaid, sizeof(eisaid)); 396 eisaid[EISA_IDSTRINGLEN - 1] = '\0'; /* sanity */ 397 cfgaddr += sizeof(eisaid) * eisa_config_stride; 398 eisa_read_config_word(cfgaddr, &offset); 399 cfgaddr += sizeof(offset) * eisa_config_stride; 400 401 if (offset != 0 && offset != 0xffffffff) { 402 #ifdef EISA_DEBUG 403 printf("SLOT %d: offset 0x%08x eisaid %s\n", 404 i, offset, eisaid); 405 #endif 406 ecud = kmem_zalloc(sizeof(*ecud), KM_SLEEP); 407 SIMPLEQ_INIT(&ecud->ecud_funcs); 408 409 ecud->ecud_slot = i; 410 memcpy(ecud->ecud_eisaid, eisaid, sizeof(eisaid)); 411 ecud->ecud_offset = offset; 412 SIMPLEQ_INSERT_TAIL(&ecu_data_list, ecud, ecud_list); 413 } 414 } 415 416 /* 417 * Now traverse the valid slots and read the info. 418 */ 419 420 cdata = kmem_zalloc(CBUFSIZE, KM_SLEEP); 421 data = kmem_zalloc(CBUFSIZE, KM_SLEEP); 422 423 SIMPLEQ_FOREACH(ecud, &ecu_data_list, ecud_list) { 424 cfgaddr = eisa_config_addr + ecud->ecud_offset; 425 #ifdef EISA_DEBUG 426 printf("Checking SLOT %d\n", ecud->ecud_slot); 427 printf("Reading config bytes at 0x%lx to cdata[0]\n", cfgaddr); 428 #endif 429 eisa_read_config_bytes(cfgaddr, &cdata[0], 1); 430 cfgaddr += eisa_config_stride; 431 432 for (i = 1; i < CBUFSIZE; cfgaddr += eisa_config_stride, i++) { 433 #ifdef EISA_DEBUG 434 printf("Reading config bytes at 0x%lx to cdata[%d]\n", 435 cfgaddr, i); 436 #endif 437 eisa_read_config_bytes(cfgaddr, &cdata[i], 1); 438 if (cdata[i - 1] == 0 && cdata[i] == 0) 439 break; 440 } 441 if (i == CBUFSIZE) { 442 /* assume this compressed data invalid */ 443 #ifdef EISA_DEBUG 444 printf("SLOT %d has invalid config\n", ecud->ecud_slot); 445 #endif 446 continue; 447 } 448 449 i++; /* index -> length */ 450 451 #ifdef EISA_DEBUG 452 printf("SLOT %d compressed data length %d:", 453 ecud->ecud_slot, i); 454 { 455 int j; 456 457 for (j = 0; j < i; j++) { 458 if ((j % 16) == 0) 459 printf("\n"); 460 printf("0x%02x ", cdata[j]); 461 } 462 printf("\n"); 463 } 464 #endif 465 466 cdp = cdata; 467 dp = data; 468 469 /* Uncompress the slot header. */ 470 cdp += eisa_uncompress(cdp, dp, EISA_SLOT_HEADER_SIZE); 471 #ifdef EISA_DEBUG 472 printf("SLOT %d uncompressed header data:", 473 ecud->ecud_slot); 474 { 475 int j; 476 477 for (j = 0; j < EISA_SLOT_HEADER_SIZE; j++) { 478 if ((j % 16) == 0) 479 printf("\n"); 480 printf("0x%02x ", dp[j]); 481 } 482 printf("\n"); 483 } 484 #endif 485 486 dp = &data[EISA_SLOT_INFO_OFFSET]; 487 ecud->ecud_slot_info = *dp++; 488 ecud->ecud_ecu_major_rev = *dp++; 489 ecud->ecud_ecu_minor_rev = *dp++; 490 memcpy(&ecud->ecud_cksum, dp, sizeof(ecud->ecud_cksum)); 491 dp += sizeof(ecud->ecud_cksum); 492 ecud->ecud_ndevfuncs = *dp++; 493 ecud->ecud_funcinfo = *dp++; 494 memcpy(&ecud->ecud_comp_id, dp, sizeof(ecud->ecud_comp_id)); 495 dp += sizeof(ecud->ecud_comp_id); 496 497 #ifdef EISA_DEBUG 498 printf("SLOT %d: ndevfuncs %d\n", ecud->ecud_slot, 499 ecud->ecud_ndevfuncs); 500 #endif 501 502 for (func = 0; func < ecud->ecud_ndevfuncs; func++) { 503 dp = data; 504 cdp += eisa_uncompress(cdp, dp, EISA_CONFIG_BLOCK_SIZE); 505 #ifdef EISA_DEBUG 506 printf("SLOT %d:%d uncompressed data:", 507 ecud->ecud_slot, func); 508 { 509 int j; 510 511 for (j = 0; i < EISA_CONFIG_BLOCK_SIZE; j++) { 512 if ((j % 16) == 0) 513 printf("\n"); 514 printf("0x%02x ", dp[j]); 515 } 516 printf("\n"); 517 } 518 #endif 519 520 /* Skip disabled functions. */ 521 if (dp[EISA_FUNC_INFO_OFFSET] & ECUF_DISABLED) { 522 #ifdef EISA_DEBUG 523 printf("SLOT %d:%d disabled\n", 524 ecud->ecud_slot, func); 525 #endif 526 continue; 527 } 528 529 ecuf = kmem_zalloc(sizeof(*ecuf), KM_SLEEP); 530 ecuf_init(ecuf); 531 ecuf->ecuf_funcno = func; 532 SIMPLEQ_INSERT_TAIL(&ecud->ecud_funcs, ecuf, 533 ecuf_list); 534 535 memcpy(&ecuf->ecuf_id, dp, sizeof(ecuf->ecuf_id)); 536 dp += sizeof(ecuf->ecuf_id); 537 538 memcpy(&ecuf->ecuf_slot_info, dp, 539 sizeof(ecuf->ecuf_slot_info)); 540 dp += sizeof(ecuf->ecuf_slot_info); 541 542 memcpy(&ecuf->ecuf_cfg_ext, dp, 543 sizeof(ecuf->ecuf_cfg_ext)); 544 dp += sizeof(ecuf->ecuf_cfg_ext); 545 546 memcpy(&ecuf->ecuf_selections, dp, 547 sizeof(ecuf->ecuf_selections)); 548 dp += sizeof(ecuf->ecuf_selections); 549 550 memcpy(&ecuf->ecuf_func_info, dp, 551 sizeof(ecuf->ecuf_func_info)); 552 dp += sizeof(ecuf->ecuf_func_info); 553 554 if (ecuf->ecuf_func_info & ECUF_TYPE_STRING) 555 memcpy(ecuf->ecuf_type_string, dp, 556 sizeof(ecuf->ecuf_type_string)); 557 dp += sizeof(ecuf->ecuf_type_string); 558 559 if (ecuf->ecuf_func_info & ECUF_MEM_ENTRY) 560 eisa_parse_mem(ecuf, dp); 561 dp += ECUF_MEM_ENTRY_SIZE * ECUF_MEM_ENTRY_CNT; 562 563 if (ecuf->ecuf_func_info & ECUF_IRQ_ENTRY) 564 eisa_parse_irq(ecuf, dp); 565 dp += ECUF_IRQ_ENTRY_SIZE * ECUF_IRQ_ENTRY_CNT; 566 567 if (ecuf->ecuf_func_info & ECUF_DMA_ENTRY) 568 eisa_parse_dma(ecuf, dp); 569 dp += ECUF_DMA_ENTRY_SIZE * ECUF_DMA_ENTRY_CNT; 570 571 if (ecuf->ecuf_func_info & ECUF_IO_ENTRY) 572 eisa_parse_io(ecuf, dp); 573 dp += ECUF_IO_ENTRY_SIZE * ECUF_IO_ENTRY_CNT; 574 575 if (ecuf->ecuf_func_info & ECUF_INIT_ENTRY) 576 memcpy(ecuf->ecuf_init, dp, 577 sizeof(ecuf->ecuf_init)); 578 dp += sizeof(ecuf->ecuf_init); 579 } 580 } 581 582 kmem_free(cdata, CBUFSIZE); 583 kmem_free(data, CBUFSIZE); 584 } 585 586 static struct ecu_data * 587 eisa_lookup_data(int slot) 588 { 589 struct ecu_data *ecud; 590 591 SIMPLEQ_FOREACH(ecud, &ecu_data_list, ecud_list) { 592 if (ecud->ecud_slot == slot) 593 return (ecud); 594 } 595 return (NULL); 596 } 597 598 static struct ecu_func * 599 eisa_lookup_func(int slot, int func) 600 { 601 struct ecu_data *ecud; 602 struct ecu_func *ecuf; 603 604 ecud = eisa_lookup_data(slot); 605 if (ecud == NULL) 606 return (NULL); 607 608 SIMPLEQ_FOREACH(ecuf, &ecud->ecud_funcs, ecuf_list) { 609 if (ecuf->ecuf_funcno == func) 610 return (ecuf); 611 } 612 return (NULL); 613 } 614 615 int 616 eisa_conf_read_mem(eisa_chipset_tag_t ec, int slot, int func, int entry, 617 struct eisa_cfg_mem *dp) 618 { 619 struct ecu_func *ecuf; 620 struct ecu_mem *ecum; 621 622 ecuf = eisa_lookup_func(slot, func); 623 if (ecuf == NULL) 624 return (ENOENT); 625 626 SIMPLEQ_FOREACH(ecum, &ecuf->ecuf_mem, ecum_list) { 627 if (entry-- == 0) 628 break; 629 } 630 if (ecum == NULL) 631 return (ENOENT); 632 633 *dp = ecum->ecum_mem; 634 return (0); 635 } 636 637 int 638 eisa_conf_read_irq(eisa_chipset_tag_t ec, int slot, int func, int entry, 639 struct eisa_cfg_irq *dp) 640 { 641 struct ecu_func *ecuf; 642 struct ecu_irq *ecui; 643 644 ecuf = eisa_lookup_func(slot, func); 645 if (ecuf == NULL) 646 return (ENOENT); 647 648 SIMPLEQ_FOREACH(ecui, &ecuf->ecuf_irq, ecui_list) { 649 if (entry-- == 0) 650 break; 651 } 652 if (ecui == NULL) 653 return (ENOENT); 654 655 *dp = ecui->ecui_irq; 656 return (0); 657 } 658 659 int 660 eisa_conf_read_dma(eisa_chipset_tag_t ec, int slot, int func, int entry, 661 struct eisa_cfg_dma *dp) 662 { 663 struct ecu_func *ecuf; 664 struct ecu_dma *ecud; 665 666 ecuf = eisa_lookup_func(slot, func); 667 if (ecuf == NULL) 668 return (ENOENT); 669 670 SIMPLEQ_FOREACH(ecud, &ecuf->ecuf_dma, ecud_list) { 671 if (entry-- == 0) 672 break; 673 } 674 if (ecud == NULL) 675 return (ENOENT); 676 677 *dp = ecud->ecud_dma; 678 return (0); 679 } 680 681 int 682 eisa_conf_read_io(eisa_chipset_tag_t ec, int slot, int func, int entry, 683 struct eisa_cfg_io *dp) 684 { 685 struct ecu_func *ecuf; 686 struct ecu_io *ecuio; 687 688 ecuf = eisa_lookup_func(slot, func); 689 if (ecuf == NULL) 690 return (ENOENT); 691 692 SIMPLEQ_FOREACH(ecuio, &ecuf->ecuf_io, ecuio_list) { 693 if (entry-- == 0) 694 break; 695 } 696 if (ecuio == NULL) 697 return (ENOENT); 698 699 *dp = ecuio->ecuio_io; 700 return (0); 701 } 702
Indexes created Sat Sep 20 22:09:52 GMT 2025