sys/dev/netif/aue/if_aue.c

   1 /*-
   2  * Copyright (c) 1997, 1998, 1999, 2000
   3  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  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
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/dev/usb/if_aue.c,v 1.78 2003/12/17 14:23:07 sanpei Exp $
  33  * $DragonFly: src/sys/dev/netif/aue/if_aue.c,v 1.7 2004/02/11 15:05:03 joerg Exp $
  34  *
  35  * $FreeBSD: src/sys/dev/usb/if_aue.c,v 1.19.2.18 2003/06/14 15:56:48 trhodes Exp $
  36  */
  37
  38 /*
  39  * ADMtek AN986 Pegasus and AN8511 Pegasus II USB to ethernet driver.
  40  * Datasheet is available from http://www.admtek.com.tw.
  41  *
  42  * Written by Bill Paul <wpaul@ee.columbia.edu>
  43  * Electrical Engineering Department
  44  * Columbia University, New York City
  45  */
  46
  47 /*
  48  * The Pegasus chip uses four USB "endpoints" to provide 10/100 ethernet
  49  * support: the control endpoint for reading/writing registers, burst
  50  * read endpoint for packet reception, burst write for packet transmission
  51  * and one for "interrupts." The chip uses the same RX filter scheme
  52  * as the other ADMtek ethernet parts: one perfect filter entry for the
  53  * the station address and a 64-bit multicast hash table. The chip supports
  54  * both MII and HomePNA attachments.
  55  *
  56  * Since the maximum data transfer speed of USB is supposed to be 12Mbps,
  57  * you're never really going to get 100Mbps speeds from this device. I
  58  * think the idea is to allow the device to connect to 10 or 100Mbps
  59  * networks, not necessarily to provide 100Mbps performance. Also, since
  60  * the controller uses an external PHY chip, it's possible that board
  61  * designers might simply choose a 10Mbps PHY.
  62  *
  63  * Registers are accessed using usbd_do_request(). Packet transfers are
  64  * done using usbd_transfer() and friends.
  65  */
  66
  67 #include <sys/param.h>
  68 #include <sys/systm.h>
  69 #include <sys/sockio.h>
  70 #include <sys/mbuf.h>
  71 #include <sys/malloc.h>
  72 #include <sys/kernel.h>
  73 #include <sys/socket.h>
  74
  75 #include <net/if.h>
  76 #include <net/if_arp.h>
  77 #include <net/ethernet.h>
  78 #include <net/if_dl.h>
  79 #include <net/if_media.h>
  80
  81 #include <net/bpf.h>
  82
  83 #include <sys/bus.h>
  84 #include <machine/bus.h>
  85 #if defined(DragonFly) || __FreeBSD_version < 500000
  86 #include <machine/clock.h>
  87 #endif
  88
  89 #include <bus/usb/usb.h>
  90 #include <bus/usb/usbdi.h>
  91 #include <bus/usb/usbdi_util.h>
  92 #include <bus/usb/usbdivar.h>
  93 #include <bus/usb/usbdevs.h>
  94 #include <bus/usb/usb_ethersubr.h>
  95
  96 #include "../mii_layer/mii.h"
  97 #include "../mii_layer/miivar.h"
  98
  99 #include "if_auereg.h"
 100
 101 MODULE_DEPEND(aue, usb, 1, 1, 1);
 102 MODULE_DEPEND(aue, ether, 1, 1, 1);
 103 MODULE_DEPEND(aue, miibus, 1, 1, 1);
 104
 105 /* "controller miibus0" required.  See GENERIC if you get errors here. */
 106 #include "miibus_if.h"
 107
 108 struct aue_type {
 109         struct usb_devno        aue_dev;
 110         u_int16_t               aue_flags;
 111 #define LSYS  0x0001          /* use Linksys reset */
 112 #define PNA   0x0002          /* has Home PNA */
 113 #define PII   0x0004          /* Pegasus II chip */
 114 };
 115
 116 Static const struct aue_type aue_devs[] = {
 117  {{ USB_VENDOR_3COM,            USB_PRODUCT_3COM_3C460B},         PII },
 118  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX1},          PNA|PII },
 119  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX2},          PII },
 120  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_UFE1000},      LSYS },
 121  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX4},          PNA },
 122  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX5},          PNA },
 123  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX6},          PII },
 124  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX7},          PII },
 125  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX8},          PII },
 126  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX9},          PNA },
 127  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_XX10},         0 },
 128  {{ USB_VENDOR_ABOCOM,          USB_PRODUCT_ABOCOM_DSB650TX_PNA}, 0 },
 129  {{ USB_VENDOR_ACCTON,          USB_PRODUCT_ACCTON_USB320_EC},    0 },
 130  {{ USB_VENDOR_ACCTON,          USB_PRODUCT_ACCTON_SS1001},       PII },
 131  {{ USB_VENDOR_ADMTEK,          USB_PRODUCT_ADMTEK_PEGASUS},      PNA },
 132  {{ USB_VENDOR_ADMTEK,          USB_PRODUCT_ADMTEK_PEGASUSII},    PII },
 133  {{ USB_VENDOR_BELKIN,          USB_PRODUCT_BELKIN_USB2LAN},      PII },
 134  {{ USB_VENDOR_BILLIONTON,      USB_PRODUCT_BILLIONTON_USB100},   0 },
 135  {{ USB_VENDOR_BILLIONTON,      USB_PRODUCT_BILLIONTON_USBLP100}, PNA },
 136  {{ USB_VENDOR_BILLIONTON,      USB_PRODUCT_BILLIONTON_USBEL100}, 0 },
 137  {{ USB_VENDOR_BILLIONTON,      USB_PRODUCT_BILLIONTON_USBE100},  PII },
 138  {{ USB_VENDOR_COREGA,          USB_PRODUCT_COREGA_FETHER_USB_TX}, 0 },
 139  {{ USB_VENDOR_COREGA,          USB_PRODUCT_COREGA_FETHER_USB_TXS},PII },
 140  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX4},     LSYS|PII },
 141  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX1},     LSYS },
 142  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX},      LSYS },
 143  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX_PNA},  PNA },
 144  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX3},     LSYS|PII },
 145  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650TX2},     LSYS|PII },
 146  {{ USB_VENDOR_DLINK,           USB_PRODUCT_DLINK_DSB650},        LSYS },
 147  {{ USB_VENDOR_ELECOM,          USB_PRODUCT_ELECOM_LDUSBTX0},     0 },
 148  {{ USB_VENDOR_ELECOM,          USB_PRODUCT_ELECOM_LDUSBTX1},     LSYS },
 149  {{ USB_VENDOR_ELECOM,          USB_PRODUCT_ELECOM_LDUSBTX2},     0 },
 150  {{ USB_VENDOR_ELECOM,          USB_PRODUCT_ELECOM_LDUSBTX3},     LSYS },
 151  {{ USB_VENDOR_ELECOM,          USB_PRODUCT_ELECOM_LDUSBLTX},     PII },
 152  {{ USB_VENDOR_ELSA,            USB_PRODUCT_ELSA_USB2ETHERNET},   0 },
 153  {{ USB_VENDOR_HAWKING,         USB_PRODUCT_HAWKING_UF100},       PII },
 154  {{ USB_VENDOR_HP,              USB_PRODUCT_HP_HN210E},           PII },
 155  {{ USB_VENDOR_IODATA,          USB_PRODUCT_IODATA_USBETTX},      0 },
 156  {{ USB_VENDOR_IODATA,          USB_PRODUCT_IODATA_USBETTXS},     PII },
 157  {{ USB_VENDOR_KINGSTON,        USB_PRODUCT_KINGSTON_KNU101TX},   0 },
 158  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB10TX1},    LSYS|PII },
 159  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB10T},      LSYS },
 160  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB100TX},    LSYS },
 161  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB100H1},    LSYS|PNA },
 162  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB10TA},     LSYS },
 163  {{ USB_VENDOR_LINKSYS,         USB_PRODUCT_LINKSYS_USB10TX2},    LSYS|PII },
 164  {{ USB_VENDOR_MICROSOFT,       USB_PRODUCT_MICROSOFT_MN110},     PII },
 165  {{ USB_VENDOR_MELCO,           USB_PRODUCT_MELCO_LUATX1},        0 },
 166  {{ USB_VENDOR_MELCO,           USB_PRODUCT_MELCO_LUATX5},        0 },
 167  {{ USB_VENDOR_MELCO,           USB_PRODUCT_MELCO_LUA2TX5},       PII },
 168  {{ USB_VENDOR_SIEMENS,         USB_PRODUCT_SIEMENS_SPEEDSTREAM}, PII },
 169  {{ USB_VENDOR_SMARTBRIDGES,    USB_PRODUCT_SMARTBRIDGES_SMARTNIC},PII },
 170  {{ USB_VENDOR_SMC,             USB_PRODUCT_SMC_2202USB},         0 },
 171  {{ USB_VENDOR_SMC,             USB_PRODUCT_SMC_2206USB},         PII },
 172  {{ USB_VENDOR_SOHOWARE,        USB_PRODUCT_SOHOWARE_NUB100},     0 },
 173 };
 174 #define aue_lookup(v, p) ((const struct aue_type *)usb_lookup(aue_devs, v, p))
 175
 176 Static struct usb_qdat aue_qdat;
 177
 178 Static int aue_match(device_ptr_t);
 179 Static int aue_attach(device_ptr_t);
 180 Static int aue_detach(device_ptr_t);
 181
 182 Static void aue_reset_pegasus_II(struct aue_softc *sc);
 183 Static int aue_tx_list_init(struct aue_softc *);
 184 Static int aue_rx_list_init(struct aue_softc *);
 185 Static int aue_newbuf(struct aue_softc *, struct aue_chain *, struct mbuf *);
 186 Static int aue_encap(struct aue_softc *, struct mbuf *, int);
 187 #ifdef AUE_INTR_PIPE
 188 Static void aue_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
 189 #endif
 190 Static void aue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 191 Static void aue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 192 Static void aue_tick(void *);
 193 Static void aue_rxstart(struct ifnet *);
 194 Static void aue_start(struct ifnet *);
 195 Static int aue_ioctl(struct ifnet *, u_long, caddr_t);
 196 Static void aue_init(void *);
 197 Static void aue_stop(struct aue_softc *);
 198 Static void aue_watchdog(struct ifnet *);
 199 Static void aue_shutdown(device_ptr_t);
 200 Static int aue_ifmedia_upd(struct ifnet *);
 201 Static void aue_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 202
 203 Static void aue_eeprom_getword(struct aue_softc *, int, u_int16_t *);
 204 Static void aue_read_eeprom(struct aue_softc *, caddr_t, int, int, int);
 205 Static int aue_miibus_readreg(device_ptr_t, int, int);
 206 Static int aue_miibus_writereg(device_ptr_t, int, int, int);
 207 Static void aue_miibus_statchg(device_ptr_t);
 208
 209 Static void aue_setmulti(struct aue_softc *);
 210 Static uint32_t aue_mchash(const uint8_t *);
 211 Static void aue_reset(struct aue_softc *);
 212
 213 Static int aue_csr_read_1(struct aue_softc *, int);
 214 Static int aue_csr_write_1(struct aue_softc *, int, int);
 215 Static int aue_csr_read_2(struct aue_softc *, int);
 216 Static int aue_csr_write_2(struct aue_softc *, int, int);
 217
 218 Static device_method_t aue_methods[] = {
 219         /* Device interface */
 220         DEVMETHOD(device_probe,         aue_match),
 221         DEVMETHOD(device_attach,        aue_attach),
 222         DEVMETHOD(device_detach,        aue_detach),
 223         DEVMETHOD(device_shutdown,      aue_shutdown),
 224
 225         /* bus interface */
 226         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 227         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 228
 229         /* MII interface */
 230         DEVMETHOD(miibus_readreg,       aue_miibus_readreg),
 231         DEVMETHOD(miibus_writereg,      aue_miibus_writereg),
 232         DEVMETHOD(miibus_statchg,       aue_miibus_statchg),
 233
 234         { 0, 0 }
 235 };
 236
 237 Static driver_t aue_driver = {
 238         "aue",
 239         aue_methods,
 240         sizeof(struct aue_softc)
 241 };
 242
 243 Static devclass_t aue_devclass;
 244
 245 DECLARE_DUMMY_MODULE(if_aue);
 246 DRIVER_MODULE(aue, uhub, aue_driver, aue_devclass, usbd_driver_load, 0);
 247 DRIVER_MODULE(miibus, aue, miibus_driver, miibus_devclass, 0, 0);
 248
 249 #define AUE_SETBIT(sc, reg, x)                          \
 250         aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) | (x))
 251
 252 #define AUE_CLRBIT(sc, reg, x)                          \
 253         aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) & ~(x))
 254
 255 Static int
 256 aue_csr_read_1(struct aue_softc *sc, int reg)
 257 {
 258         usb_device_request_t    req;
 259         usbd_status             err;
 260         u_int8_t                val = 0;
 261
 262         if (sc->aue_dying)
 263                 return(0);
 264
 265         AUE_LOCK(sc);
 266
 267         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 268         req.bRequest = AUE_UR_READREG;
 269         USETW(req.wValue, 0);
 270         USETW(req.wIndex, reg);
 271         USETW(req.wLength, 1);
 272
 273         err = usbd_do_request(sc->aue_udev, &req, &val);
 274
 275         AUE_UNLOCK(sc);
 276
 277         if (err) {
 278                 return (0);
 279         }
 280
 281         return (val);
 282 }
 283
 284 Static int
 285 aue_csr_read_2(struct aue_softc *sc, int reg)
 286 {
 287         usb_device_request_t    req;
 288         usbd_status             err;
 289         u_int16_t               val = 0;
 290
 291         if (sc->aue_dying)
 292                 return (0);
 293
 294         AUE_LOCK(sc);
 295
 296         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 297         req.bRequest = AUE_UR_READREG;
 298         USETW(req.wValue, 0);
 299         USETW(req.wIndex, reg);
 300         USETW(req.wLength, 2);
 301
 302         err = usbd_do_request(sc->aue_udev, &req, &val);
 303
 304         AUE_UNLOCK(sc);
 305
 306         if (err) {
 307                 return (0);
 308         }
 309
 310         return (val);
 311 }
 312
 313 Static int
 314 aue_csr_write_1(struct aue_softc *sc, int reg, int val)
 315 {
 316         usb_device_request_t    req;
 317         usbd_status             err;
 318
 319         if (sc->aue_dying)
 320                 return (0);
 321
 322         AUE_LOCK(sc);
 323
 324         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 325         req.bRequest = AUE_UR_WRITEREG;
 326         USETW(req.wValue, val);
 327         USETW(req.wIndex, reg);
 328         USETW(req.wLength, 1);
 329
 330         err = usbd_do_request(sc->aue_udev, &req, &val);
 331
 332         AUE_UNLOCK(sc);
 333
 334         if (err) {
 335                 return (-1);
 336         }
 337
 338         return (0);
 339 }
 340
 341 Static int
 342 aue_csr_write_2(struct aue_softc *sc, int reg, int val)
 343 {
 344         usb_device_request_t    req;
 345         usbd_status             err;
 346
 347         if (sc->aue_dying)
 348                 return (0);
 349
 350         AUE_LOCK(sc);
 351
 352         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 353         req.bRequest = AUE_UR_WRITEREG;
 354         USETW(req.wValue, val);
 355         USETW(req.wIndex, reg);
 356         USETW(req.wLength, 2);
 357
 358         err = usbd_do_request(sc->aue_udev, &req, &val);
 359
 360         AUE_UNLOCK(sc);
 361
 362         if (err) {
 363                 return (-1);
 364         }
 365
 366         return (0);
 367 }
 368
 369 /*
 370  * Read a word of data stored in the EEPROM at address 'addr.'
 371  */
 372 Static void
 373 aue_eeprom_getword(struct aue_softc *sc, int addr, u_int16_t *dest)
 374 {
 375         int             i;
 376         u_int16_t       word = 0;
 377
 378         aue_csr_write_1(sc, AUE_EE_REG, addr);
 379         aue_csr_write_1(sc, AUE_EE_CTL, AUE_EECTL_READ);
 380
 381         for (i = 0; i < AUE_TIMEOUT; i++) {
 382                 if (aue_csr_read_1(sc, AUE_EE_CTL) & AUE_EECTL_DONE)
 383                         break;
 384         }
 385
 386         if (i == AUE_TIMEOUT) {
 387                 printf("aue%d: EEPROM read timed out\n",
 388                     sc->aue_unit);
 389         }
 390
 391         word = aue_csr_read_2(sc, AUE_EE_DATA);
 392         *dest = word;
 393
 394         return;
 395 }
 396
 397 /*
 398  * Read a sequence of words from the EEPROM.
 399  */
 400 Static void
 401 aue_read_eeprom(struct aue_softc *sc, caddr_t dest, int off, int cnt, int swap)
 402 {
 403         int                     i;
 404         u_int16_t               word = 0, *ptr;
 405
 406         for (i = 0; i < cnt; i++) {
 407                 aue_eeprom_getword(sc, off + i, &word);
 408                 ptr = (u_int16_t *)(dest + (i * 2));
 409                 if (swap)
 410                         *ptr = ntohs(word);
 411                 else
 412                         *ptr = word;
 413         }
 414
 415         return;
 416 }
 417
 418 Static int
 419 aue_miibus_readreg(device_ptr_t dev, int phy, int reg)
 420 {
 421         struct aue_softc        *sc = USBGETSOFTC(dev);
 422         int                     i;
 423         u_int16_t               val = 0;
 424
 425         /*
 426          * The Am79C901 HomePNA PHY actually contains
 427          * two transceivers: a 1Mbps HomePNA PHY and a
 428          * 10Mbps full/half duplex ethernet PHY with
 429          * NWAY autoneg. However in the ADMtek adapter,
 430          * only the 1Mbps PHY is actually connected to
 431          * anything, so we ignore the 10Mbps one. It
 432          * happens to be configured for MII address 3,
 433          * so we filter that out.
 434          */
 435         if (sc->aue_vendor == USB_VENDOR_ADMTEK &&
 436             sc->aue_product == USB_PRODUCT_ADMTEK_PEGASUS) {
 437                 if (phy == 3)
 438                         return (0);
 439 #ifdef notdef
 440                 if (phy != 1)
 441                         return (0);
 442 #endif
 443         }
 444
 445         aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
 446         aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_READ);
 447
 448         for (i = 0; i < AUE_TIMEOUT; i++) {
 449                 if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 450                         break;
 451         }
 452
 453         if (i == AUE_TIMEOUT) {
 454                 printf("aue%d: MII read timed out\n", sc->aue_unit);
 455         }
 456
 457         val = aue_csr_read_2(sc, AUE_PHY_DATA);
 458
 459         return (val);
 460 }
 461
 462 Static int
 463 aue_miibus_writereg(device_ptr_t dev, int phy, int reg, int data)
 464 {
 465         struct aue_softc        *sc = USBGETSOFTC(dev);
 466         int                     i;
 467
 468         if (phy == 3)
 469                 return (0);
 470
 471         aue_csr_write_2(sc, AUE_PHY_DATA, data);
 472         aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
 473         aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_WRITE);
 474
 475         for (i = 0; i < AUE_TIMEOUT; i++) {
 476                 if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
 477                         break;
 478         }
 479
 480         if (i == AUE_TIMEOUT) {
 481                 printf("aue%d: MII read timed out\n",
 482                     sc->aue_unit);
 483         }
 484
 485         return(0);
 486 }
 487
 488 Static void
 489 aue_miibus_statchg(device_ptr_t dev)
 490 {
 491         struct aue_softc        *sc = USBGETSOFTC(dev);
 492         struct mii_data         *mii = GET_MII(sc);
 493
 494         AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
 495         if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) {
 496                 AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
 497         } else {
 498                 AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
 499         }
 500
 501         if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
 502                 AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
 503         else
 504                 AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
 505
 506         AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
 507
 508         /*
 509          * Set the LED modes on the LinkSys adapter.
 510          * This turns on the 'dual link LED' bin in the auxmode
 511          * register of the Broadcom PHY.
 512          */
 513         if (sc->aue_flags & LSYS) {
 514                 u_int16_t auxmode;
 515                 auxmode = aue_miibus_readreg(dev, 0, 0x1b);
 516                 aue_miibus_writereg(dev, 0, 0x1b, auxmode | 0x04);
 517         }
 518
 519         return;
 520 }
 521
 522 #define AUE_POLY        0xEDB88320
 523 #define AUE_BITS        6
 524
 525 Static u_int32_t
 526 aue_mchash(const uint8_t *addr)
 527 {
 528         uint32_t crc;
 529         int idx, bit;
 530         uint8_t data;
 531
 532         /* Compute CRC for the address value. */
 533         crc = 0xFFFFFFFF; /* initial value */
 534
 535         for (idx = 0; idx < 6; idx++) {
 536                 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
 537                         crc = (crc >> 1) ^ (((crc ^ data) & 1) ? AUE_POLY : 0);
 538         }
 539
 540         return (crc & ((1 << AUE_BITS) - 1));
 541 }
 542
 543 Static void
 544 aue_setmulti(struct aue_softc *sc)
 545 {
 546         struct ifnet            *ifp;
 547         struct ifmultiaddr      *ifma;
 548         u_int32_t               h = 0, i;
 549
 550         ifp = &sc->arpcom.ac_if;
 551
 552         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
 553                 AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
 554                 return;
 555         }
 556
 557         AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
 558
 559         /* first, zot all the existing hash bits */
 560         for (i = 0; i < 8; i++)
 561                 aue_csr_write_1(sc, AUE_MAR0 + i, 0);
 562
 563         /* now program new ones */
 564 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 565         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 566 #else
 567         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
 568 #endif
 569         {
 570                 if (ifma->ifma_addr->sa_family != AF_LINK)
 571                         continue;
 572                 h = aue_mchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 573                 AUE_SETBIT(sc, AUE_MAR + (h >> 3), 1 << (h & 0x7));
 574         }
 575
 576         return;
 577 }
 578
 579 Static void
 580 aue_reset_pegasus_II(struct aue_softc *sc)
 581 {
 582         /* Magic constants taken from Linux driver. */
 583         aue_csr_write_1(sc, AUE_REG_1D, 0);
 584         aue_csr_write_1(sc, AUE_REG_7B, 2);
 585 #if 0
 586         if ((sc->aue_flags & HAS_HOME_PNA) && mii_mode)
 587                 aue_csr_write_1(sc, AUE_REG_81, 6);
 588         else
 589 #endif
 590                 aue_csr_write_1(sc, AUE_REG_81, 2);
 591 }
 592
 593 Static void
 594 aue_reset(struct aue_softc *sc)
 595 {
 596         int             i;
 597
 598         AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_RESETMAC);
 599
 600         for (i = 0; i < AUE_TIMEOUT; i++) {
 601                 if (!(aue_csr_read_1(sc, AUE_CTL1) & AUE_CTL1_RESETMAC))
 602                         break;
 603         }
 604
 605         if (i == AUE_TIMEOUT)
 606                 printf("aue%d: reset failed\n", sc->aue_unit);
 607
 608         /*
 609          * The PHY(s) attached to the Pegasus chip may be held
 610          * in reset until we flip on the GPIO outputs. Make sure
 611          * to set the GPIO pins high so that the PHY(s) will
 612          * be enabled.
 613          *
 614          * Note: We force all of the GPIO pins low first, *then*
 615          * enable the ones we want.
 616          */
 617         aue_csr_write_1(sc, AUE_GPIO0, AUE_GPIO_OUT0|AUE_GPIO_SEL0);
 618         aue_csr_write_1(sc, AUE_GPIO0, AUE_GPIO_OUT0|AUE_GPIO_SEL0|AUE_GPIO_SEL1);
 619
 620         if (sc->aue_flags & LSYS) {
 621                 /* Grrr. LinkSys has to be different from everyone else. */
 622                 aue_csr_write_1(sc, AUE_GPIO0,
 623                     AUE_GPIO_SEL0 | AUE_GPIO_SEL1);
 624                 aue_csr_write_1(sc, AUE_GPIO0,
 625                     AUE_GPIO_SEL0 | AUE_GPIO_SEL1 | AUE_GPIO_OUT0);
 626         }
 627
 628         if (sc->aue_flags & PII)
 629                 aue_reset_pegasus_II(sc);
 630
 631         /* Wait a little while for the chip to get its brains in order. */
 632         DELAY(10000);
 633
 634         return;
 635 }
 636
 637 /*
 638  * Probe for a Pegasus chip.
 639  */
 640 USB_MATCH(aue)
 641 {
 642         USB_MATCH_START(aue, uaa);
 643
 644         if (uaa->iface != NULL)
 645                 return (UMATCH_NONE);
 646
 647         return (aue_lookup(uaa->vendor, uaa->product) != NULL ?
 648                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
 649 }
 650
 651 /*
 652  * Attach the interface. Allocate softc structures, do ifmedia
 653  * setup and ethernet/BPF attach.
 654  */
 655 USB_ATTACH(aue)
 656 {
 657         USB_ATTACH_START(aue, sc, uaa);
 658         char                    devinfo[1024];
 659         u_char                  eaddr[ETHER_ADDR_LEN];
 660         struct ifnet            *ifp;
 661         usbd_interface_handle   iface;
 662         usbd_status             err;
 663         usb_interface_descriptor_t      *id;
 664         usb_endpoint_descriptor_t       *ed;
 665         int                     i;
 666
 667         bzero(sc, sizeof(struct aue_softc));
 668
 669         usbd_devinfo(uaa->device, 0, devinfo);
 670
 671         sc->aue_udev = uaa->device;
 672         sc->aue_unit = device_get_unit(self);
 673
 674         if (usbd_set_config_no(sc->aue_udev, AUE_CONFIG_NO, 0)) {
 675                 printf("aue%d: getting interface handle failed\n",
 676                     sc->aue_unit);
 677                 USB_ATTACH_ERROR_RETURN;
 678         }
 679
 680         err = usbd_device2interface_handle(uaa->device, AUE_IFACE_IDX, &iface);
 681         if (err) {
 682                 printf("aue%d: getting interface handle failed\n",
 683                     sc->aue_unit);
 684                 USB_ATTACH_ERROR_RETURN;
 685         }
 686
 687         sc->aue_iface = iface;
 688         sc->aue_flags = aue_lookup(uaa->vendor, uaa->product)->aue_flags;
 689
 690         sc->aue_product = uaa->product;
 691         sc->aue_vendor = uaa->vendor;
 692
 693         id = usbd_get_interface_descriptor(sc->aue_iface);
 694
 695         usbd_devinfo(uaa->device, 0, devinfo);
 696         device_set_desc_copy(self, devinfo);
 697         printf("%s: %s\n", USBDEVNAME(self), devinfo);
 698
 699         /* Find endpoints. */
 700         for (i = 0; i < id->bNumEndpoints; i++) {
 701                 ed = usbd_interface2endpoint_descriptor(iface, i);
 702                 if (ed == NULL) {
 703                         printf("aue%d: couldn't get ep %d\n",
 704                             sc->aue_unit, i);
 705                         USB_ATTACH_ERROR_RETURN;
 706                 }
 707                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 708                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 709                         sc->aue_ed[AUE_ENDPT_RX] = ed->bEndpointAddress;
 710                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 711                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 712                         sc->aue_ed[AUE_ENDPT_TX] = ed->bEndpointAddress;
 713                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 714                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 715                         sc->aue_ed[AUE_ENDPT_INTR] = ed->bEndpointAddress;
 716                 }
 717         }
 718
 719 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 720         mtx_init(&sc->aue_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK,
 721             MTX_DEF | MTX_RECURSE);
 722 #endif
 723         AUE_LOCK(sc);
 724
 725         /* Reset the adapter. */
 726         aue_reset(sc);
 727
 728         /*
 729          * Get station address from the EEPROM.
 730          */
 731         aue_read_eeprom(sc, (caddr_t)&eaddr, 0, 3, 0);
 732
 733         /*
 734          * A Pegasus chip was detected. Inform the world.
 735          */
 736         printf("aue%d: Ethernet address: %6D\n", sc->aue_unit, eaddr, ":");
 737
 738         bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
 739
 740         ifp = &sc->arpcom.ac_if;
 741         ifp->if_softc = sc;
 742         if_initname(ifp, "aue", sc->aue_unit);
 743         ifp->if_mtu = ETHERMTU;
 744         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 745         ifp->if_ioctl = aue_ioctl;
 746         ifp->if_output = ether_output;
 747         ifp->if_start = aue_start;
 748         ifp->if_watchdog = aue_watchdog;
 749         ifp->if_init = aue_init;
 750         ifp->if_baudrate = 10000000;
 751         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 752
 753         /*
 754          * Do MII setup.
 755          * NOTE: Doing this causes child devices to be attached to us,
 756          * which we would normally disconnect at in the detach routine
 757          * using device_delete_child(). However the USB code is set up
 758          * such that when this driver is removed, all children devices
 759          * are removed as well. In effect, the USB code ends up detaching
 760          * all of our children for us, so we don't have to do is ourselves
 761          * in aue_detach(). It's important to point this out since if
 762          * we *do* try to detach the child devices ourselves, we will
 763          * end up getting the children deleted twice, which will crash
 764          * the system.
 765          */
 766         if (mii_phy_probe(self, &sc->aue_miibus,
 767             aue_ifmedia_upd, aue_ifmedia_sts)) {
 768                 printf("aue%d: MII without any PHY!\n", sc->aue_unit);
 769                 AUE_UNLOCK(sc);
 770 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 771                 mtx_destroy(&sc->aue_mtx);
 772 #endif
 773                 USB_ATTACH_ERROR_RETURN;
 774         }
 775
 776         aue_qdat.ifp = ifp;
 777         aue_qdat.if_rxstart = aue_rxstart;
 778
 779         /*
 780          * Call MI attach routine.
 781          */
 782 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 783         ether_ifattach(ifp, eaddr);
 784 #else
 785         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
 786 #endif
 787         callout_handle_init(&sc->aue_stat_ch);
 788         usb_register_netisr();
 789         sc->aue_dying = 0;
 790
 791         AUE_UNLOCK(sc);
 792         USB_ATTACH_SUCCESS_RETURN;
 793 }
 794
 795 Static int
 796 aue_detach(device_ptr_t dev)
 797 {
 798         struct aue_softc        *sc;
 799         struct ifnet            *ifp;
 800
 801         sc = device_get_softc(dev);
 802         AUE_LOCK(sc);
 803         ifp = &sc->arpcom.ac_if;
 804
 805         sc->aue_dying = 1;
 806         untimeout(aue_tick, sc, sc->aue_stat_ch);
 807 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 808         ether_ifdetach(ifp);
 809 #else
 810         ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
 811 #endif
 812
 813         if (sc->aue_ep[AUE_ENDPT_TX] != NULL)
 814                 usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_TX]);
 815         if (sc->aue_ep[AUE_ENDPT_RX] != NULL)
 816                 usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_RX]);
 817 #ifdef AUE_INTR_PIPE
 818         if (sc->aue_ep[AUE_ENDPT_INTR] != NULL)
 819                 usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_INTR]);
 820 #endif
 821
 822         AUE_UNLOCK(sc);
 823 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 824         mtx_destroy(&sc->aue_mtx);
 825 #endif
 826
 827         return (0);
 828 }
 829
 830 /*
 831  * Initialize an RX descriptor and attach an MBUF cluster.
 832  */
 833 Static int
 834 aue_newbuf(struct aue_softc *sc, struct aue_chain *c, struct mbuf *m)
 835 {
 836         struct mbuf             *m_new = NULL;
 837
 838         if (m == NULL) {
 839                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
 840                 if (m_new == NULL) {
 841                         printf("aue%d: no memory for rx list "
 842                             "-- packet dropped!\n", sc->aue_unit);
 843                         return (ENOBUFS);
 844                 }
 845
 846                 MCLGET(m_new, M_DONTWAIT);
 847                 if (!(m_new->m_flags & M_EXT)) {
 848                         printf("aue%d: no memory for rx list "
 849                             "-- packet dropped!\n", sc->aue_unit);
 850                         m_freem(m_new);
 851                         return (ENOBUFS);
 852                 }
 853                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 854         } else {
 855                 m_new = m;
 856                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
 857                 m_new->m_data = m_new->m_ext.ext_buf;
 858         }
 859
 860         m_adj(m_new, ETHER_ALIGN);
 861         c->aue_mbuf = m_new;
 862
 863         return (0);
 864 }
 865
 866 Static int
 867 aue_rx_list_init(struct aue_softc *sc)
 868 {
 869         struct aue_cdata        *cd;
 870         struct aue_chain        *c;
 871         int                     i;
 872
 873         cd = &sc->aue_cdata;
 874         for (i = 0; i < AUE_RX_LIST_CNT; i++) {
 875                 c = &cd->aue_rx_chain[i];
 876                 c->aue_sc = sc;
 877                 c->aue_idx = i;
 878                 if (aue_newbuf(sc, c, NULL) == ENOBUFS)
 879                         return (ENOBUFS);
 880                 if (c->aue_xfer == NULL) {
 881                         c->aue_xfer = usbd_alloc_xfer(sc->aue_udev);
 882                         if (c->aue_xfer == NULL)
 883                                 return (ENOBUFS);
 884                 }
 885         }
 886
 887         return (0);
 888 }
 889
 890 Static int
 891 aue_tx_list_init(struct aue_softc *sc)
 892 {
 893         struct aue_cdata        *cd;
 894         struct aue_chain        *c;
 895         int                     i;
 896
 897         cd = &sc->aue_cdata;
 898         for (i = 0; i < AUE_TX_LIST_CNT; i++) {
 899                 c = &cd->aue_tx_chain[i];
 900                 c->aue_sc = sc;
 901                 c->aue_idx = i;
 902                 c->aue_mbuf = NULL;
 903                 if (c->aue_xfer == NULL) {
 904                         c->aue_xfer = usbd_alloc_xfer(sc->aue_udev);
 905                         if (c->aue_xfer == NULL)
 906                                 return (ENOBUFS);
 907                 }
 908                 c->aue_buf = malloc(AUE_BUFSZ, M_USBDEV, M_NOWAIT);
 909                 if (c->aue_buf == NULL)
 910                         return (ENOBUFS);
 911         }
 912
 913         return (0);
 914 }
 915
 916 #ifdef AUE_INTR_PIPE
 917 Static void
 918 aue_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 919 {
 920         struct aue_softc        *sc = priv;
 921         struct ifnet            *ifp;
 922         struct aue_intrpkt      *p;
 923
 924         AUE_LOCK(sc);
 925         ifp = &sc->arpcom.ac_if;
 926
 927         if (!(ifp->if_flags & IFF_RUNNING)) {
 928                 AUE_UNLOCK(sc);
 929                 return;
 930         }
 931
 932         if (status != USBD_NORMAL_COMPLETION) {
 933                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
 934                         AUE_UNLOCK(sc);
 935                         return;
 936                 }
 937                 printf("aue%d: usb error on intr: %s\n", sc->aue_unit,
 938                     usbd_errstr(status));
 939                 if (status == USBD_STALLED)
 940                         usbd_clear_endpoint_stall(sc->aue_ep[AUE_ENDPT_RX]);
 941                 AUE_UNLOCK(sc);
 942                 return;
 943         }
 944
 945         usbd_get_xfer_status(xfer, NULL, (void **)&p, NULL, NULL);
 946
 947         if (p->aue_txstat0)
 948                 ifp->if_oerrors++;
 949
 950         if (p->aue_txstat0 & (AUE_TXSTAT0_LATECOLL & AUE_TXSTAT0_EXCESSCOLL))
 951                 ifp->if_collisions++;
 952
 953         AUE_UNLOCK(sc);
 954         return;
 955 }
 956 #endif
 957
 958 Static void
 959 aue_rxstart(struct ifnet *ifp)
 960 {
 961         struct aue_softc        *sc;
 962         struct aue_chain        *c;
 963
 964         sc = ifp->if_softc;
 965         AUE_LOCK(sc);
 966         c = &sc->aue_cdata.aue_rx_chain[sc->aue_cdata.aue_rx_prod];
 967
 968         if (aue_newbuf(sc, c, NULL) == ENOBUFS) {
 969                 ifp->if_ierrors++;
 970                 AUE_UNLOCK(sc);
 971                 return;
 972         }
 973
 974         /* Setup new transfer. */
 975         usbd_setup_xfer(c->aue_xfer, sc->aue_ep[AUE_ENDPT_RX],
 976             c, mtod(c->aue_mbuf, char *), AUE_BUFSZ, USBD_SHORT_XFER_OK,
 977             USBD_NO_TIMEOUT, aue_rxeof);
 978         usbd_transfer(c->aue_xfer);
 979
 980         AUE_UNLOCK(sc);
 981         return;
 982 }
 983
 984 /*
 985  * A frame has been uploaded: pass the resulting mbuf chain up to
 986  * the higher level protocols.
 987  */
 988 Static void
 989 aue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 990 {
 991         struct aue_chain        *c = priv;
 992         struct aue_softc        *sc = c->aue_sc;
 993         struct mbuf             *m;
 994         struct ifnet            *ifp;
 995         int                     total_len = 0;
 996         struct aue_rxpkt        r;
 997
 998         if (sc->aue_dying)
 999                 return;
1000         AUE_LOCK(sc);
1001         ifp = &sc->arpcom.ac_if;
1002
1003         if (!(ifp->if_flags & IFF_RUNNING)) {
1004                 AUE_UNLOCK(sc);
1005                 return;
1006         }
1007
1008         if (status != USBD_NORMAL_COMPLETION) {
1009                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1010                         AUE_UNLOCK(sc);
1011                         return;
1012                 }
1013                 if (usbd_ratecheck(&sc->aue_rx_notice))
1014                         printf("aue%d: usb error on rx: %s\n", sc->aue_unit,
1015                             usbd_errstr(status));
1016                 if (status == USBD_STALLED)
1017                         usbd_clear_endpoint_stall(sc->aue_ep[AUE_ENDPT_RX]);
1018                 goto done;
1019         }
1020
1021         usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
1022
1023         if (total_len <= 4 + ETHER_CRC_LEN) {
1024                 ifp->if_ierrors++;
1025                 goto done;
1026         }
1027
1028         m = c->aue_mbuf;
1029         bcopy(mtod(m, char *) + total_len - 4, (char *)&r, sizeof(r));
1030
1031         /* Turn off all the non-error bits in the rx status word. */
1032         r.aue_rxstat &= AUE_RXSTAT_MASK;
1033
1034         if (r.aue_rxstat) {
1035                 ifp->if_ierrors++;
1036                 goto done;
1037         }
1038
1039         /* No errors; receive the packet. */
1040         total_len -= (4 + ETHER_CRC_LEN);
1041
1042         ifp->if_ipackets++;
1043         m->m_pkthdr.rcvif = (struct ifnet *)&aue_qdat;
1044         m->m_pkthdr.len = m->m_len = total_len;
1045
1046         /* Put the packet on the special USB input queue. */
1047         usb_ether_input(m);
1048         AUE_UNLOCK(sc);
1049         return;
1050 done:
1051
1052         /* Setup new transfer. */
1053         usbd_setup_xfer(xfer, sc->aue_ep[AUE_ENDPT_RX],
1054             c, mtod(c->aue_mbuf, char *), AUE_BUFSZ, USBD_SHORT_XFER_OK,
1055             USBD_NO_TIMEOUT, aue_rxeof);
1056         usbd_transfer(xfer);
1057
1058         AUE_UNLOCK(sc);
1059         return;
1060 }
1061
1062 /*
1063  * A frame was downloaded to the chip. It's safe for us to clean up
1064  * the list buffers.
1065  */
1066
1067 Static void
1068 aue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
1069 {
1070         struct aue_chain        *c = priv;
1071         struct aue_softc        *sc = c->aue_sc;
1072         struct ifnet            *ifp;
1073         usbd_status             err;
1074
1075         AUE_LOCK(sc);
1076         ifp = &sc->arpcom.ac_if;
1077
1078         if (status != USBD_NORMAL_COMPLETION) {
1079                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1080                         AUE_UNLOCK(sc);
1081                         return;
1082                 }
1083                 printf("aue%d: usb error on tx: %s\n", sc->aue_unit,
1084                     usbd_errstr(status));
1085                 if (status == USBD_STALLED)
1086                         usbd_clear_endpoint_stall(sc->aue_ep[AUE_ENDPT_TX]);
1087                 AUE_UNLOCK(sc);
1088                 return;
1089         }
1090
1091         ifp->if_timer = 0;
1092         ifp->if_flags &= ~IFF_OACTIVE;
1093         usbd_get_xfer_status(c->aue_xfer, NULL, NULL, NULL, &err);
1094
1095         if (c->aue_mbuf != NULL) {
1096                 c->aue_mbuf->m_pkthdr.rcvif = ifp;
1097                 usb_tx_done(c->aue_mbuf);
1098                 c->aue_mbuf = NULL;
1099         }
1100
1101         if (err)
1102                 ifp->if_oerrors++;
1103         else
1104                 ifp->if_opackets++;
1105
1106         AUE_UNLOCK(sc);
1107
1108         return;
1109 }
1110
1111 Static void
1112 aue_tick(void *xsc)
1113 {
1114         struct aue_softc        *sc = xsc;
1115         struct ifnet            *ifp;
1116         struct mii_data         *mii;
1117
1118         if (sc == NULL)
1119                 return;
1120
1121         AUE_LOCK(sc);
1122
1123         ifp = &sc->arpcom.ac_if;
1124         mii = GET_MII(sc);
1125         if (mii == NULL) {
1126                 AUE_UNLOCK(sc);
1127                 return;
1128         }
1129
1130         mii_tick(mii);
1131         if (!sc->aue_link && mii->mii_media_status & IFM_ACTIVE &&
1132             IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1133                 sc->aue_link++;
1134                 if (ifp->if_snd.ifq_head != NULL)
1135                         aue_start(ifp);
1136         }
1137
1138         sc->aue_stat_ch = timeout(aue_tick, sc, hz);
1139
1140         AUE_UNLOCK(sc);
1141
1142         return;
1143 }
1144
1145 Static int
1146 aue_encap(struct aue_softc *sc, struct mbuf *m, int idx)
1147 {
1148         int                     total_len;
1149         struct aue_chain        *c;
1150         usbd_status             err;
1151
1152         c = &sc->aue_cdata.aue_tx_chain[idx];
1153
1154         /*
1155          * Copy the mbuf data into a contiguous buffer, leaving two
1156          * bytes at the beginning to hold the frame length.
1157          */
1158         m_copydata(m, 0, m->m_pkthdr.len, c->aue_buf + 2);
1159         c->aue_mbuf = m;
1160
1161         total_len = m->m_pkthdr.len + 2;
1162
1163         /*
1164          * The ADMtek documentation says that the packet length is
1165          * supposed to be specified in the first two bytes of the
1166          * transfer, however it actually seems to ignore this info
1167          * and base the frame size on the bulk transfer length.
1168          */
1169         c->aue_buf[0] = (u_int8_t)m->m_pkthdr.len;
1170         c->aue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
1171
1172         usbd_setup_xfer(c->aue_xfer, sc->aue_ep[AUE_ENDPT_TX],
1173             c, c->aue_buf, total_len, USBD_FORCE_SHORT_XFER,
1174             10000, aue_txeof);
1175
1176         /* Transmit */
1177         err = usbd_transfer(c->aue_xfer);
1178         if (err != USBD_IN_PROGRESS) {
1179                 aue_stop(sc);
1180                 return (EIO);
1181         }
1182
1183         sc->aue_cdata.aue_tx_cnt++;
1184
1185         return (0);
1186 }
1187
1188 Static void
1189 aue_start(struct ifnet *ifp)
1190 {
1191         struct aue_softc        *sc = ifp->if_softc;
1192         struct mbuf             *m_head = NULL;
1193
1194         AUE_LOCK(sc);
1195
1196         if (!sc->aue_link) {
1197                 AUE_UNLOCK(sc);
1198                 return;
1199         }
1200
1201         if (ifp->if_flags & IFF_OACTIVE) {
1202                 AUE_UNLOCK(sc);
1203                 return;
1204         }
1205
1206         IF_DEQUEUE(&ifp->if_snd, m_head);
1207         if (m_head == NULL) {
1208                 AUE_UNLOCK(sc);
1209                 return;
1210         }
1211
1212         if (aue_encap(sc, m_head, 0)) {
1213                 IF_PREPEND(&ifp->if_snd, m_head);
1214                 ifp->if_flags |= IFF_OACTIVE;
1215                 AUE_UNLOCK(sc);
1216                 return;
1217         }
1218
1219         /*
1220          * If there's a BPF listener, bounce a copy of this frame
1221          * to him.
1222          */
1223         BPF_MTAP(ifp, m_head);
1224
1225         ifp->if_flags |= IFF_OACTIVE;
1226
1227         /*
1228          * Set a timeout in case the chip goes out to lunch.
1229          */
1230         ifp->if_timer = 5;
1231         AUE_UNLOCK(sc);
1232
1233         return;
1234 }
1235
1236 Static void
1237 aue_init(void *xsc)
1238 {
1239         struct aue_softc        *sc = xsc;
1240         struct ifnet            *ifp = &sc->arpcom.ac_if;
1241         struct mii_data         *mii = GET_MII(sc);
1242         struct aue_chain        *c;
1243         usbd_status             err;
1244         int                     i;
1245
1246         AUE_LOCK(sc);
1247
1248         if (ifp->if_flags & IFF_RUNNING) {
1249                 AUE_UNLOCK(sc);
1250                 return;
1251         }
1252
1253         /*
1254          * Cancel pending I/O and free all RX/TX buffers.
1255          */
1256         aue_reset(sc);
1257
1258         /* Set MAC address */
1259         for (i = 0; i < ETHER_ADDR_LEN; i++)
1260                 aue_csr_write_1(sc, AUE_PAR0 + i, sc->arpcom.ac_enaddr[i]);
1261
1262          /* If we want promiscuous mode, set the allframes bit. */
1263         if (ifp->if_flags & IFF_PROMISC)
1264                 AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1265         else
1266                 AUE_CLRBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1267
1268         /* Init TX ring. */
1269         if (aue_tx_list_init(sc) == ENOBUFS) {
1270                 printf("aue%d: tx list init failed\n", sc->aue_unit);
1271                 AUE_UNLOCK(sc);
1272                 return;
1273         }
1274
1275         /* Init RX ring. */
1276         if (aue_rx_list_init(sc) == ENOBUFS) {
1277                 printf("aue%d: rx list init failed\n", sc->aue_unit);
1278                 AUE_UNLOCK(sc);
1279                 return;
1280         }
1281
1282 #ifdef AUE_INTR_PIPE
1283         sc->aue_cdata.aue_ibuf = malloc(AUE_INTR_PKTLEN, M_USBDEV, M_NOWAIT);
1284 #endif
1285
1286         /* Load the multicast filter. */
1287         aue_setmulti(sc);
1288
1289         /* Enable RX and TX */
1290         aue_csr_write_1(sc, AUE_CTL0, AUE_CTL0_RXSTAT_APPEND | AUE_CTL0_RX_ENB);
1291         AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_TX_ENB);
1292         AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_EP3_CLR);
1293
1294         mii_mediachg(mii);
1295
1296         /* Open RX and TX pipes. */
1297         err = usbd_open_pipe(sc->aue_iface, sc->aue_ed[AUE_ENDPT_RX],
1298             USBD_EXCLUSIVE_USE, &sc->aue_ep[AUE_ENDPT_RX]);
1299         if (err) {
1300                 printf("aue%d: open rx pipe failed: %s\n",
1301                     sc->aue_unit, usbd_errstr(err));
1302                 AUE_UNLOCK(sc);
1303                 return;
1304         }
1305         err = usbd_open_pipe(sc->aue_iface, sc->aue_ed[AUE_ENDPT_TX],
1306             USBD_EXCLUSIVE_USE, &sc->aue_ep[AUE_ENDPT_TX]);
1307         if (err) {
1308                 printf("aue%d: open tx pipe failed: %s\n",
1309                     sc->aue_unit, usbd_errstr(err));
1310                 AUE_UNLOCK(sc);
1311                 return;
1312         }
1313
1314 #ifdef AUE_INTR_PIPE
1315         err = usbd_open_pipe_intr(sc->aue_iface, sc->aue_ed[AUE_ENDPT_INTR],
1316             USBD_SHORT_XFER_OK, &sc->aue_ep[AUE_ENDPT_INTR], sc,
1317             sc->aue_cdata.aue_ibuf, AUE_INTR_PKTLEN, aue_intr,
1318             AUE_INTR_INTERVAL);
1319         if (err) {
1320                 printf("aue%d: open intr pipe failed: %s\n",
1321                     sc->aue_unit, usbd_errstr(err));
1322                 AUE_UNLOCK(sc);
1323                 return;
1324         }
1325 #endif
1326
1327         /* Start up the receive pipe. */
1328         for (i = 0; i < AUE_RX_LIST_CNT; i++) {
1329                 c = &sc->aue_cdata.aue_rx_chain[i];
1330                 usbd_setup_xfer(c->aue_xfer, sc->aue_ep[AUE_ENDPT_RX],
1331                     c, mtod(c->aue_mbuf, char *), AUE_BUFSZ,
1332                 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, aue_rxeof);
1333                 usbd_transfer(c->aue_xfer);
1334         }
1335
1336         ifp->if_flags |= IFF_RUNNING;
1337         ifp->if_flags &= ~IFF_OACTIVE;
1338
1339         sc->aue_stat_ch = timeout(aue_tick, sc, hz);
1340
1341         AUE_UNLOCK(sc);
1342
1343         return;
1344 }
1345
1346 /*
1347  * Set media options.
1348  */
1349 Static int
1350 aue_ifmedia_upd(struct ifnet *ifp)
1351 {
1352         struct aue_softc        *sc = ifp->if_softc;
1353         struct mii_data         *mii = GET_MII(sc);
1354
1355         sc->aue_link = 0;
1356         if (mii->mii_instance) {
1357                 struct mii_softc        *miisc;
1358                 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
1359                          mii_phy_reset(miisc);
1360         }
1361         mii_mediachg(mii);
1362
1363         return (0);
1364 }
1365
1366 /*
1367  * Report current media status.
1368  */
1369 Static void
1370 aue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1371 {
1372         struct aue_softc        *sc = ifp->if_softc;
1373         struct mii_data         *mii = GET_MII(sc);
1374
1375         mii_pollstat(mii);
1376         ifmr->ifm_active = mii->mii_media_active;
1377         ifmr->ifm_status = mii->mii_media_status;
1378
1379         return;
1380 }
1381
1382 Static int
1383 aue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1384 {
1385         struct aue_softc        *sc = ifp->if_softc;
1386         struct ifreq            *ifr = (struct ifreq *)data;
1387         struct mii_data         *mii;
1388         int                     error = 0;
1389
1390         AUE_LOCK(sc);
1391
1392         switch(command) {
1393         case SIOCSIFFLAGS:
1394                 if (ifp->if_flags & IFF_UP) {
1395                         if (ifp->if_flags & IFF_RUNNING &&
1396                             ifp->if_flags & IFF_PROMISC &&
1397                             !(sc->aue_if_flags & IFF_PROMISC)) {
1398                                 AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1399                         } else if (ifp->if_flags & IFF_RUNNING &&
1400                             !(ifp->if_flags & IFF_PROMISC) &&
1401                             sc->aue_if_flags & IFF_PROMISC) {
1402                                 AUE_CLRBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1403                         } else if (!(ifp->if_flags & IFF_RUNNING))
1404                                 aue_init(sc);
1405                 } else {
1406                         if (ifp->if_flags & IFF_RUNNING)
1407                                 aue_stop(sc);
1408                 }
1409                 sc->aue_if_flags = ifp->if_flags;
1410                 error = 0;
1411                 break;
1412         case SIOCADDMULTI:
1413         case SIOCDELMULTI:
1414                 aue_setmulti(sc);
1415                 error = 0;
1416                 break;
1417         case SIOCGIFMEDIA:
1418         case SIOCSIFMEDIA:
1419                 mii = GET_MII(sc);
1420                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
1421                 break;
1422         default:
1423                 error = ether_ioctl(ifp, command, data);
1424                 break;
1425         }
1426
1427         AUE_UNLOCK(sc);
1428
1429         return (error);
1430 }
1431
1432 Static void
1433 aue_watchdog(struct ifnet *ifp)
1434 {
1435         struct aue_softc        *sc = ifp->if_softc;
1436         struct aue_chain        *c;
1437         usbd_status             stat;
1438
1439         AUE_LOCK(sc);
1440
1441         ifp->if_oerrors++;
1442         printf("aue%d: watchdog timeout\n", sc->aue_unit);
1443
1444         c = &sc->aue_cdata.aue_tx_chain[0];
1445         usbd_get_xfer_status(c->aue_xfer, NULL, NULL, NULL, &stat);
1446         aue_txeof(c->aue_xfer, c, stat);
1447
1448         if (ifp->if_snd.ifq_head != NULL)
1449                 aue_start(ifp);
1450         AUE_UNLOCK(sc);
1451         return;
1452 }
1453
1454 /*
1455  * Stop the adapter and free any mbufs allocated to the
1456  * RX and TX lists.
1457  */
1458 Static void
1459 aue_stop(struct aue_softc *sc)
1460 {
1461         usbd_status             err;
1462         struct ifnet            *ifp;
1463         int                     i;
1464
1465         AUE_LOCK(sc);
1466         ifp = &sc->arpcom.ac_if;
1467         ifp->if_timer = 0;
1468
1469         aue_csr_write_1(sc, AUE_CTL0, 0);
1470         aue_csr_write_1(sc, AUE_CTL1, 0);
1471         aue_reset(sc);
1472         untimeout(aue_tick, sc, sc->aue_stat_ch);
1473
1474         /* Stop transfers. */
1475         if (sc->aue_ep[AUE_ENDPT_RX] != NULL) {
1476                 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_RX]);
1477                 if (err) {
1478                         printf("aue%d: abort rx pipe failed: %s\n",
1479                         sc->aue_unit, usbd_errstr(err));
1480                 }
1481                 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_RX]);
1482                 if (err) {
1483                         printf("aue%d: close rx pipe failed: %s\n",
1484                         sc->aue_unit, usbd_errstr(err));
1485                 }
1486                 sc->aue_ep[AUE_ENDPT_RX] = NULL;
1487         }
1488
1489         if (sc->aue_ep[AUE_ENDPT_TX] != NULL) {
1490                 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_TX]);
1491                 if (err) {
1492                         printf("aue%d: abort tx pipe failed: %s\n",
1493                         sc->aue_unit, usbd_errstr(err));
1494                 }
1495                 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_TX]);
1496                 if (err) {
1497                         printf("aue%d: close tx pipe failed: %s\n",
1498                             sc->aue_unit, usbd_errstr(err));
1499                 }
1500                 sc->aue_ep[AUE_ENDPT_TX] = NULL;
1501         }
1502
1503 #ifdef AUE_INTR_PIPE
1504         if (sc->aue_ep[AUE_ENDPT_INTR] != NULL) {
1505                 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_INTR]);
1506                 if (err) {
1507                         printf("aue%d: abort intr pipe failed: %s\n",
1508                         sc->aue_unit, usbd_errstr(err));
1509                 }
1510                 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_INTR]);
1511                 if (err) {
1512                         printf("aue%d: close intr pipe failed: %s\n",
1513                             sc->aue_unit, usbd_errstr(err));
1514                 }
1515                 sc->aue_ep[AUE_ENDPT_INTR] = NULL;
1516         }
1517 #endif
1518
1519         /* Free RX resources. */
1520         for (i = 0; i < AUE_RX_LIST_CNT; i++) {
1521                 if (sc->aue_cdata.aue_rx_chain[i].aue_buf != NULL) {
1522                         free(sc->aue_cdata.aue_rx_chain[i].aue_buf, M_USBDEV);
1523                         sc->aue_cdata.aue_rx_chain[i].aue_buf = NULL;
1524                 }
1525                 if (sc->aue_cdata.aue_rx_chain[i].aue_mbuf != NULL) {
1526                         m_freem(sc->aue_cdata.aue_rx_chain[i].aue_mbuf);
1527                         sc->aue_cdata.aue_rx_chain[i].aue_mbuf = NULL;
1528                 }
1529                 if (sc->aue_cdata.aue_rx_chain[i].aue_xfer != NULL) {
1530                         usbd_free_xfer(sc->aue_cdata.aue_rx_chain[i].aue_xfer);
1531                         sc->aue_cdata.aue_rx_chain[i].aue_xfer = NULL;
1532                 }
1533         }
1534
1535         /* Free TX resources. */
1536         for (i = 0; i < AUE_TX_LIST_CNT; i++) {
1537                 if (sc->aue_cdata.aue_tx_chain[i].aue_buf != NULL) {
1538                         free(sc->aue_cdata.aue_tx_chain[i].aue_buf, M_USBDEV);
1539                         sc->aue_cdata.aue_tx_chain[i].aue_buf = NULL;
1540                 }
1541                 if (sc->aue_cdata.aue_tx_chain[i].aue_mbuf != NULL) {
1542                         m_freem(sc->aue_cdata.aue_tx_chain[i].aue_mbuf);
1543                         sc->aue_cdata.aue_tx_chain[i].aue_mbuf = NULL;
1544                 }
1545                 if (sc->aue_cdata.aue_tx_chain[i].aue_xfer != NULL) {
1546                         usbd_free_xfer(sc->aue_cdata.aue_tx_chain[i].aue_xfer);
1547                         sc->aue_cdata.aue_tx_chain[i].aue_xfer = NULL;
1548                 }
1549         }
1550
1551 #ifdef AUE_INTR_PIPE
1552         free(sc->aue_cdata.aue_ibuf, M_USBDEV);
1553         sc->aue_cdata.aue_ibuf = NULL;
1554 #endif
1555
1556         sc->aue_link = 0;
1557
1558         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1559         AUE_UNLOCK(sc);
1560
1561         return;
1562 }
1563
1564 /*
1565  * Stop all chip I/O so that the kernel's probe routines don't
1566  * get confused by errant DMAs when rebooting.
1567  */
1568 Static void
1569 aue_shutdown(device_ptr_t dev)
1570 {
1571         struct aue_softc        *sc;
1572
1573         sc = device_get_softc(dev);
1574         sc->aue_dying++;
1575         AUE_LOCK(sc);
1576         aue_reset(sc);
1577         aue_stop(sc);
1578         AUE_UNLOCK(sc);
1579
1580         return;
1581 }