eisa_machdep.c revision 1.1
1 /* $NetBSD: eisa_machdep.c,v 1.1 2000/07/29 23:18:47 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 41 __KERNEL_RCSID(0, "$NetBSD: eisa_machdep.c,v 1.1 2000/07/29 23:18:47 thorpej Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/device.h> 46 #include <sys/malloc.h> 47 #include <sys/queue.h> 48 49 #include <machine/intr.h> 50 #include <machine/rpb.h> 51 52 #include <dev/eisa/eisareg.h> 53 #include <dev/eisa/eisavar.h> 54 55 #define EISA_SLOT_HEADER_SIZE 31 56 #define EISA_SLOT_INFO_OFFSET 20 57 58 #define EISA_FUNC_INFO_OFFSET 34 59 #define EISA_CONFIG_BLOCK_SIZE 320 60 61 #define ECUF_TYPE_STRING 0x01 62 #define ECUF_MEM_ENTRY 0x02 63 #define ECUF_IRQ_ENTRY 0x04 64 #define ECUF_DMA_ENTRY 0x08 65 #define ECUF_IO_ENTRY 0x10 66 #define ECUF_INIT_ENTRY 0x20 67 #define ECUF_DISABLED 0x80 68 69 #define ECUF_SELECTIONS_SIZE 26 70 #define ECUF_TYPE_STRING_SIZE 80 71 #define ECUF_MEM_ENTRY_SIZE 7 72 #define ECUF_IRQ_ENTRY_SIZE 2 73 #define ECUF_DMA_ENTRY_SIZE 2 74 #define ECUF_IO_ENTRY_SIZE 3 75 #define ECUF_INIT_ENTRY_SIZE 60 76 77 #define ECUF_MEM_ENTRY_CNT 9 78 #define ECUF_IRQ_ENTRY_CNT 7 79 #define ECUF_DMA_ENTRY_CNT 4 80 #define ECUF_IO_ENTRY_CNT 20 81 82 /* 83 * EISA configuration space, as set up by the ECU, may be sparse. 84 */ 85 bus_size_t eisa_config_stride; 86 paddr_t eisa_config_addr; /* defaults to 0 */ 87 paddr_t eisa_config_header_addr; 88 89 struct ecu_mem { 90 SIMPLEQ_ENTRY(ecu_mem) ecum_list; 91 bus_addr_t ecum_addr; 92 bus_size_t ecum_size; 93 int ecum_isram; 94 int ecum_decode; 95 int ecum_unitsize; 96 }; 97 98 struct ecu_irq { 99 SIMPLEQ_ENTRY(ecu_irq) ecui_list; 100 int ecui_irq; 101 int ecui_ist; 102 int ecui_shared; 103 }; 104 105 struct ecu_dma { 106 SIMPLEQ_ENTRY(ecu_dma) ecud_list; 107 int ecud_drq; 108 int ecud_shared; 109 int ecud_size; 110 #define ECUD_SIZE_8BIT 0 111 #define ECUD_SIZE_16BIT 1 112 #define ECUD_SIZE_32BIT 2 113 #define ECUD_SIZE_RESERVED 3 114 int ecud_timing; 115 #define ECUD_TIMING_ISA 0 116 #define ECUD_TIMING_TYPEA 1 117 #define ECUD_TIMING_TYPEB 2 118 #define ECUD_TIMING_TYPEC 3 119 }; 120 121 struct ecu_io { 122 SIMPLEQ_ENTRY(ecu_io) ecuio_list; 123 bus_addr_t ecuio_addr; 124 bus_size_t ecuio_size; 125 int ecuio_shared; 126 }; 127 128 struct ecu_func { 129 SIMPLEQ_ENTRY(ecu_func) ecuf_list; 130 int ecuf_funcno; 131 u_int32_t ecuf_id; 132 u_int16_t ecuf_slot_info; 133 u_int16_t ecuf_cfg_ext; 134 u_int8_t ecuf_selections[ECUF_SELECTIONS_SIZE]; 135 u_int8_t ecuf_func_info; 136 u_int8_t ecuf_type_string[ECUF_TYPE_STRING_SIZE]; 137 u_int8_t ecuf_init[ECUF_INIT_ENTRY_SIZE]; 138 SIMPLEQ_HEAD(, ecu_mem) ecuf_mem; 139 SIMPLEQ_HEAD(, ecu_irq) ecuf_irq; 140 SIMPLEQ_HEAD(, ecu_dma) ecuf_dma; 141 SIMPLEQ_HEAD(, ecu_io) ecuf_io; 142 }; 143 144 struct ecu_data { 145 SIMPLEQ_ENTRY(ecu_data) ecud_list; 146 int ecud_slot; 147 u_int8_t ecud_eisaid[EISA_IDSTRINGLEN]; 148 u_int32_t ecud_offset; 149 150 /* General slot info. */ 151 u_int8_t ecud_slot_info; 152 u_int16_t ecud_ecu_major_rev; 153 u_int16_t ecud_ecu_minor_rev; 154 u_int16_t ecud_cksum; 155 u_int16_t ecud_ndevfuncs; 156 u_int8_t ecud_funcinfo; 157 u_int32_t ecud_comp_id; 158 159 /* The functions */ 160 SIMPLEQ_HEAD(, ecu_func) ecud_funcs; 161 }; 162 163 SIMPLEQ_HEAD(, ecu_data) ecu_data_list = 164 SIMPLEQ_HEAD_INITIALIZER(ecu_data_list); 165 166 static void 167 ecuf_init(struct ecu_func *ecuf) 168 { 169 170 memset(ecuf, 0, sizeof(*ecuf)); 171 SIMPLEQ_INIT(&ecuf->ecuf_mem); 172 SIMPLEQ_INIT(&ecuf->ecuf_irq); 173 SIMPLEQ_INIT(&ecuf->ecuf_dma); 174 SIMPLEQ_INIT(&ecuf->ecuf_io); 175 } 176 177 static void 178 eisa_parse_mem(struct ecu_func *ecuf, u_int8_t *dp) 179 { 180 struct ecu_mem *ecum; 181 int i; 182 183 for (i = 0; i < ECUF_MEM_ENTRY_CNT; i++) { 184 ecum = malloc(sizeof(*ecum), M_DEVBUF, M_WAITOK); 185 186 ecum->ecum_isram = dp[0] & 0x1; 187 ecum->ecum_unitsize = dp[1] & 0x3; 188 ecum->ecum_decode = (dp[1] >> 2) & 0x3; 189 ecum->ecum_addr = (dp[2] | (dp[3] << 8) | (dp[4] << 16)) << 8; 190 ecum->ecum_size = (dp[5] | (dp[6] << 8)) << 10; 191 if (ecum->ecum_size == 0) 192 ecum->ecum_size = (1 << 26); 193 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_mem, ecum, ecum_list); 194 195 #if 0 196 printf("MEM 0x%lx 0x%lx %d %d %d\n", 197 ecum->ecum_addr, ecum->ecum_size, 198 ecum->ecum_isram, ecum->ecum_unitsize, 199 ecum->ecum_decode); 200 #endif 201 202 if ((dp[0] & 0x80) == 0) 203 break; 204 dp += ECUF_MEM_ENTRY_SIZE; 205 } 206 } 207 208 static void 209 eisa_parse_irq(struct ecu_func *ecuf, u_int8_t *dp) 210 { 211 struct ecu_irq *ecui; 212 int i; 213 214 for (i = 0; i < ECUF_IRQ_ENTRY_CNT; i++) { 215 ecui = malloc(sizeof(*ecui), M_DEVBUF, M_WAITOK); 216 217 ecui->ecui_irq = dp[0] & 0xf; 218 ecui->ecui_ist = (dp[0] & 0x20) ? IST_LEVEL : IST_EDGE; 219 ecui->ecui_shared = (dp[0] & 0x40) ? 1 : 0; 220 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_irq, ecui, ecui_list); 221 222 #if 0 223 printf("IRQ %d %s%s\n", ecui->ecui_irq, 224 ecui->ecui_ist == IST_LEVEL ? "level" : "edge", 225 ecui->ecui_shared ? " shared" : ""); 226 #endif 227 228 if ((dp[0] & 0x80) == 0) 229 break; 230 dp += ECUF_IRQ_ENTRY_SIZE; 231 } 232 } 233 234 static void 235 eisa_parse_dma(struct ecu_func *ecuf, u_int8_t *dp) 236 { 237 struct ecu_dma *ecud; 238 int i; 239 240 for (i = 0; i < ECUF_DMA_ENTRY_CNT; i++) { 241 ecud = malloc(sizeof(*ecud), M_DEVBUF, M_WAITOK); 242 243 ecud->ecud_drq = dp[0] & 0x7; 244 ecud->ecud_shared = dp[0] & 0x40; 245 ecud->ecud_size = (dp[1] >> 2) & 0x3; 246 ecud->ecud_timing = (dp[1] >> 4) & 0x3; 247 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_dma, ecud, ecud_list); 248 249 #if 0 250 printf("DRQ %d%s %d %d\n", ecud->ecud_drq, 251 ecud->ecud_shared ? " shared" : "", 252 ecud->ecud_size, ecud->ecud_timing); 253 #endif 254 255 if ((dp[0] & 0x80) == 0) 256 break; 257 dp += ECUF_DMA_ENTRY_SIZE; 258 } 259 } 260 261 static void 262 eisa_parse_io(struct ecu_func *ecuf, u_int8_t *dp) 263 { 264 struct ecu_io *ecuio; 265 int i; 266 267 for (i = 0; i < ECUF_IO_ENTRY_CNT; i++) { 268 ecuio = malloc(sizeof(*ecuio), M_DEVBUF, M_WAITOK); 269 270 ecuio->ecuio_addr = dp[1] | (dp[2] << 8); 271 ecuio->ecuio_size = (dp[0] & 0x1f) + 1; 272 ecuio->ecuio_shared = (dp[0] & 0x40) ? 1 : 0; 273 274 #if 0 275 printf("IO 0x%lx 0x%lx%s\n", ecuio->ecuio_addr, 276 ecuio->ecuio_size, 277 ecuio->ecuio_shared ? " shared" : ""); 278 #endif 279 280 if ((dp[0] & 0x80) == 0) 281 break; 282 dp += ECUF_IO_ENTRY_SIZE; 283 } 284 } 285 286 static void 287 eisa_read_config_bytes(paddr_t addr, void *buf, size_t count) 288 { 289 const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr); 290 u_int8_t *dst = buf; 291 292 for (; count != 0; count--) { 293 *dst++ = *src; 294 src += eisa_config_stride; 295 } 296 } 297 298 static void 299 eisa_read_config_word(paddr_t addr, u_int32_t *valp) 300 { 301 const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr); 302 u_int32_t val = 0; 303 int i; 304 305 for (i = 0; i < sizeof(val); i++) { 306 val |= (u_int)(*src << (i * 8)); 307 src += eisa_config_stride; 308 } 309 310 *valp = val; 311 } 312 313 static size_t 314 eisa_uncompress(void *cbufp, void *ucbufp, size_t count) 315 { 316 const u_int8_t *cbuf = cbufp; 317 u_int8_t *ucbuf = ucbufp; 318 u_int zeros = 0; 319 320 while (count--) { 321 if (zeros) { 322 zeros--; 323 *ucbuf++ = '\0'; 324 } else if (*cbuf == '\0') { 325 *ucbuf++ = *cbuf++; 326 zeros = *cbuf++ - 1; 327 } else 328 *ucbuf++ = *cbuf++; 329 } 330 331 return ((size_t)cbuf - (size_t)cbufp); 332 } 333 334 void 335 eisa_init() 336 { 337 struct ecu_data *ecud; 338 paddr_t cfgaddr; 339 u_int32_t offset; 340 u_int8_t eisaid[EISA_IDSTRINGLEN]; 341 u_int8_t *cdata, *data; 342 u_int8_t *cdp, *dp; 343 struct ecu_func *ecuf; 344 int i, func; 345 346 /* 347 * Locate EISA configuration space. 348 */ 349 if (hwrpb->rpb_condat_off == 0UL || 350 (hwrpb->rpb_condat_off >> 63) != 0) { 351 printf(": WARNING: no EISA configuration space"); 352 return; 353 } 354 355 if (eisa_config_header_addr) { 356 printf("\n"); 357 panic("eisa_init: EISA config space already initialized"); 358 } 359 360 eisa_config_header_addr = hwrpb->rpb_condat_off; 361 #if 0 362 printf("\nEISA config header at 0x%lx\n", eisa_config_header_addr); 363 #endif 364 if (eisa_config_stride == 0) 365 eisa_config_stride = 1; 366 367 /* 368 * Read the slot headers, and allocate config structures for 369 * valid slots. 370 */ 371 for (cfgaddr = eisa_config_header_addr, i = 0; i < 16 /* XXX */; i++) { 372 eisa_read_config_bytes(cfgaddr, eisaid, sizeof(eisaid)); 373 eisaid[EISA_IDSTRINGLEN - 1] = '\0'; /* sanity */ 374 cfgaddr += sizeof(eisaid) * eisa_config_stride; 375 eisa_read_config_word(cfgaddr, &offset); 376 cfgaddr += sizeof(offset) * eisa_config_stride; 377 378 if (offset != 0) { 379 #if 0 380 printf("SLOT %d: offset 0x%08x eisaid %s\n", 381 i, offset, eisaid); 382 #endif 383 ecud = malloc(sizeof(*ecud), M_DEVBUF, M_WAITOK); 384 memset(ecud, 0, sizeof(*ecud)); 385 386 SIMPLEQ_INIT(&ecud->ecud_funcs); 387 388 ecud->ecud_slot = i; 389 memcpy(ecud->ecud_eisaid, eisaid, sizeof(eisaid)); 390 ecud->ecud_offset = offset; 391 SIMPLEQ_INSERT_TAIL(&ecu_data_list, ecud, ecud_list); 392 } 393 } 394 395 /* 396 * Now traverse the valid slots and read the info. 397 */ 398 399 cdata = malloc(512, M_TEMP, M_WAITOK); 400 data = malloc(512, M_TEMP, M_WAITOK); 401 402 for (ecud = SIMPLEQ_FIRST(&ecu_data_list); ecud != NULL; 403 ecud = SIMPLEQ_NEXT(ecud, ecud_list)) { 404 cfgaddr = eisa_config_addr + ecud->ecud_offset; 405 eisa_read_config_bytes(cfgaddr, &cdata[0], 1); 406 cfgaddr += eisa_config_stride; 407 408 for (i = 1; ; cfgaddr += eisa_config_stride, i++) { 409 eisa_read_config_bytes(cfgaddr, &cdata[i], 1); 410 if (cdata[i - 1] == 0 && cdata[i] == 0) 411 break; 412 } 413 i++; /* index -> length */ 414 415 #if 0 416 printf("SLOT %d compressed data length %d:", 417 ecud->ecud_slot, i); 418 { 419 int j; 420 421 for (j = 0; j < i; j++) { 422 if ((j % 16) == 0) 423 printf("\n"); 424 printf("0x%02x ", cdata[j]); 425 } 426 printf("\n"); 427 } 428 #endif 429 430 cdp = cdata; 431 dp = data; 432 433 /* Uncompress the slot header. */ 434 cdp += eisa_uncompress(cdp, dp, EISA_SLOT_HEADER_SIZE); 435 #if 0 436 printf("SLOT %d uncompressed header data:", 437 ecud->ecud_slot); 438 { 439 int j; 440 441 for (j = 0; j < EISA_SLOT_HEADER_SIZE; j++) { 442 if ((j % 16) == 0) 443 printf("\n"); 444 printf("0x%02x ", dp[j]); 445 } 446 printf("\n"); 447 } 448 #endif 449 450 dp = &data[EISA_SLOT_INFO_OFFSET]; 451 ecud->ecud_slot_info = *dp++; 452 ecud->ecud_ecu_major_rev = *dp++; 453 ecud->ecud_ecu_minor_rev = *dp++; 454 memcpy(&ecud->ecud_cksum, dp, sizeof(ecud->ecud_cksum)); 455 dp += sizeof(ecud->ecud_cksum); 456 ecud->ecud_ndevfuncs = *dp++; 457 ecud->ecud_funcinfo = *dp++; 458 memcpy(&ecud->ecud_comp_id, dp, sizeof(ecud->ecud_comp_id)); 459 dp += sizeof(ecud->ecud_comp_id); 460 461 #if 0 462 printf("SLOT %d: ndevfuncs %d\n", ecud->ecud_slot, 463 ecud->ecud_ndevfuncs); 464 #endif 465 466 for (func = 0; func < ecud->ecud_ndevfuncs; func++) { 467 dp = data; 468 cdp += eisa_uncompress(cdp, dp, EISA_CONFIG_BLOCK_SIZE); 469 #if 0 470 printf("SLOT %d:%d uncompressed data:", 471 ecud->ecud_slot, func); 472 { 473 int j; 474 475 for (j = 0; i < EISA_CONFIG_BLOCK_SIZE; j++) { 476 if ((j % 16) == 0) 477 printf("\n"); 478 printf("0x%02x ", dp[j]); 479 } 480 printf("\n"); 481 } 482 #endif 483 484 /* Skip disabled functions. */ 485 if (dp[EISA_FUNC_INFO_OFFSET] & ECUF_DISABLED) { 486 printf("SLOT %d:%d disabled\n", 487 ecud->ecud_slot, func); 488 continue; 489 } 490 491 ecuf = malloc(sizeof(*ecuf), M_DEVBUF, M_WAITOK); 492 ecuf_init(ecuf); 493 ecuf->ecuf_funcno = func; 494 SIMPLEQ_INSERT_TAIL(&ecud->ecud_funcs, ecuf, 495 ecuf_list); 496 497 memcpy(&ecuf->ecuf_id, dp, sizeof(ecuf->ecuf_id)); 498 dp += sizeof(ecuf->ecuf_id); 499 500 memcpy(&ecuf->ecuf_slot_info, dp, 501 sizeof(ecuf->ecuf_slot_info)); 502 dp += sizeof(ecuf->ecuf_slot_info); 503 504 memcpy(&ecuf->ecuf_cfg_ext, dp, 505 sizeof(ecuf->ecuf_cfg_ext)); 506 dp += sizeof(ecuf->ecuf_cfg_ext); 507 508 memcpy(&ecuf->ecuf_selections, dp, 509 sizeof(ecuf->ecuf_selections)); 510 dp += sizeof(ecuf->ecuf_selections); 511 512 memcpy(&ecuf->ecuf_func_info, dp, 513 sizeof(ecuf->ecuf_func_info)); 514 dp += sizeof(ecuf->ecuf_func_info); 515 516 if (ecuf->ecuf_func_info & ECUF_TYPE_STRING) 517 memcpy(ecuf->ecuf_type_string, dp, 518 sizeof(ecuf->ecuf_type_string)); 519 dp += sizeof(ecuf->ecuf_type_string); 520 521 if (ecuf->ecuf_func_info & ECUF_MEM_ENTRY) 522 eisa_parse_mem(ecuf, dp); 523 dp += ECUF_MEM_ENTRY_SIZE * ECUF_MEM_ENTRY_CNT; 524 525 if (ecuf->ecuf_func_info & ECUF_IRQ_ENTRY) 526 eisa_parse_irq(ecuf, dp); 527 dp += ECUF_IRQ_ENTRY_SIZE * ECUF_IRQ_ENTRY_CNT; 528 529 if (ecuf->ecuf_func_info & ECUF_DMA_ENTRY) 530 eisa_parse_dma(ecuf, dp); 531 dp += ECUF_DMA_ENTRY_SIZE * ECUF_DMA_ENTRY_CNT; 532 533 if (ecuf->ecuf_func_info & ECUF_IO_ENTRY) 534 eisa_parse_io(ecuf, dp); 535 dp += ECUF_IO_ENTRY_SIZE * ECUF_IO_ENTRY_CNT; 536 537 if (ecuf->ecuf_func_info & ECUF_INIT_ENTRY) 538 memcpy(ecuf->ecuf_init, dp, 539 sizeof(ecuf->ecuf_init)); 540 dp += sizeof(ecuf->ecuf_init); 541 } 542 } 543 544 free(cdata, M_TEMP); 545 free(data, M_TEMP); 546 } 547
Indexes created Thu Oct 02 01:09:59 GMT 2025