1 /* $NetBSD: if_mc.c,v 1.35 2008/11/07 00:20:01 dyoung Exp $ */ 2 3 /*- 4 * Copyright (c) 1997 David Huang <khym@azeotrope.org> 5 * All rights reserved. 6 * 7 * Portions of this code are based on code by Denton Gentry <denny1@home.com>, 8 * Charles M. Hannum, Yanagisawa Takeshi <yanagisw@aa.ap.titech.ac.jp>, and 9 * 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. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 */ 31 32 /* 33 * Driver for the AMD Am79C940 (MACE) ethernet chip, used for onboard 34 * ethernet on the Centris/Quadra 660av and Quadra 840av. 35 */ 36 37 #include <sys/cdefs.h> 38 __KERNEL_RCSID(0, "$NetBSD: if_mc.c,v 1.35 2008/11/07 00:20:01 dyoung Exp $"); 39 40 #include "opt_ddb.h" 41 #include "opt_inet.h" 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/mbuf.h> 46 #include <sys/buf.h> 47 #include <sys/protosw.h> 48 #include <sys/socket.h> 49 #include <sys/syslog.h> 50 #include <sys/ioctl.h> 51 #include <sys/errno.h> 52 #include <sys/device.h> 53 54 #include <uvm/uvm_extern.h> 55 56 #include <net/if.h> 57 #include <net/if_dl.h> 58 #include <net/if_ether.h> 59 60 #ifdef INET 61 #include <netinet/in.h> 62 #include <netinet/if_inarp.h> 63 #include <netinet/in_systm.h> 64 #include <netinet/in_var.h> 65 #include <netinet/ip.h> 66 #endif 67 68 69 70 #include "bpfilter.h" 71 #if NBPFILTER > 0 72 #include <net/bpf.h> 73 #include <net/bpfdesc.h> 74 #endif 75 76 #include <machine/bus.h> 77 #include <mac68k/dev/if_mcreg.h> 78 #include <mac68k/dev/if_mcvar.h> 79 80 hide void mcwatchdog(struct ifnet *); 81 hide int mcinit(struct mc_softc *); 82 hide int mcstop(struct mc_softc *); 83 hide int mcioctl(struct ifnet *, u_long, void *); 84 hide void mcstart(struct ifnet *); 85 hide void mcreset(struct mc_softc *); 86 87 integrate u_int maceput(struct mc_softc *, struct mbuf *); 88 integrate void mc_tint(struct mc_softc *); 89 integrate void mace_read(struct mc_softc *, void *, int); 90 integrate struct mbuf *mace_get(struct mc_softc *, void *, int); 91 static void mace_calcladrf(struct ethercom *, u_int8_t *); 92 static inline u_int16_t ether_cmp(void *, void *); 93 94 95 /* 96 * Compare two Ether/802 addresses for equality, inlined and 97 * unrolled for speed. Use this like bcmp(). 98 * 99 * XXX: Add <machine/inlines.h> for stuff like this? 100 * XXX: or maybe add it to libkern.h instead? 101 * 102 * "I'd love to have an inline assembler version of this." 103 * XXX: Who wanted that? mycroft? I wrote one, but this 104 * version in C is as good as hand-coded assembly. -gwr 105 * 106 * Please do NOT tweak this without looking at the actual 107 * assembly code generated before and after your tweaks! 108 */ 109 static inline u_int16_t 110 ether_cmp(void *one, void *two) 111 { 112 u_int16_t *a = (u_short *) one; 113 u_int16_t *b = (u_short *) two; 114 u_int16_t diff; 115 116 #ifdef m68k 117 /* 118 * The post-increment-pointer form produces the best 119 * machine code for m68k. This was carefully tuned 120 * so it compiles to just 8 short (2-byte) op-codes! 121 */ 122 diff = *a++ - *b++; 123 diff |= *a++ - *b++; 124 diff |= *a++ - *b++; 125 #else 126 /* 127 * Most modern CPUs do better with a single expresion. 128 * Note that short-cut evaluation is NOT helpful here, 129 * because it just makes the code longer, not faster! 130 */ 131 diff = (a[0] - b[0]) | (a[1] - b[1]) | (a[2] - b[2]); 132 #endif 133 134 return (diff); 135 } 136 137 #define ETHER_CMP ether_cmp 138 139 /* 140 * Interface exists: make available by filling in network interface 141 * record. System will initialize the interface when it is ready 142 * to accept packets. 143 */ 144 int 145 mcsetup(struct mc_softc *sc, u_int8_t *lladdr) 146 { 147 struct ifnet *ifp = &sc->sc_if; 148 149 /* reset the chip and disable all interrupts */ 150 NIC_PUT(sc, MACE_BIUCC, SWRST); 151 DELAY(100); 152 NIC_PUT(sc, MACE_IMR, ~0); 153 154 memcpy(sc->sc_enaddr, lladdr, ETHER_ADDR_LEN); 155 printf(": address %s\n", ether_sprintf(lladdr)); 156 157 memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ); 158 ifp->if_softc = sc; 159 ifp->if_ioctl = mcioctl; 160 ifp->if_start = mcstart; 161 ifp->if_flags = 162 IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST; 163 ifp->if_watchdog = mcwatchdog; 164 165 if_attach(ifp); 166 ether_ifattach(ifp, lladdr); 167 168 return (0); 169 } 170 171 hide int 172 mcioctl(struct ifnet *ifp, u_long cmd, void *data) 173 { 174 struct mc_softc *sc = ifp->if_softc; 175 struct ifaddr *ifa; 176 177 int s = splnet(), err = 0; 178 179 switch (cmd) { 180 181 case SIOCINITIFADDR: 182 ifa = (struct ifaddr *)data; 183 ifp->if_flags |= IFF_UP; 184 mcinit(sc); 185 switch (ifa->ifa_addr->sa_family) { 186 #ifdef INET 187 case AF_INET: 188 arp_ifinit(ifp, ifa); 189 break; 190 #endif 191 default: 192 break; 193 } 194 break; 195 196 case SIOCSIFFLAGS: 197 if ((err = ifioctl_common(ifp, cmd, data)) != 0) 198 break; 199 /* XXX see the comment in ed_ioctl() about code re-use */ 200 if ((ifp->if_flags & IFF_UP) == 0 && 201 (ifp->if_flags & IFF_RUNNING) != 0) { 202 /* 203 * If interface is marked down and it is running, 204 * then stop it. 205 */ 206 mcstop(sc); 207 ifp->if_flags &= ~IFF_RUNNING; 208 } else if ((ifp->if_flags & IFF_UP) != 0 && 209 (ifp->if_flags & IFF_RUNNING) == 0) { 210 /* 211 * If interface is marked up and it is stopped, 212 * then start it. 213 */ 214 (void)mcinit(sc); 215 } else { 216 /* 217 * reset the interface to pick up any other changes 218 * in flags 219 */ 220 mcreset(sc); 221 mcstart(ifp); 222 } 223 break; 224 225 case SIOCADDMULTI: 226 case SIOCDELMULTI: 227 if ((err = ether_ioctl(ifp, cmd, data)) == ENETRESET) { 228 /* 229 * Multicast list has changed; set the hardware 230 * filter accordingly. But remember UP flag! 231 */ 232 if (ifp->if_flags & IFF_RUNNING) 233 mcreset(sc); 234 err = 0; 235 } 236 break; 237 default: 238 err = ether_ioctl(ifp, cmd, data); 239 } 240 splx(s); 241 return (err); 242 } 243 244 /* 245 * Encapsulate a packet of type family for the local net. 246 */ 247 hide void 248 mcstart(struct ifnet *ifp) 249 { 250 struct mc_softc *sc = ifp->if_softc; 251 struct mbuf *m; 252 253 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING) 254 return; 255 256 while (1) { 257 if (ifp->if_flags & IFF_OACTIVE) 258 return; 259 260 IF_DEQUEUE(&ifp->if_snd, m); 261 if (m == 0) 262 return; 263 264 #if NBPFILTER > 0 265 /* 266 * If bpf is listening on this interface, let it 267 * see the packet before we commit it to the wire. 268 */ 269 if (ifp->if_bpf) 270 bpf_mtap(ifp->if_bpf, m); 271 #endif 272 273 /* 274 * Copy the mbuf chain into the transmit buffer. 275 */ 276 ifp->if_flags |= IFF_OACTIVE; 277 maceput(sc, m); 278 279 ifp->if_opackets++; /* # of pkts */ 280 } 281 } 282 283 /* 284 * reset and restart the MACE. Called in case of fatal 285 * hardware/software errors. 286 */ 287 hide void 288 mcreset(struct mc_softc *sc) 289 { 290 mcstop(sc); 291 mcinit(sc); 292 } 293 294 hide int 295 mcinit(struct mc_softc *sc) 296 { 297 int s; 298 u_int8_t maccc, ladrf[8]; 299 300 if (sc->sc_if.if_flags & IFF_RUNNING) 301 /* already running */ 302 return (0); 303 304 s = splnet(); 305 306 NIC_PUT(sc, MACE_BIUCC, sc->sc_biucc); 307 NIC_PUT(sc, MACE_FIFOCC, sc->sc_fifocc); 308 NIC_PUT(sc, MACE_IMR, ~0); /* disable all interrupts */ 309 NIC_PUT(sc, MACE_PLSCC, sc->sc_plscc); 310 311 NIC_PUT(sc, MACE_UTR, RTRD); /* disable reserved test registers */ 312 313 /* set MAC address */ 314 NIC_PUT(sc, MACE_IAC, ADDRCHG); 315 while (NIC_GET(sc, MACE_IAC) & ADDRCHG) 316 ; 317 NIC_PUT(sc, MACE_IAC, PHYADDR); 318 bus_space_write_multi_1(sc->sc_regt, sc->sc_regh, MACE_REG(MACE_PADR), 319 sc->sc_enaddr, ETHER_ADDR_LEN); 320 321 /* set logical address filter */ 322 mace_calcladrf(&sc->sc_ethercom, ladrf); 323 324 NIC_PUT(sc, MACE_IAC, ADDRCHG); 325 while (NIC_GET(sc, MACE_IAC) & ADDRCHG) 326 ; 327 NIC_PUT(sc, MACE_IAC, LOGADDR); 328 bus_space_write_multi_1(sc->sc_regt, sc->sc_regh, MACE_REG(MACE_LADRF), 329 ladrf, 8); 330 331 NIC_PUT(sc, MACE_XMTFC, APADXMT); 332 /* 333 * No need to autostrip padding on receive... Ethernet frames 334 * don't have a length field, unlike 802.3 frames, so the MACE 335 * can't figure out the length of the packet anyways. 336 */ 337 NIC_PUT(sc, MACE_RCVFC, 0); 338 339 maccc = ENXMT | ENRCV; 340 if (sc->sc_if.if_flags & IFF_PROMISC) 341 maccc |= PROM; 342 343 NIC_PUT(sc, MACE_MACCC, maccc); 344 345 if (sc->sc_bus_init) 346 (*sc->sc_bus_init)(sc); 347 348 /* 349 * Enable all interrupts except receive, since we use the DMA 350 * completion interrupt for that. 351 */ 352 NIC_PUT(sc, MACE_IMR, RCVINTM); 353 354 /* flag interface as "running" */ 355 sc->sc_if.if_flags |= IFF_RUNNING; 356 sc->sc_if.if_flags &= ~IFF_OACTIVE; 357 358 splx(s); 359 return (0); 360 } 361 362 /* 363 * close down an interface and free its buffers 364 * Called on final close of device, or if mcinit() fails 365 * part way through. 366 */ 367 hide int 368 mcstop(struct mc_softc *sc) 369 { 370 int s; 371 372 s = splnet(); 373 374 NIC_PUT(sc, MACE_BIUCC, SWRST); 375 DELAY(100); 376 377 sc->sc_if.if_timer = 0; 378 sc->sc_if.if_flags &= ~IFF_RUNNING; 379 380 splx(s); 381 return (0); 382 } 383 384 /* 385 * Called if any Tx packets remain unsent after 5 seconds, 386 * In all cases we just reset the chip, and any retransmission 387 * will be handled by higher level protocol timeouts. 388 */ 389 hide void 390 mcwatchdog(struct ifnet *ifp) 391 { 392 struct mc_softc *sc = ifp->if_softc; 393 394 printf("mcwatchdog: resetting chip\n"); 395 mcreset(sc); 396 } 397 398 /* 399 * stuff packet into MACE (at splnet) 400 */ 401 integrate u_int 402 maceput(struct mc_softc *sc, struct mbuf *m) 403 { 404 struct mbuf *n; 405 u_int len, totlen = 0; 406 u_char *buff; 407 408 buff = (u_char*)sc->sc_txbuf + (sc->sc_txset == 0 ? 0 : 0x800); 409 410 for (; m; m = n) { 411 u_char *data = mtod(m, u_char *); 412 len = m->m_len; 413 totlen += len; 414 memcpy(buff, data, len); 415 buff += len; 416 MFREE(m, n); 417 } 418 419 if (totlen > PAGE_SIZE) 420 panic("%s: maceput: packet overflow", sc->sc_dev.dv_xname); 421 422 #if 0 423 if (totlen < ETHERMIN + sizeof(struct ether_header)) { 424 int pad = ETHERMIN + sizeof(struct ether_header) - totlen; 425 memset(sc->sc_txbuf + totlen, 0, pad); 426 totlen = ETHERMIN + sizeof(struct ether_header); 427 } 428 #endif 429 430 (*sc->sc_putpacket)(sc, totlen); 431 432 sc->sc_if.if_timer = 5; /* 5 seconds to watch for failing to transmit */ 433 return (totlen); 434 } 435 436 void 437 mcintr(void *arg) 438 { 439 struct mc_softc *sc = arg; 440 u_int8_t ir; 441 442 ir = NIC_GET(sc, MACE_IR) & ~NIC_GET(sc, MACE_IMR); 443 if (ir & JAB) { 444 #ifdef MCDEBUG 445 printf("%s: jabber error\n", sc->sc_dev.dv_xname); 446 #endif 447 sc->sc_if.if_oerrors++; 448 } 449 450 if (ir & BABL) { 451 #ifdef MCDEBUG 452 printf("%s: babble\n", sc->sc_dev.dv_xname); 453 #endif 454 sc->sc_if.if_oerrors++; 455 } 456 457 if (ir & CERR) { 458 #ifdef MCDEBUG 459 printf("%s: collision error\n", sc->sc_dev.dv_xname); 460 #endif 461 sc->sc_if.if_collisions++; 462 } 463 464 /* 465 * Pretend we have carrier; if we don't this will be cleared 466 * shortly. 467 */ 468 sc->sc_havecarrier = 1; 469 470 if (ir & XMTINT) 471 mc_tint(sc); 472 473 if (ir & RCVINT) 474 mc_rint(sc); 475 } 476 477 integrate void 478 mc_tint(struct mc_softc *sc) 479 { 480 u_int8_t xmtrc, xmtfs; 481 482 xmtrc = NIC_GET(sc, MACE_XMTRC); 483 xmtfs = NIC_GET(sc, MACE_XMTFS); 484 485 if ((xmtfs & XMTSV) == 0) 486 return; 487 488 if (xmtfs & UFLO) { 489 printf("%s: underflow\n", sc->sc_dev.dv_xname); 490 mcreset(sc); 491 return; 492 } 493 494 if (xmtfs & LCOL) { 495 printf("%s: late collision\n", sc->sc_dev.dv_xname); 496 sc->sc_if.if_oerrors++; 497 sc->sc_if.if_collisions++; 498 } 499 500 if (xmtfs & MORE) 501 /* Real number is unknown. */ 502 sc->sc_if.if_collisions += 2; 503 else if (xmtfs & ONE) 504 sc->sc_if.if_collisions++; 505 else if (xmtfs & RTRY) { 506 printf("%s: excessive collisions\n", sc->sc_dev.dv_xname); 507 sc->sc_if.if_collisions += 16; 508 sc->sc_if.if_oerrors++; 509 } 510 511 if (xmtfs & LCAR) { 512 sc->sc_havecarrier = 0; 513 printf("%s: lost carrier\n", sc->sc_dev.dv_xname); 514 sc->sc_if.if_oerrors++; 515 } 516 517 sc->sc_if.if_flags &= ~IFF_OACTIVE; 518 sc->sc_if.if_timer = 0; 519 mcstart(&sc->sc_if); 520 } 521 522 void 523 mc_rint(struct mc_softc *sc) 524 { 525 #define rxf sc->sc_rxframe 526 u_int len; 527 528 len = (rxf.rx_rcvcnt | ((rxf.rx_rcvsts & 0xf) << 8)) - 4; 529 530 #ifdef MCDEBUG 531 if (rxf.rx_rcvsts & 0xf0) 532 printf("%s: rcvcnt %02x rcvsts %02x rntpc 0x%02x rcvcc 0x%02x\n", 533 sc->sc_dev.dv_xname, rxf.rx_rcvcnt, rxf.rx_rcvsts, 534 rxf.rx_rntpc, rxf.rx_rcvcc); 535 #endif 536 537 if (rxf.rx_rcvsts & OFLO) { 538 printf("%s: receive FIFO overflow\n", sc->sc_dev.dv_xname); 539 sc->sc_if.if_ierrors++; 540 return; 541 } 542 543 if (rxf.rx_rcvsts & CLSN) 544 sc->sc_if.if_collisions++; 545 546 if (rxf.rx_rcvsts & FRAM) { 547 #ifdef MCDEBUG 548 printf("%s: framing error\n", sc->sc_dev.dv_xname); 549 #endif 550 sc->sc_if.if_ierrors++; 551 return; 552 } 553 554 if (rxf.rx_rcvsts & FCS) { 555 #ifdef MCDEBUG 556 printf("%s: frame control checksum error\n", sc->sc_dev.dv_xname); 557 #endif 558 sc->sc_if.if_ierrors++; 559 return; 560 } 561 562 mace_read(sc, rxf.rx_frame, len); 563 #undef rxf 564 } 565 566 integrate void 567 mace_read(struct mc_softc *sc, void *pkt, int len) 568 { 569 struct ifnet *ifp = &sc->sc_if; 570 struct mbuf *m; 571 572 if (len <= sizeof(struct ether_header) || 573 len > ETHERMTU + sizeof(struct ether_header)) { 574 #ifdef MCDEBUG 575 printf("%s: invalid packet size %d; dropping\n", 576 sc->sc_dev.dv_xname, len); 577 #endif 578 ifp->if_ierrors++; 579 return; 580 } 581 582 m = mace_get(sc, pkt, len); 583 if (m == NULL) { 584 ifp->if_ierrors++; 585 return; 586 } 587 588 ifp->if_ipackets++; 589 590 #if NBPFILTER > 0 591 /* Pass the packet to any BPF listeners. */ 592 if (ifp->if_bpf) 593 bpf_mtap(ifp->if_bpf, m); 594 #endif 595 596 /* Pass the packet up. */ 597 (*ifp->if_input)(ifp, m); 598 } 599 600 /* 601 * Pull data off an interface. 602 * Len is length of data, with local net header stripped. 603 * We copy the data into mbufs. When full cluster sized units are present 604 * we copy into clusters. 605 */ 606 integrate struct mbuf * 607 mace_get(struct mc_softc *sc, void *pkt, int totlen) 608 { 609 struct mbuf *m; 610 struct mbuf *top, **mp; 611 int len; 612 613 MGETHDR(m, M_DONTWAIT, MT_DATA); 614 if (m == 0) 615 return (0); 616 m->m_pkthdr.rcvif = &sc->sc_if; 617 m->m_pkthdr.len = totlen; 618 len = MHLEN; 619 top = 0; 620 mp = ⊤ 621 622 while (totlen > 0) { 623 if (top) { 624 MGET(m, M_DONTWAIT, MT_DATA); 625 if (m == 0) { 626 m_freem(top); 627 return 0; 628 } 629 len = MLEN; 630 } 631 if (totlen >= MINCLSIZE) { 632 MCLGET(m, M_DONTWAIT); 633 if ((m->m_flags & M_EXT) == 0) { 634 m_free(m); 635 m_freem(top); 636 return 0; 637 } 638 len = MCLBYTES; 639 } 640 m->m_len = len = min(totlen, len); 641 memcpy(mtod(m, void *), pkt, len); 642 pkt = (char*)pkt + len; 643 totlen -= len; 644 *mp = m; 645 mp = &m->m_next; 646 } 647 648 return (top); 649 } 650 651 /* 652 * Go through the list of multicast addresses and calculate the logical 653 * address filter. 654 */ 655 void 656 mace_calcladrf(struct ethercom *ac, u_int8_t *af) 657 { 658 struct ifnet *ifp = &ac->ec_if; 659 struct ether_multi *enm; 660 u_char *cp; 661 u_int32_t crc; 662 static const u_int32_t crctab[] = { 663 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 664 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 665 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 666 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c 667 }; 668 int len; 669 struct ether_multistep step; 670 671 /* 672 * Set up multicast address filter by passing all multicast addresses 673 * through a crc generator, and then using the high order 6 bits as an 674 * index into the 64 bit logical address filter. The high order bit 675 * selects the word, while the rest of the bits select the bit within 676 * the word. 677 */ 678 679 *((u_int32_t *)af) = *((u_int32_t *)af + 1) = 0; 680 ETHER_FIRST_MULTI(step, ac, enm); 681 while (enm != NULL) { 682 if (ETHER_CMP(enm->enm_addrlo, enm->enm_addrhi)) { 683 /* 684 * We must listen to a range of multicast addresses. 685 * For now, just accept all multicasts, rather than 686 * trying to set only those filter bits needed to match 687 * the range. (At this time, the only use of address 688 * ranges is for IP multicast routing, for which the 689 * range is big enough to require all bits set.) 690 */ 691 goto allmulti; 692 } 693 694 cp = enm->enm_addrlo; 695 crc = 0xffffffff; 696 for (len = sizeof(enm->enm_addrlo); --len >= 0;) { 697 crc ^= *cp++; 698 crc = (crc >> 4) ^ crctab[crc & 0xf]; 699 crc = (crc >> 4) ^ crctab[crc & 0xf]; 700 } 701 /* Just want the 6 most significant bits. */ 702 crc >>= 26; 703 704 /* Set the corresponding bit in the filter. */ 705 af[crc >> 3] |= 1 << (crc & 7); 706 707 ETHER_NEXT_MULTI(step, enm); 708 } 709 ifp->if_flags &= ~IFF_ALLMULTI; 710 return; 711 712 allmulti: 713 ifp->if_flags |= IFF_ALLMULTI; 714 *((u_int32_t *)af) = *((u_int32_t *)af + 1) = 0xffffffff; 715 } 716 717 static u_char bbr4[] = {0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15}; 718 #define bbr(v) ((bbr4[(v)&0xf] << 4) | bbr4[((v)>>4) & 0xf]) 719 720 u_char 721 mc_get_enaddr(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, 722 u_char *dst) 723 { 724 int i; 725 u_char b, csum; 726 727 /* 728 * The XOR of the 8 bytes of the ROM must be 0xff for it to be 729 * valid 730 */ 731 for (i = 0, csum = 0; i < 8; i++) { 732 b = bus_space_read_1(t, h, o+16*i); 733 if (i < ETHER_ADDR_LEN) 734 dst[i] = bbr(b); 735 csum ^= b; 736 } 737 738 return csum; 739 } 740