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