xirc.c revision 1.2
1 /* $NetBSD: xirc.c,v 1.2 2004/08/08 07:25:20 mycroft Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2000, 2004 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 of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center and by Charles M. Hannum. 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 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: xirc.c,v 1.2 2004/08/08 07:25:20 mycroft Exp $"); 42 43 #include "opt_inet.h" 44 #include "opt_ns.h" 45 #include "bpfilter.h" 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/mbuf.h> 50 #include <sys/socket.h> 51 #include <sys/ioctl.h> 52 #include <sys/errno.h> 53 #include <sys/syslog.h> 54 #include <sys/select.h> 55 #include <sys/tty.h> 56 #include <sys/device.h> 57 58 #include <net/if.h> 59 #include <net/if_dl.h> 60 #include <net/if_ether.h> 61 #include <net/if_media.h> 62 63 #ifdef INET 64 #include <netinet/in.h> 65 #include <netinet/in_systm.h> 66 #include <netinet/in_var.h> 67 #include <netinet/ip.h> 68 #include <netinet/if_inarp.h> 69 #endif 70 71 #ifdef NS 72 #include <netns/ns.h> 73 #include <netns/ns_if.h> 74 #endif 75 76 #if NBPFILTER > 0 77 #include <net/bpf.h> 78 #include <net/bpfdesc.h> 79 #endif 80 81 #include <machine/intr.h> 82 #include <machine/bus.h> 83 84 #include <dev/pcmcia/pcmciareg.h> 85 #include <dev/pcmcia/pcmciavar.h> 86 #include <dev/pcmcia/pcmciadevs.h> 87 88 #include "xirc.h" 89 90 #if NCOM_XIRC > 0 91 #include <dev/ic/comreg.h> 92 #include <dev/ic/comvar.h> 93 #endif 94 95 #if NXI_XIRC > 0 96 #include <dev/mii/mii.h> 97 #include <dev/mii/miivar.h> 98 99 #include <dev/pcmcia/if_xivar.h> 100 #endif 101 #include <dev/pcmcia/if_xireg.h> 102 103 struct xirc_softc { 104 struct device sc_dev; /* generic device glue */ 105 106 struct pcmcia_function *sc_pf; /* our PCMCIA function */ 107 void *sc_ih; /* interrupt handle */ 108 109 u_int16_t sc_id; 110 int sc_chipset; 111 112 /* 113 * Data for the Modem portion. 114 */ 115 struct device *sc_modem; 116 struct pcmcia_io_handle sc_modem_pcioh; 117 int sc_modem_io_window; 118 119 /* 120 * Data for the Ethernet portion. 121 */ 122 struct device *sc_ethernet; 123 struct pcmcia_io_handle sc_ethernet_pcioh; 124 int sc_ethernet_io_window; 125 126 int sc_flags; 127 #define XIRC_MODEM_MAPPED 0x01 128 #define XIRC_ETHERNET_MAPPED 0x02 129 #define XIRC_MODEM_ENABLED 0x04 130 #define XIRC_ETHERNET_ENABLED 0x08 131 #define XIRC_MODEM_ALLOCED 0x10 132 #define XIRC_ETHERNET_ALLOCED 0x20 133 }; 134 135 int xirc_match __P((struct device *, struct cfdata *, void *)); 136 void xirc_attach __P((struct device *, struct device *, void *)); 137 int xirc_detach __P((struct device *, int)); 138 int xirc_activate __P((struct device *, enum devact)); 139 140 CFATTACH_DECL(xirc, sizeof(struct xirc_softc), 141 xirc_match, xirc_attach, xirc_detach, xirc_activate); 142 143 int xirc_print __P((void *, const char *)); 144 145 int xirc_manfid_ciscallback __P((struct pcmcia_tuple *, void *)); 146 struct pcmcia_config_entry * 147 xirc_mohawk_alloc __P((struct xirc_softc *)); 148 struct pcmcia_config_entry * 149 xirc_dingo_alloc_modem __P((struct xirc_softc *)); 150 struct pcmcia_config_entry * 151 xirc_dingo_alloc_ethernet __P((struct xirc_softc *)); 152 153 int xirc_enable __P((struct xirc_softc *, int)); 154 void xirc_disable __P((struct xirc_softc *, int)); 155 156 int xirc_intr __P((void *)); 157 158 int 159 xirc_match(parent, match, aux) 160 struct device *parent; 161 struct cfdata *match; 162 void *aux; 163 { 164 struct pcmcia_attach_args *pa = aux; 165 166 /* XXX Toshiba, Accton */ 167 168 if (pa->manufacturer == PCMCIA_VENDOR_COMPAQ2 && 169 pa->product == PCMCIA_PRODUCT_COMPAQ2_CPQ_10_100) 170 return (1); 171 172 if (pa->manufacturer == PCMCIA_VENDOR_INTEL && 173 pa->product == PCMCIA_PRODUCT_INTEL_EEPRO100) 174 return (1); 175 176 if (pa->manufacturer == PCMCIA_VENDOR_XIRCOM && 177 (pa->product & ((XIMEDIA_ETHER | XIMEDIA_MODEM) << 8)) != 0) 178 return (2); 179 180 return (0); 181 } 182 183 void 184 xirc_attach(parent, self, aux) 185 struct device *parent, *self; 186 void *aux; 187 { 188 struct xirc_softc *sc = (void *)self; 189 struct pcmcia_attach_args *pa = aux; 190 struct pcmcia_config_entry *cfe; 191 int rv; 192 193 aprint_normal("\n"); 194 195 sc->sc_pf = pa->pf; 196 197 pcmcia_socket_enable(parent); 198 rv = pcmcia_scan_cis(parent, xirc_manfid_ciscallback, &sc->sc_id); 199 pcmcia_socket_disable(parent); 200 if (!rv) { 201 aprint_error("%s: failed to find ID\n", self->dv_xname); 202 return; 203 } 204 205 switch (sc->sc_id & 0x100f) { 206 case 0x0001: /* CE */ 207 case 0x0002: /* CE2 */ 208 sc->sc_chipset = XI_CHIPSET_SCIPPER; 209 break; 210 case 0x0003: /* CE3 */ 211 sc->sc_chipset = XI_CHIPSET_MOHAWK; 212 break; 213 case 0x1001: 214 case 0x1002: 215 case 0x1003: 216 case 0x1004: 217 sc->sc_chipset = XI_CHIPSET_SCIPPER; 218 break; 219 case 0x1005: 220 sc->sc_chipset = XI_CHIPSET_MOHAWK; 221 break; 222 case 0x1006: 223 case 0x1007: 224 sc->sc_chipset = XI_CHIPSET_DINGO; 225 break; 226 default: 227 aprint_error("%s: unknown ID %04x\n", self->dv_xname, 228 sc->sc_id); 229 return; 230 } 231 232 aprint_normal("%s: id=%04x\n", self->dv_xname, sc->sc_id); 233 234 if (sc->sc_id & (XIMEDIA_MODEM << 8)) { 235 if (sc->sc_chipset >= XI_CHIPSET_DINGO) { 236 cfe = xirc_dingo_alloc_modem(sc); 237 if (!cfe) { 238 aprint_error("%s: failed to allocate I/O for modem\n", 239 self->dv_xname); 240 goto fail; 241 } 242 if (sc->sc_id & (XIMEDIA_ETHER << 8)) { 243 if (!xirc_dingo_alloc_ethernet(sc)) 244 aprint_error("%s: failed to allocate I/O for ethernet\n", 245 self->dv_xname); 246 } 247 } else { 248 cfe = xirc_mohawk_alloc(sc); 249 if (!cfe) { 250 aprint_error("%s: failed to allocate I/O\n", 251 self->dv_xname); 252 goto fail; 253 } 254 } 255 } else { 256 cfe = xirc_dingo_alloc_ethernet(sc); 257 if (!cfe) 258 aprint_error("%s: failed to allocate I/O for ethernet\n", 259 self->dv_xname); 260 } 261 262 /* Enable the card. */ 263 pcmcia_function_init(pa->pf, cfe); 264 if (pcmcia_function_enable(pa->pf)) { 265 aprint_error("%s: function enable failed\n", self->dv_xname); 266 goto fail; 267 } 268 269 if (sc->sc_id & (XIMEDIA_MODEM << 8)) 270 sc->sc_modem = config_found(self, "com", xirc_print); 271 if (sc->sc_id & (XIMEDIA_ETHER << 8)) 272 sc->sc_ethernet = config_found(self, "xi", xirc_print); 273 274 pcmcia_function_disable(pa->pf); 275 return; 276 277 fail: 278 /* Free our i/o spaces. */ 279 if (sc->sc_flags & XIRC_ETHERNET_ALLOCED) 280 pcmcia_io_free(sc->sc_pf, &sc->sc_ethernet_pcioh); 281 if (sc->sc_flags & XIRC_MODEM_ALLOCED) 282 pcmcia_io_free(sc->sc_pf, &sc->sc_modem_pcioh); 283 sc->sc_flags = 0; 284 } 285 286 int 287 xirc_manfid_ciscallback(tuple, arg) 288 struct pcmcia_tuple *tuple; 289 void *arg; 290 { 291 u_int16_t *id = arg; 292 293 if (tuple->code != PCMCIA_CISTPL_MANFID) 294 return (0); 295 296 if (tuple->length < 5) 297 return (0); 298 299 *id = (pcmcia_tuple_read_1(tuple, 3) << 8) | 300 pcmcia_tuple_read_1(tuple, 4); 301 return (1); 302 } 303 304 struct pcmcia_config_entry * 305 xirc_mohawk_alloc(sc) 306 struct xirc_softc *sc; 307 { 308 struct pcmcia_config_entry *cfe; 309 310 SIMPLEQ_FOREACH(cfe, &sc->sc_pf->cfe_head, cfe_list) { 311 if (cfe->num_iospace != 1) 312 continue; 313 314 if (pcmcia_io_alloc(sc->sc_pf, cfe->iospace[0].start, 315 cfe->iospace[0].length, cfe->iospace[0].length, 316 &sc->sc_modem_pcioh)) 317 continue; 318 319 if (pcmcia_io_alloc(sc->sc_pf, cfe->iospace[0].start+8, 320 XI_IOSIZE, XI_IOSIZE, &sc->sc_ethernet_pcioh) && 321 pcmcia_io_alloc(sc->sc_pf, cfe->iospace[0].start-24, 322 XI_IOSIZE, XI_IOSIZE, &sc->sc_ethernet_pcioh)) { 323 pcmcia_io_free(sc->sc_pf, &sc->sc_modem_pcioh); 324 continue; 325 } 326 327 /* Found one! */ 328 sc->sc_flags |= XIRC_MODEM_ALLOCED; 329 sc->sc_flags |= XIRC_ETHERNET_ALLOCED; 330 return (cfe); 331 } 332 333 return (0); 334 } 335 336 struct pcmcia_config_entry * 337 xirc_dingo_alloc_modem(sc) 338 struct xirc_softc *sc; 339 { 340 struct pcmcia_config_entry *cfe; 341 342 SIMPLEQ_FOREACH(cfe, &sc->sc_pf->cfe_head, cfe_list) { 343 if (cfe->num_iospace != 1) 344 continue; 345 346 if (pcmcia_io_alloc(sc->sc_pf, cfe->iospace[0].start, 347 cfe->iospace[0].length, cfe->iospace[0].length, 348 &sc->sc_modem_pcioh)) 349 continue; 350 351 /* Found one! */ 352 sc->sc_flags |= XIRC_MODEM_ALLOCED; 353 return (cfe); 354 } 355 356 return (0); 357 } 358 359 struct pcmcia_config_entry * 360 xirc_dingo_alloc_ethernet(sc) 361 struct xirc_softc *sc; 362 { 363 struct pcmcia_config_entry *cfe; 364 bus_addr_t port; 365 366 for (port = 0x300; port < 0x400; port += XI_IOSIZE) { 367 if (pcmcia_io_alloc(sc->sc_pf, port, 368 XI_IOSIZE, XI_IOSIZE, &sc->sc_ethernet_pcioh)) 369 continue; 370 371 /* Found one for the ethernet! */ 372 sc->sc_flags |= XIRC_ETHERNET_ALLOCED; 373 cfe = SIMPLEQ_FIRST(&sc->sc_pf->cfe_head); 374 return (cfe); 375 } 376 377 return (0); 378 } 379 380 int 381 xirc_print(aux, pnp) 382 void *aux; 383 const char *pnp; 384 { 385 const char *name = aux; 386 387 if (pnp) 388 aprint_normal("%s at %s(*)", name, pnp); 389 390 return (UNCONF); 391 } 392 393 int 394 xirc_detach(self, flags) 395 struct device *self; 396 int flags; 397 { 398 struct xirc_softc *sc = (void *)self; 399 int rv; 400 401 if (sc->sc_ethernet != NULL) { 402 rv = config_detach(sc->sc_ethernet, flags); 403 if (rv != 0) 404 return (rv); 405 sc->sc_ethernet = NULL; 406 } 407 408 if (sc->sc_modem != NULL) { 409 rv = config_detach(sc->sc_modem, flags); 410 if (rv != 0) 411 return (rv); 412 #ifdef not_necessary 413 sc->sc_modem = NULL; 414 #endif 415 } 416 417 /* Unmap our i/o windows. */ 418 if (sc->sc_flags & XIRC_ETHERNET_MAPPED) 419 pcmcia_io_unmap(sc->sc_pf, sc->sc_ethernet_io_window); 420 if (sc->sc_flags & XIRC_MODEM_MAPPED) 421 pcmcia_io_unmap(sc->sc_pf, sc->sc_modem_io_window); 422 423 /* Free our i/o spaces. */ 424 if (sc->sc_flags & XIRC_ETHERNET_ALLOCED) 425 pcmcia_io_free(sc->sc_pf, &sc->sc_ethernet_pcioh); 426 if (sc->sc_flags & XIRC_MODEM_ALLOCED) 427 pcmcia_io_free(sc->sc_pf, &sc->sc_modem_pcioh); 428 sc->sc_flags = 0; 429 430 return (0); 431 } 432 433 int 434 xirc_activate(self, act) 435 struct device *self; 436 enum devact act; 437 { 438 struct xirc_softc *sc = (void *)self; 439 int s, rv = 0; 440 441 s = splhigh(); 442 switch (act) { 443 case DVACT_ACTIVATE: 444 rv = EOPNOTSUPP; 445 break; 446 447 case DVACT_DEACTIVATE: 448 if (sc->sc_ethernet != NULL) { 449 rv = config_deactivate(sc->sc_ethernet); 450 if (rv != 0) 451 goto out; 452 } 453 454 if (sc->sc_modem != NULL) { 455 rv = config_deactivate(sc->sc_modem); 456 if (rv != 0) 457 goto out; 458 } 459 break; 460 } 461 out: 462 splx(s); 463 return (rv); 464 } 465 466 int 467 xirc_intr(arg) 468 void *arg; 469 { 470 struct xirc_softc *sc = arg; 471 int rval = 0; 472 473 #if NCOM_XIRC > 0 474 if (sc->sc_modem != NULL && 475 (sc->sc_flags & XIRC_MODEM_ENABLED) != 0) 476 rval |= comintr(sc->sc_modem); 477 #endif 478 479 #if NXI_XIRC > 0 480 if (sc->sc_ethernet != NULL && 481 (sc->sc_flags & XIRC_ETHERNET_ENABLED) != 0) 482 rval |= xi_intr(sc->sc_ethernet); 483 #endif 484 485 return (rval); 486 } 487 488 int 489 xirc_enable(sc, flag) 490 struct xirc_softc *sc; 491 int flag; 492 { 493 494 if (sc->sc_flags & flag) { 495 printf("%s: %s already enabled\n", sc->sc_dev.dv_xname, 496 (flag & XIRC_MODEM_ENABLED) ? "modem" : "ethernet"); 497 panic("xirc_enable"); 498 } 499 500 if ((sc->sc_flags & (XIRC_MODEM_ENABLED|XIRC_ETHERNET_ENABLED)) != 0) { 501 sc->sc_flags |= flag; 502 return (0); 503 } 504 505 /* 506 * Establish our interrupt handler. 507 * 508 * XXX Note, we establish this at IPL_NET. This is suboptimal 509 * XXX the Modem portion, but is necessary to make the Ethernet 510 * XXX portion have the correct interrupt level semantics. 511 * 512 * XXX Eventually we should use the `enabled' bits in the 513 * XXX flags word to determine which level we should be at. 514 */ 515 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET, 516 xirc_intr, sc); 517 if (sc->sc_ih == NULL) { 518 printf("%s: unable to establish interrupt\n", 519 sc->sc_dev.dv_xname); 520 return (EIO); 521 } 522 523 if (pcmcia_function_enable(sc->sc_pf)) { 524 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); 525 return (EIO); 526 } 527 528 sc->sc_flags |= flag; 529 return (0); 530 } 531 532 void 533 xirc_disable(sc, flag) 534 struct xirc_softc *sc; 535 int flag; 536 { 537 538 if ((sc->sc_flags & flag) == 0) { 539 printf("%s: %s already disabled\n", sc->sc_dev.dv_xname, 540 (flag & XIRC_MODEM_ENABLED) ? "modem" : "ethernet"); 541 panic("xirc_disable"); 542 } 543 544 sc->sc_flags &= ~flag; 545 if ((sc->sc_flags & (XIRC_MODEM_ENABLED|XIRC_ETHERNET_ENABLED)) != 0) 546 return; 547 548 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); 549 pcmcia_function_disable(sc->sc_pf); 550 } 551 552 /****** Here begins the com attachment code. ******/ 553 554 #if NCOM_XIRC > 0 555 int com_xirc_match __P((struct device *, struct cfdata *, void *)); 556 void com_xirc_attach __P((struct device *, struct device *, void *)); 557 int com_xirc_detach __P((struct device *, int)); 558 559 /* No xirc-specific goo in the softc; it's all in the parent. */ 560 CFATTACH_DECL(com_xirc, sizeof(struct com_softc), 561 com_xirc_match, com_xirc_attach, com_detach, com_activate); 562 563 int com_xirc_enable __P((struct com_softc *)); 564 void com_xirc_disable __P((struct com_softc *)); 565 566 int 567 com_xirc_match(parent, match, aux) 568 struct device *parent; 569 struct cfdata *match; 570 void *aux; 571 { 572 extern struct cfdriver com_cd; 573 const char *name = aux; 574 575 if (strcmp(name, com_cd.cd_name) == 0) 576 return (1); 577 578 return (0); 579 } 580 581 void 582 com_xirc_attach(parent, self, aux) 583 struct device *parent, *self; 584 void *aux; 585 { 586 struct com_softc *sc = (void *)self; 587 struct xirc_softc *msc = (void *)parent; 588 589 aprint_normal("\n"); 590 591 if (pcmcia_io_map(msc->sc_pf, PCMCIA_WIDTH_IO8, 0, 592 msc->sc_modem_pcioh.size, &msc->sc_modem_pcioh, 593 &msc->sc_modem_io_window)) { 594 aprint_error("%s: unable to map I/O space\n", self->dv_xname); 595 return; 596 } 597 msc->sc_flags |= XIRC_MODEM_MAPPED; 598 599 sc->sc_iot = msc->sc_modem_pcioh.iot; 600 sc->sc_ioh = msc->sc_modem_pcioh.ioh; 601 602 sc->enabled = 1; 603 604 sc->sc_iobase = -1; 605 sc->sc_frequency = COM_FREQ; 606 607 sc->enable = com_xirc_enable; 608 sc->disable = com_xirc_disable; 609 610 aprint_normal("%s", self->dv_xname); 611 612 com_attach_subr(sc); 613 614 sc->enabled = 0; 615 } 616 617 int 618 com_xirc_enable(sc) 619 struct com_softc *sc; 620 { 621 622 return (xirc_enable((struct xirc_softc *)sc->sc_dev.dv_parent, 623 XIRC_MODEM_ENABLED)); 624 } 625 626 void 627 com_xirc_disable(sc) 628 struct com_softc *sc; 629 { 630 631 xirc_disable((struct xirc_softc *)sc->sc_dev.dv_parent, 632 XIRC_MODEM_ENABLED); 633 } 634 635 #endif /* NCOM_XIRC > 0 */ 636 637 /****** Here begins the xi attachment code. ******/ 638 639 #if NXI_XIRC > 0 640 int xi_xirc_match __P((struct device *, struct cfdata *, void *)); 641 void xi_xirc_attach __P((struct device *, struct device *, void *)); 642 643 /* No xirc-specific goo in the softc; it's all in the parent. */ 644 CFATTACH_DECL(xi_xirc, sizeof(struct xi_softc), 645 xi_xirc_match, xi_xirc_attach, xi_detach, xi_activate); 646 647 int xi_xirc_enable __P((struct xi_softc *)); 648 void xi_xirc_disable __P((struct xi_softc *)); 649 int xi_xirc_lan_nid_ciscallback __P((struct pcmcia_tuple *, void *)); 650 651 int 652 xi_xirc_match(parent, match, aux) 653 struct device *parent; 654 struct cfdata *match; 655 void *aux; 656 { 657 extern struct cfdriver xi_cd; 658 const char *name = aux; 659 660 if (strcmp(name, xi_cd.cd_name) == 0) 661 return (1); 662 663 return (0); 664 } 665 666 void 667 xi_xirc_attach(parent, self, aux) 668 struct device *parent, *self; 669 void *aux; 670 { 671 struct xi_softc *sc = (void *)self; 672 struct xirc_softc *msc = (void *)parent; 673 u_int8_t myla[ETHER_ADDR_LEN]; 674 675 aprint_normal("\n"); 676 677 if (pcmcia_io_map(msc->sc_pf, PCMCIA_WIDTH_AUTO, 0, 678 msc->sc_ethernet_pcioh.size, &msc->sc_ethernet_pcioh, 679 &msc->sc_ethernet_io_window)) { 680 aprint_error("%s: unable to map I/O space\n", self->dv_xname); 681 return; 682 } 683 msc->sc_flags |= XIRC_ETHERNET_MAPPED; 684 685 sc->sc_bst = msc->sc_ethernet_pcioh.iot; 686 sc->sc_bsh = msc->sc_ethernet_pcioh.ioh; 687 688 sc->sc_chipset = msc->sc_chipset; 689 690 sc->sc_enable = xi_xirc_enable; 691 sc->sc_disable = xi_xirc_disable; 692 693 if (!pcmcia_scan_cis(msc->sc_dev.dv_parent, xi_xirc_lan_nid_ciscallback, 694 myla)) { 695 aprint_error("%s: can't find MAC address\n", self->dv_xname); 696 return; 697 } 698 699 /* Perform generic initialization. */ 700 xi_attach(sc, myla); 701 } 702 703 int 704 xi_xirc_enable(sc) 705 struct xi_softc *sc; 706 { 707 708 return (xirc_enable((struct xirc_softc *)sc->sc_dev.dv_parent, 709 XIRC_ETHERNET_ENABLED)); 710 } 711 712 void 713 xi_xirc_disable(sc) 714 struct xi_softc *sc; 715 { 716 717 xirc_disable((struct xirc_softc *)sc->sc_dev.dv_parent, 718 XIRC_ETHERNET_ENABLED); 719 } 720 721 int 722 xi_xirc_lan_nid_ciscallback(tuple, arg) 723 struct pcmcia_tuple *tuple; 724 void *arg; 725 { 726 u_int8_t *myla = arg; 727 int i; 728 729 if (tuple->length < 2) 730 return (0); 731 732 switch (tuple->code) { 733 case PCMCIA_CISTPL_FUNCE: 734 switch (pcmcia_tuple_read_1(tuple, 0)) { 735 case PCMCIA_TPLFE_TYPE_LAN_NID: 736 if (pcmcia_tuple_read_1(tuple, 1) != ETHER_ADDR_LEN) 737 return (0); 738 for (i = 0; i < ETHER_ADDR_LEN; i++) 739 myla[i] = pcmcia_tuple_read_1(tuple, i + 2); 740 return (1); 741 742 case 0x02: 743 /* 744 * Not sure about this, I don't have a CE2 745 * that puts the ethernet addr here. 746 */ 747 if (pcmcia_tuple_read_1(tuple, 1) != 0x01 || 748 pcmcia_tuple_read_1(tuple, 2) != ETHER_ADDR_LEN) 749 return (0); 750 for (i = 0; i < ETHER_ADDR_LEN; i++) 751 myla[i] = pcmcia_tuple_read_1(tuple, i + 3); 752 return (1); 753 } 754 755 case 0x89: 756 if (pcmcia_tuple_read_1(tuple, 0) != 0x04 || 757 pcmcia_tuple_read_1(tuple, 1) != ETHER_ADDR_LEN) 758 return (0); 759 for (i = 0; i < ETHER_ADDR_LEN; i++) 760 myla[i] = pcmcia_tuple_read_1(tuple, i + 2); 761 return (1); 762 } 763 764 return (0); 765 } 766 767 #endif /* NXI_XIRC > 0 */ 768
Indexes created Wed Oct 01 07:09:59 GMT 2025