1 /* $NetBSD: if_udav.c,v 1.2 2003/09/04 15:17:38 tsutsui Exp $ */ 2 /* $nabe: if_udav.c,v 1.3 2003/08/21 16:57:19 nabe Exp $ */ 3 /* $FreeBSD$ */ 4 /*- 5 * Copyright (c) 2003 6 * Shingo WATANABE <nabe@nabechan.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. 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 THE AUTHOR 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 THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 */ 33 34 /* 35 * DM9601(DAVICOM USB to Ethernet MAC Controller with Integrated 10/100 PHY) 36 * The spec can be found at the following url. 37 * http://www.davicom.com.tw/big5/download/Data%20Sheet/DM9601-DS-P01-930914.pdf 38 */ 39 40 /* 41 * TODO: 42 * Interrupt Endpoint support 43 * External PHYs 44 */ 45 46 #include <sys/stdint.h> 47 #include <sys/param.h> 48 #include <sys/queue.h> 49 #include <sys/types.h> 50 #include <sys/systm.h> 51 #include <sys/kernel.h> 52 #include <sys/bus.h> 53 #include <sys/module.h> 54 #include <sys/lock.h> 55 #include <sys/mutex.h> 56 #include <sys/condvar.h> 57 #include <sys/sysctl.h> 58 #include <sys/unistd.h> 59 #include <sys/callout.h> 60 #include <sys/malloc.h> 61 #include <sys/priv.h> 62 63 #include <net/if.h> 64 #include <net/if_var.h> 65 #include <net/ifq_var.h> 66 67 #include <bus/u4b/usb.h> 68 #include <bus/u4b/usbdi.h> 69 #include <bus/u4b/usbdi_util.h> 70 #include "usbdevs.h" 71 72 #define USB_DEBUG_VAR udav_debug 73 #include <bus/u4b/usb_debug.h> 74 #include <bus/u4b/usb_process.h> 75 76 #include <bus/u4b/net/usb_ethernet.h> 77 #include <bus/u4b/net/if_udavreg.h> 78 79 /* prototypes */ 80 81 static device_probe_t udav_probe; 82 static device_attach_t udav_attach; 83 static device_detach_t udav_detach; 84 85 static usb_callback_t udav_bulk_write_callback; 86 static usb_callback_t udav_bulk_read_callback; 87 static usb_callback_t udav_intr_callback; 88 89 static uether_fn_t udav_attach_post; 90 static uether_fn_t udav_init; 91 static uether_fn_t udav_stop; 92 static uether_fn_t udav_start; 93 static uether_fn_t udav_tick; 94 static uether_fn_t udav_setmulti; 95 static uether_fn_t udav_setpromisc; 96 97 static int udav_csr_read(struct udav_softc *, uint16_t, void *, int); 98 static int udav_csr_write(struct udav_softc *, uint16_t, void *, int); 99 static uint8_t udav_csr_read1(struct udav_softc *, uint16_t); 100 static int udav_csr_write1(struct udav_softc *, uint16_t, uint8_t); 101 static void udav_reset(struct udav_softc *); 102 static int udav_ifmedia_upd(struct ifnet *); 103 static void udav_ifmedia_status(struct ifnet *, struct ifmediareq *); 104 105 static miibus_readreg_t udav_miibus_readreg; 106 static miibus_writereg_t udav_miibus_writereg; 107 static miibus_statchg_t udav_miibus_statchg; 108 109 static const struct usb_config udav_config[UDAV_N_TRANSFER] = { 110 111 [UDAV_BULK_DT_WR] = { 112 .type = UE_BULK, 113 .endpoint = UE_ADDR_ANY, 114 .direction = UE_DIR_OUT, 115 .bufsize = (MCLBYTES + 2), 116 .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 117 .callback = udav_bulk_write_callback, 118 .timeout = 10000, /* 10 seconds */ 119 }, 120 121 [UDAV_BULK_DT_RD] = { 122 .type = UE_BULK, 123 .endpoint = UE_ADDR_ANY, 124 .direction = UE_DIR_IN, 125 .bufsize = (MCLBYTES + 3), 126 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 127 .callback = udav_bulk_read_callback, 128 .timeout = 0, /* no timeout */ 129 }, 130 131 [UDAV_INTR_DT_RD] = { 132 .type = UE_INTERRUPT, 133 .endpoint = UE_ADDR_ANY, 134 .direction = UE_DIR_IN, 135 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 136 .bufsize = 0, /* use wMaxPacketSize */ 137 .callback = udav_intr_callback, 138 }, 139 }; 140 141 static device_method_t udav_methods[] = { 142 /* Device interface */ 143 DEVMETHOD(device_probe, udav_probe), 144 DEVMETHOD(device_attach, udav_attach), 145 DEVMETHOD(device_detach, udav_detach), 146 147 /* MII interface */ 148 DEVMETHOD(miibus_readreg, udav_miibus_readreg), 149 DEVMETHOD(miibus_writereg, udav_miibus_writereg), 150 DEVMETHOD(miibus_statchg, udav_miibus_statchg), 151 152 DEVMETHOD_END 153 }; 154 155 static driver_t udav_driver = { 156 .name = "udav", 157 .methods = udav_methods, 158 .size = sizeof(struct udav_softc), 159 }; 160 161 static devclass_t udav_devclass; 162 163 DRIVER_MODULE(udav, uhub, udav_driver, udav_devclass, NULL, NULL); 164 DRIVER_MODULE(miibus, udav, miibus_driver, miibus_devclass, NULL, NULL); 165 MODULE_DEPEND(udav, uether, 1, 1, 1); 166 MODULE_DEPEND(udav, usb, 1, 1, 1); 167 MODULE_DEPEND(udav, ether, 1, 1, 1); 168 MODULE_DEPEND(udav, miibus, 1, 1, 1); 169 MODULE_VERSION(udav, 1); 170 171 static const struct usb_ether_methods udav_ue_methods = { 172 .ue_attach_post = udav_attach_post, 173 .ue_start = udav_start, 174 .ue_init = udav_init, 175 .ue_stop = udav_stop, 176 .ue_tick = udav_tick, 177 .ue_setmulti = udav_setmulti, 178 .ue_setpromisc = udav_setpromisc, 179 .ue_mii_upd = udav_ifmedia_upd, 180 .ue_mii_sts = udav_ifmedia_status, 181 }; 182 183 static const struct usb_ether_methods udav_ue_methods_nophy = { 184 .ue_attach_post = udav_attach_post, 185 .ue_start = udav_start, 186 .ue_init = udav_init, 187 .ue_stop = udav_stop, 188 .ue_setmulti = udav_setmulti, 189 .ue_setpromisc = udav_setpromisc, 190 }; 191 192 #ifdef USB_DEBUG 193 static int udav_debug = 0; 194 195 static SYSCTL_NODE(_hw_usb, OID_AUTO, udav, CTLFLAG_RW, 0, "USB udav"); 196 SYSCTL_INT(_hw_usb_udav, OID_AUTO, debug, CTLFLAG_RW, &udav_debug, 0, 197 "Debug level"); 198 #endif 199 200 #define UDAV_SETBIT(sc, reg, x) \ 201 udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) | (x)) 202 203 #define UDAV_CLRBIT(sc, reg, x) \ 204 udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) & ~(x)) 205 206 static const STRUCT_USB_HOST_ID udav_devs[] = { 207 /* ShanTou DM9601 USB NIC */ 208 {USB_VPI(USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_DM9601, 0)}, 209 /* ShanTou ST268 USB NIC */ 210 {USB_VPI(USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_ST268, 0)}, 211 /* Corega USB-TXC */ 212 {USB_VPI(USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TXC, 0)}, 213 /* ShanTou AMD8515 USB NIC */ 214 {USB_VPI(USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_ADM8515, 0)}, 215 /* Kontron AG USB Ethernet */ 216 {USB_VPI(USB_VENDOR_KONTRON, USB_PRODUCT_KONTRON_DM9601, 0)}, 217 {USB_VPI(USB_VENDOR_KONTRON, USB_PRODUCT_KONTRON_JP1082, 218 UDAV_FLAG_NO_PHY)}, 219 }; 220 221 static void 222 udav_attach_post(struct usb_ether *ue) 223 { 224 struct udav_softc *sc = uether_getsc(ue); 225 226 /* reset the adapter */ 227 udav_reset(sc); 228 229 /* Get Ethernet Address */ 230 udav_csr_read(sc, UDAV_PAR, ue->ue_eaddr, ETHER_ADDR_LEN); 231 } 232 233 static int 234 udav_probe(device_t dev) 235 { 236 struct usb_attach_arg *uaa = device_get_ivars(dev); 237 238 if (uaa->usb_mode != USB_MODE_HOST) 239 return (ENXIO); 240 if (uaa->info.bConfigIndex != UDAV_CONFIG_INDEX) 241 return (ENXIO); 242 if (uaa->info.bIfaceIndex != UDAV_IFACE_INDEX) 243 return (ENXIO); 244 245 return (usbd_lookup_id_by_uaa(udav_devs, sizeof(udav_devs), uaa)); 246 } 247 248 static int 249 udav_attach(device_t dev) 250 { 251 struct usb_attach_arg *uaa = device_get_ivars(dev); 252 struct udav_softc *sc = device_get_softc(dev); 253 struct usb_ether *ue = &sc->sc_ue; 254 uint8_t iface_index; 255 int error; 256 257 sc->sc_flags = USB_GET_DRIVER_INFO(uaa); 258 259 device_set_usb_desc(dev); 260 261 lockinit(&sc->sc_lock, device_get_nameunit(dev), 0, 0); 262 263 iface_index = UDAV_IFACE_INDEX; 264 error = usbd_transfer_setup(uaa->device, &iface_index, 265 sc->sc_xfer, udav_config, UDAV_N_TRANSFER, sc, &sc->sc_lock); 266 if (error) { 267 device_printf(dev, "allocating USB transfers failed\n"); 268 goto detach; 269 } 270 271 /* 272 * The JP1082 has an unusable PHY and provides no link information. 273 */ 274 if (sc->sc_flags & UDAV_FLAG_NO_PHY) { 275 ue->ue_methods = &udav_ue_methods_nophy; 276 sc->sc_flags |= UDAV_FLAG_LINK; 277 } else { 278 ue->ue_methods = &udav_ue_methods; 279 } 280 281 ue->ue_sc = sc; 282 ue->ue_dev = dev; 283 ue->ue_udev = uaa->device; 284 ue->ue_lock = &sc->sc_lock; 285 286 error = uether_ifattach(ue); 287 if (error) { 288 device_printf(dev, "could not attach interface\n"); 289 goto detach; 290 } 291 292 return (0); /* success */ 293 294 detach: 295 udav_detach(dev); 296 return (ENXIO); /* failure */ 297 } 298 299 static int 300 udav_detach(device_t dev) 301 { 302 struct udav_softc *sc = device_get_softc(dev); 303 struct usb_ether *ue = &sc->sc_ue; 304 305 usbd_transfer_unsetup(sc->sc_xfer, UDAV_N_TRANSFER); 306 uether_ifdetach(ue); 307 lockuninit(&sc->sc_lock); 308 309 return (0); 310 } 311 312 #if 0 313 static int 314 udav_mem_read(struct udav_softc *sc, uint16_t offset, void *buf, 315 int len) 316 { 317 struct usb_device_request req; 318 319 len &= 0xff; 320 321 req.bmRequestType = UT_READ_VENDOR_DEVICE; 322 req.bRequest = UDAV_REQ_MEM_READ; 323 USETW(req.wValue, 0x0000); 324 USETW(req.wIndex, offset); 325 USETW(req.wLength, len); 326 327 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 328 } 329 330 static int 331 udav_mem_write(struct udav_softc *sc, uint16_t offset, void *buf, 332 int len) 333 { 334 struct usb_device_request req; 335 336 len &= 0xff; 337 338 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 339 req.bRequest = UDAV_REQ_MEM_WRITE; 340 USETW(req.wValue, 0x0000); 341 USETW(req.wIndex, offset); 342 USETW(req.wLength, len); 343 344 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 345 } 346 347 static int 348 udav_mem_write1(struct udav_softc *sc, uint16_t offset, 349 uint8_t ch) 350 { 351 struct usb_device_request req; 352 353 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 354 req.bRequest = UDAV_REQ_MEM_WRITE1; 355 USETW(req.wValue, ch); 356 USETW(req.wIndex, offset); 357 USETW(req.wLength, 0x0000); 358 359 return (uether_do_request(&sc->sc_ue, &req, NULL, 1000)); 360 } 361 #endif 362 363 static int 364 udav_csr_read(struct udav_softc *sc, uint16_t offset, void *buf, int len) 365 { 366 struct usb_device_request req; 367 368 len &= 0xff; 369 370 req.bmRequestType = UT_READ_VENDOR_DEVICE; 371 req.bRequest = UDAV_REQ_REG_READ; 372 USETW(req.wValue, 0x0000); 373 USETW(req.wIndex, offset); 374 USETW(req.wLength, len); 375 376 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 377 } 378 379 static int 380 udav_csr_write(struct udav_softc *sc, uint16_t offset, void *buf, int len) 381 { 382 struct usb_device_request req; 383 384 offset &= 0xff; 385 len &= 0xff; 386 387 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 388 req.bRequest = UDAV_REQ_REG_WRITE; 389 USETW(req.wValue, 0x0000); 390 USETW(req.wIndex, offset); 391 USETW(req.wLength, len); 392 393 return (uether_do_request(&sc->sc_ue, &req, buf, 1000)); 394 } 395 396 static uint8_t 397 udav_csr_read1(struct udav_softc *sc, uint16_t offset) 398 { 399 uint8_t val; 400 401 udav_csr_read(sc, offset, &val, 1); 402 return (val); 403 } 404 405 static int 406 udav_csr_write1(struct udav_softc *sc, uint16_t offset, 407 uint8_t ch) 408 { 409 struct usb_device_request req; 410 411 offset &= 0xff; 412 413 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 414 req.bRequest = UDAV_REQ_REG_WRITE1; 415 USETW(req.wValue, ch); 416 USETW(req.wIndex, offset); 417 USETW(req.wLength, 0x0000); 418 419 return (uether_do_request(&sc->sc_ue, &req, NULL, 1000)); 420 } 421 422 static void 423 udav_init(struct usb_ether *ue) 424 { 425 struct udav_softc *sc = ue->ue_sc; 426 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 427 428 UDAV_LOCK_ASSERT(sc); 429 430 /* 431 * Cancel pending I/O 432 */ 433 udav_stop(ue); 434 435 /* set MAC address */ 436 udav_csr_write(sc, UDAV_PAR, IF_LLADDR(ifp), ETHER_ADDR_LEN); 437 438 /* initialize network control register */ 439 440 /* disable loopback */ 441 UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_LBK0 | UDAV_NCR_LBK1); 442 443 /* Initialize RX control register */ 444 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_DIS_LONG | UDAV_RCR_DIS_CRC); 445 446 /* load multicast filter and update promiscious mode bit */ 447 udav_setpromisc(ue); 448 449 /* enable RX */ 450 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_RXEN); 451 452 /* clear POWER_DOWN state of internal PHY */ 453 UDAV_SETBIT(sc, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0); 454 UDAV_CLRBIT(sc, UDAV_GPR, UDAV_GPR_GEPIO0); 455 456 usbd_xfer_set_stall(sc->sc_xfer[UDAV_BULK_DT_WR]); 457 458 #if 0 /* XXX */ 459 ifp->if_drv_flags |= IFF_DRV_RUNNING; 460 #endif 461 udav_start(ue); 462 } 463 464 static void 465 udav_reset(struct udav_softc *sc) 466 { 467 int i; 468 469 /* Select PHY */ 470 #if 1 471 /* 472 * XXX: force select internal phy. 473 * external phy routines are not tested. 474 */ 475 UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY); 476 #else 477 if (sc->sc_flags & UDAV_EXT_PHY) 478 UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY); 479 else 480 UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY); 481 #endif 482 483 UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_RST); 484 485 for (i = 0; i < UDAV_TX_TIMEOUT; i++) { 486 if (!(udav_csr_read1(sc, UDAV_NCR) & UDAV_NCR_RST)) 487 break; 488 if (uether_pause(&sc->sc_ue, hz / 100)) 489 break; 490 } 491 492 uether_pause(&sc->sc_ue, hz / 100); 493 } 494 495 #define UDAV_BITS 6 496 static void 497 udav_setmulti(struct usb_ether *ue) 498 { 499 struct udav_softc *sc = ue->ue_sc; 500 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 501 struct ifmultiaddr *ifma; 502 uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 503 int h = 0; 504 505 UDAV_LOCK_ASSERT(sc); 506 507 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 508 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC); 509 return; 510 } 511 512 /* first, zot all the existing hash bits */ 513 memset(hashtbl, 0x00, sizeof(hashtbl)); 514 hashtbl[7] |= 0x80; /* broadcast address */ 515 udav_csr_write(sc, UDAV_MAR, hashtbl, sizeof(hashtbl)); 516 517 /* now program new ones */ 518 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) 519 { 520 if (ifma->ifma_addr->sa_family != AF_LINK) 521 continue; 522 h = ether_crc32_be(LLADDR((struct sockaddr_dl *) 523 ifma->ifma_addr), ETHER_ADDR_LEN) >> 26; 524 setbit(hashtbl, h); 525 } 526 527 /* disable all multicast */ 528 UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL); 529 530 /* write hash value to the register */ 531 udav_csr_write(sc, UDAV_MAR, hashtbl, sizeof(hashtbl)); 532 } 533 534 static void 535 udav_setpromisc(struct usb_ether *ue) 536 { 537 struct udav_softc *sc = ue->ue_sc; 538 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 539 uint8_t rxmode; 540 541 rxmode = udav_csr_read1(sc, UDAV_RCR); 542 rxmode &= ~(UDAV_RCR_ALL | UDAV_RCR_PRMSC); 543 544 if (ifp->if_flags & IFF_PROMISC) 545 rxmode |= UDAV_RCR_ALL | UDAV_RCR_PRMSC; 546 else if (ifp->if_flags & IFF_ALLMULTI) 547 rxmode |= UDAV_RCR_ALL; 548 549 /* write new mode bits */ 550 udav_csr_write1(sc, UDAV_RCR, rxmode); 551 } 552 553 static void 554 udav_start(struct usb_ether *ue) 555 { 556 struct udav_softc *sc = ue->ue_sc; 557 558 /* 559 * start the USB transfers, if not already started: 560 */ 561 usbd_transfer_start(sc->sc_xfer[UDAV_INTR_DT_RD]); 562 usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_RD]); 563 usbd_transfer_start(sc->sc_xfer[UDAV_BULK_DT_WR]); 564 } 565 566 static void 567 udav_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 568 { 569 struct udav_softc *sc = usbd_xfer_softc(xfer); 570 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 571 struct usb_page_cache *pc; 572 struct mbuf *m; 573 int extra_len; 574 int temp_len; 575 uint8_t buf[2]; 576 577 switch (USB_GET_STATE(xfer)) { 578 case USB_ST_TRANSFERRED: 579 DPRINTFN(11, "transfer complete\n"); 580 IFNET_STAT_INC(ifp, opackets, 1); 581 582 /* FALLTHROUGH */ 583 case USB_ST_SETUP: 584 tr_setup: 585 if ((sc->sc_flags & UDAV_FLAG_LINK) == 0) { 586 /* 587 * don't send anything if there is no link ! 588 */ 589 return; 590 } 591 m = ifq_dequeue(&ifp->if_snd); 592 593 if (m == NULL) 594 return; 595 if (m->m_pkthdr.len > MCLBYTES) 596 m->m_pkthdr.len = MCLBYTES; 597 if (m->m_pkthdr.len < UDAV_MIN_FRAME_LEN) { 598 extra_len = UDAV_MIN_FRAME_LEN - m->m_pkthdr.len; 599 } else { 600 extra_len = 0; 601 } 602 603 temp_len = (m->m_pkthdr.len + extra_len); 604 605 /* 606 * the frame length is specified in the first 2 bytes of the 607 * buffer 608 */ 609 buf[0] = (uint8_t)(temp_len); 610 buf[1] = (uint8_t)(temp_len >> 8); 611 612 temp_len += 2; 613 614 pc = usbd_xfer_get_frame(xfer, 0); 615 usbd_copy_in(pc, 0, buf, 2); 616 usbd_m_copy_in(pc, 2, m, 0, m->m_pkthdr.len); 617 618 if (extra_len) 619 usbd_frame_zero(pc, temp_len - extra_len, extra_len); 620 /* 621 * if there's a BPF listener, bounce a copy 622 * of this frame to him: 623 */ 624 BPF_MTAP(ifp, m); 625 626 m_freem(m); 627 628 usbd_xfer_set_frame_len(xfer, 0, temp_len); 629 usbd_transfer_submit(xfer); 630 return; 631 632 default: /* Error */ 633 DPRINTFN(11, "transfer error, %s\n", 634 usbd_errstr(error)); 635 636 IFNET_STAT_INC(ifp, oerrors, 1); 637 638 if (error != USB_ERR_CANCELLED) { 639 /* try to clear stall first */ 640 usbd_xfer_set_stall(xfer); 641 goto tr_setup; 642 } 643 return; 644 } 645 } 646 647 static void 648 udav_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 649 { 650 struct udav_softc *sc = usbd_xfer_softc(xfer); 651 struct usb_ether *ue = &sc->sc_ue; 652 struct ifnet *ifp = uether_getifp(ue); 653 struct usb_page_cache *pc; 654 struct udav_rxpkt stat; 655 int len; 656 int actlen; 657 658 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 659 660 switch (USB_GET_STATE(xfer)) { 661 case USB_ST_TRANSFERRED: 662 663 if (actlen < sizeof(stat) + ETHER_CRC_LEN) { 664 IFNET_STAT_INC(ifp, ierrors, 1); 665 goto tr_setup; 666 } 667 pc = usbd_xfer_get_frame(xfer, 0); 668 usbd_copy_out(pc, 0, &stat, sizeof(stat)); 669 actlen -= sizeof(stat); 670 len = min(actlen, le16toh(stat.pktlen)); 671 len -= ETHER_CRC_LEN; 672 673 if (stat.rxstat & UDAV_RSR_LCS) { 674 IFNET_STAT_INC(ifp, collisions, 1); 675 goto tr_setup; 676 } 677 if (stat.rxstat & UDAV_RSR_ERR) { 678 IFNET_STAT_INC(ifp, ierrors, 1); 679 goto tr_setup; 680 } 681 uether_rxbuf(ue, pc, sizeof(stat), len); 682 /* FALLTHROUGH */ 683 case USB_ST_SETUP: 684 tr_setup: 685 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 686 usbd_transfer_submit(xfer); 687 uether_rxflush(ue); 688 return; 689 690 default: /* Error */ 691 DPRINTF("bulk read error, %s\n", 692 usbd_errstr(error)); 693 694 if (error != USB_ERR_CANCELLED) { 695 /* try to clear stall first */ 696 usbd_xfer_set_stall(xfer); 697 goto tr_setup; 698 } 699 return; 700 } 701 } 702 703 static void 704 udav_intr_callback(struct usb_xfer *xfer, usb_error_t error) 705 { 706 switch (USB_GET_STATE(xfer)) { 707 case USB_ST_TRANSFERRED: 708 case USB_ST_SETUP: 709 tr_setup: 710 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 711 usbd_transfer_submit(xfer); 712 return; 713 714 default: /* Error */ 715 if (error != USB_ERR_CANCELLED) { 716 /* try to clear stall first */ 717 usbd_xfer_set_stall(xfer); 718 goto tr_setup; 719 } 720 return; 721 } 722 } 723 724 static void 725 udav_stop(struct usb_ether *ue) 726 { 727 struct udav_softc *sc = ue->ue_sc; 728 #if 0 /* XXX */ 729 struct ifnet *ifp = uether_getifp(&sc->sc_ue); 730 #endif 731 732 UDAV_LOCK_ASSERT(sc); 733 734 #if 0 /* XXX */ 735 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 736 #endif 737 if (!(sc->sc_flags & UDAV_FLAG_NO_PHY)) 738 sc->sc_flags &= ~UDAV_FLAG_LINK; 739 740 /* 741 * stop all the transfers, if not already stopped: 742 */ 743 usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_WR]); 744 usbd_transfer_stop(sc->sc_xfer[UDAV_BULK_DT_RD]); 745 usbd_transfer_stop(sc->sc_xfer[UDAV_INTR_DT_RD]); 746 747 udav_reset(sc); 748 } 749 750 static int 751 udav_ifmedia_upd(struct ifnet *ifp) 752 { 753 struct udav_softc *sc = ifp->if_softc; 754 struct mii_data *mii = GET_MII(sc); 755 struct mii_softc *miisc; 756 int error; 757 758 UDAV_LOCK_ASSERT(sc); 759 760 sc->sc_flags &= ~UDAV_FLAG_LINK; 761 LIST_FOREACH(miisc, &mii->mii_phys, mii_list) 762 mii_phy_reset(miisc); 763 error = mii_mediachg(mii); 764 return (error); 765 } 766 767 static void 768 udav_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr) 769 { 770 struct udav_softc *sc = ifp->if_softc; 771 struct mii_data *mii = GET_MII(sc); 772 773 UDAV_LOCK(sc); 774 mii_pollstat(mii); 775 ifmr->ifm_active = mii->mii_media_active; 776 ifmr->ifm_status = mii->mii_media_status; 777 UDAV_UNLOCK(sc); 778 } 779 780 static void 781 udav_tick(struct usb_ether *ue) 782 { 783 struct udav_softc *sc = ue->ue_sc; 784 struct mii_data *mii = GET_MII(sc); 785 786 UDAV_LOCK_ASSERT(sc); 787 788 mii_tick(mii); 789 if ((sc->sc_flags & UDAV_FLAG_LINK) == 0 790 && mii->mii_media_status & IFM_ACTIVE && 791 IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 792 sc->sc_flags |= UDAV_FLAG_LINK; 793 udav_start(ue); 794 } 795 } 796 797 static int 798 udav_miibus_readreg(device_t dev, int phy, int reg) 799 { 800 struct udav_softc *sc = device_get_softc(dev); 801 uint16_t data16; 802 uint8_t val[2]; 803 int locked; 804 805 /* XXX: one PHY only for the internal PHY */ 806 if (phy != 0) 807 return (0); 808 809 locked = lockowned(&sc->sc_lock); 810 if (!locked) 811 UDAV_LOCK(sc); 812 813 /* select internal PHY and set PHY register address */ 814 udav_csr_write1(sc, UDAV_EPAR, 815 UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK)); 816 817 /* select PHY operation and start read command */ 818 udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRR); 819 820 /* XXX: should we wait? */ 821 822 /* end read command */ 823 UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRR); 824 825 /* retrieve the result from data registers */ 826 udav_csr_read(sc, UDAV_EPDRL, val, 2); 827 828 data16 = (val[0] | (val[1] << 8)); 829 830 DPRINTFN(11, "phy=%d reg=0x%04x => 0x%04x\n", 831 phy, reg, data16); 832 833 if (!locked) 834 UDAV_UNLOCK(sc); 835 return (data16); 836 } 837 838 static int 839 udav_miibus_writereg(device_t dev, int phy, int reg, int data) 840 { 841 struct udav_softc *sc = device_get_softc(dev); 842 uint8_t val[2]; 843 int locked; 844 845 /* XXX: one PHY only for the internal PHY */ 846 if (phy != 0) 847 return (0); 848 849 locked = lockowned(&sc->sc_lock); 850 if (!locked) 851 UDAV_LOCK(sc); 852 853 /* select internal PHY and set PHY register address */ 854 udav_csr_write1(sc, UDAV_EPAR, 855 UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK)); 856 857 /* put the value to the data registers */ 858 val[0] = (data & 0xff); 859 val[1] = (data >> 8) & 0xff; 860 udav_csr_write(sc, UDAV_EPDRL, val, 2); 861 862 /* select PHY operation and start write command */ 863 udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRW); 864 865 /* XXX: should we wait? */ 866 867 /* end write command */ 868 UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRW); 869 870 if (!locked) 871 UDAV_UNLOCK(sc); 872 return (0); 873 } 874 875 static void 876 udav_miibus_statchg(device_t dev) 877 { 878 /* nothing to do */ 879 } 880