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