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