1 /* $OpenBSD: if_url.c,v 1.80 2016/04/13 11:03:37 mpi Exp $ */ 2 /* $NetBSD: if_url.c,v 1.6 2002/09/29 10:19:21 martin Exp $ */ 3 /* 4 * Copyright (c) 2001, 2002 5 * Shingo WATANABE <nabe@nabechan.org>. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the author nor the names of any co-contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 */ 32 33 /* 34 * The RTL8150L(Realtek USB to fast ethernet controller) spec can be found at 35 * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/8150v14.pdf 36 * ftp://152.104.125.40/lancard/data_sheet/8150/8150v14.pdf 37 */ 38 39 /* 40 * TODO: 41 * Interrupt Endpoint support 42 * External PHYs 43 */ 44 45 #include "bpfilter.h" 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/rwlock.h> 50 #include <sys/mbuf.h> 51 #include <sys/kernel.h> 52 #include <sys/socket.h> 53 54 #include <sys/device.h> 55 56 #include <net/if.h> 57 #include <net/if_media.h> 58 59 #if NBPFILTER > 0 60 #include <net/bpf.h> 61 #endif 62 63 #include <netinet/in.h> 64 #include <netinet/if_ether.h> 65 66 #include <dev/mii/mii.h> 67 #include <dev/mii/miivar.h> 68 #include <dev/mii/urlphyreg.h> 69 70 #include <dev/usb/usb.h> 71 #include <dev/usb/usbdi.h> 72 #include <dev/usb/usbdi_util.h> 73 #include <dev/usb/usbdevs.h> 74 75 #include <dev/usb/if_urlreg.h> 76 77 int url_match(struct device *, void *, void *); 78 void url_attach(struct device *, struct device *, void *); 79 int url_detach(struct device *, int); 80 81 struct cfdriver url_cd = { 82 NULL, "url", DV_IFNET 83 }; 84 85 const struct cfattach url_ca = { 86 sizeof(struct url_softc), url_match, url_attach, url_detach 87 }; 88 89 int url_openpipes(struct url_softc *); 90 int url_rx_list_init(struct url_softc *); 91 int url_tx_list_init(struct url_softc *); 92 int url_newbuf(struct url_softc *, struct url_chain *, struct mbuf *); 93 void url_start(struct ifnet *); 94 int url_send(struct url_softc *, struct mbuf *, int); 95 void url_txeof(struct usbd_xfer *, void *, usbd_status); 96 void url_rxeof(struct usbd_xfer *, void *, usbd_status); 97 void url_tick(void *); 98 void url_tick_task(void *); 99 int url_ioctl(struct ifnet *, u_long, caddr_t); 100 void url_stop_task(struct url_softc *); 101 void url_stop(struct ifnet *, int); 102 void url_watchdog(struct ifnet *); 103 int url_ifmedia_change(struct ifnet *); 104 void url_ifmedia_status(struct ifnet *, struct ifmediareq *); 105 void url_lock_mii(struct url_softc *); 106 void url_unlock_mii(struct url_softc *); 107 int url_int_miibus_readreg(struct device *, int, int); 108 void url_int_miibus_writereg(struct device *, int, int, int); 109 void url_miibus_statchg(struct device *); 110 int url_init(struct ifnet *); 111 void url_iff(struct url_softc *); 112 void url_reset(struct url_softc *); 113 114 int url_csr_read_1(struct url_softc *, int); 115 int url_csr_read_2(struct url_softc *, int); 116 int url_csr_write_1(struct url_softc *, int, int); 117 int url_csr_write_2(struct url_softc *, int, int); 118 int url_csr_write_4(struct url_softc *, int, int); 119 int url_mem(struct url_softc *, int, int, void *, int); 120 121 /* Macros */ 122 #ifdef URL_DEBUG 123 #define DPRINTF(x) do { if (urldebug) printf x; } while (0) 124 #define DPRINTFN(n,x) do { if (urldebug >= (n)) printf x; } while (0) 125 int urldebug = 0; 126 #else 127 #define DPRINTF(x) 128 #define DPRINTFN(n,x) 129 #endif 130 131 #define URL_SETBIT(sc, reg, x) \ 132 url_csr_write_1(sc, reg, url_csr_read_1(sc, reg) | (x)) 133 134 #define URL_SETBIT2(sc, reg, x) \ 135 url_csr_write_2(sc, reg, url_csr_read_2(sc, reg) | (x)) 136 137 #define URL_CLRBIT(sc, reg, x) \ 138 url_csr_write_1(sc, reg, url_csr_read_1(sc, reg) & ~(x)) 139 140 #define URL_CLRBIT2(sc, reg, x) \ 141 url_csr_write_2(sc, reg, url_csr_read_2(sc, reg) & ~(x)) 142 143 static const struct url_type { 144 struct usb_devno url_dev; 145 u_int16_t url_flags; 146 #define URL_EXT_PHY 0x0001 147 } url_devs [] = { 148 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_LCS8138TX}, 0}, 149 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_RTL8151}, 0}, 150 {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX }, 0}, 151 {{ USB_VENDOR_MICRONET, USB_PRODUCT_MICRONET_SP128AR}, 0}, 152 {{ USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01}, 0}, 153 {{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8150}, 0}, 154 {{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_RTL8151}, 0}, 155 {{ USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_PRESTIGE}, 0} 156 }; 157 #define url_lookup(v, p) ((struct url_type *)usb_lookup(url_devs, v, p)) 158 159 160 /* Probe */ 161 int 162 url_match(struct device *parent, void *match, void *aux) 163 { 164 struct usb_attach_arg *uaa = aux; 165 166 if (uaa->iface != NULL) 167 return (UMATCH_NONE); 168 169 return (url_lookup(uaa->vendor, uaa->product) != NULL ? 170 UMATCH_VENDOR_PRODUCT : UMATCH_NONE); 171 } 172 /* Attach */ 173 void 174 url_attach(struct device *parent, struct device *self, void *aux) 175 { 176 struct url_softc *sc = (struct url_softc *)self; 177 struct usb_attach_arg *uaa = aux; 178 struct usbd_device *dev = uaa->device; 179 struct usbd_interface *iface; 180 usbd_status err; 181 usb_interface_descriptor_t *id; 182 usb_endpoint_descriptor_t *ed; 183 char *devname = sc->sc_dev.dv_xname; 184 struct ifnet *ifp; 185 struct mii_data *mii; 186 u_char eaddr[ETHER_ADDR_LEN]; 187 int i, s; 188 189 sc->sc_udev = dev; 190 191 /* Move the device into the configured state. */ 192 err = usbd_set_config_no(dev, URL_CONFIG_NO, 1); 193 if (err) { 194 printf("%s: setting config no failed\n", devname); 195 goto bad; 196 } 197 198 usb_init_task(&sc->sc_tick_task, url_tick_task, sc, 199 USB_TASK_TYPE_GENERIC); 200 rw_init(&sc->sc_mii_lock, "urlmii"); 201 usb_init_task(&sc->sc_stop_task, (void (*)(void *)) url_stop_task, sc, 202 USB_TASK_TYPE_GENERIC); 203 204 /* get control interface */ 205 err = usbd_device2interface_handle(dev, URL_IFACE_INDEX, &iface); 206 if (err) { 207 printf("%s: failed to get interface, err=%s\n", devname, 208 usbd_errstr(err)); 209 goto bad; 210 } 211 212 sc->sc_ctl_iface = iface; 213 sc->sc_flags = url_lookup(uaa->vendor, uaa->product)->url_flags; 214 215 /* get interface descriptor */ 216 id = usbd_get_interface_descriptor(sc->sc_ctl_iface); 217 218 /* find endpoints */ 219 sc->sc_bulkin_no = sc->sc_bulkout_no = sc->sc_intrin_no = -1; 220 for (i = 0; i < id->bNumEndpoints; i++) { 221 ed = usbd_interface2endpoint_descriptor(sc->sc_ctl_iface, i); 222 if (ed == NULL) { 223 printf("%s: couldn't get endpoint %d\n", devname, i); 224 goto bad; 225 } 226 if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK && 227 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) 228 sc->sc_bulkin_no = ed->bEndpointAddress; /* RX */ 229 else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK && 230 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT) 231 sc->sc_bulkout_no = ed->bEndpointAddress; /* TX */ 232 else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT && 233 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) 234 sc->sc_intrin_no = ed->bEndpointAddress; /* Status */ 235 } 236 237 if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1 || 238 sc->sc_intrin_no == -1) { 239 printf("%s: missing endpoint\n", devname); 240 goto bad; 241 } 242 243 s = splnet(); 244 245 /* reset the adapter */ 246 url_reset(sc); 247 248 /* Get Ethernet Address */ 249 err = url_mem(sc, URL_CMD_READMEM, URL_IDR0, (void *)eaddr, 250 ETHER_ADDR_LEN); 251 if (err) { 252 printf("%s: read MAC address failed\n", devname); 253 splx(s); 254 goto bad; 255 } 256 257 /* Print Ethernet Address */ 258 printf("%s: address %s\n", devname, ether_sprintf(eaddr)); 259 260 bcopy(eaddr, (char *)&sc->sc_ac.ac_enaddr, ETHER_ADDR_LEN); 261 /* initialize interface information */ 262 ifp = GET_IFP(sc); 263 ifp->if_softc = sc; 264 strlcpy(ifp->if_xname, devname, IFNAMSIZ); 265 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 266 ifp->if_start = url_start; 267 ifp->if_ioctl = url_ioctl; 268 ifp->if_watchdog = url_watchdog; 269 270 ifp->if_capabilities = IFCAP_VLAN_MTU; 271 272 /* 273 * Do ifmedia setup. 274 */ 275 mii = &sc->sc_mii; 276 mii->mii_ifp = ifp; 277 mii->mii_readreg = url_int_miibus_readreg; 278 mii->mii_writereg = url_int_miibus_writereg; 279 #if 0 280 if (sc->sc_flags & URL_EXT_PHY) { 281 mii->mii_readreg = url_ext_miibus_readreg; 282 mii->mii_writereg = url_ext_miibus_writereg; 283 } 284 #endif 285 mii->mii_statchg = url_miibus_statchg; 286 mii->mii_flags = MIIF_AUTOTSLEEP; 287 ifmedia_init(&mii->mii_media, 0, 288 url_ifmedia_change, url_ifmedia_status); 289 mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0); 290 if (LIST_FIRST(&mii->mii_phys) == NULL) { 291 ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL); 292 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE); 293 } else 294 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO); 295 296 /* attach the interface */ 297 if_attach(ifp); 298 ether_ifattach(ifp); 299 300 timeout_set(&sc->sc_stat_ch, url_tick, sc); 301 302 splx(s); 303 304 return; 305 306 bad: 307 usbd_deactivate(sc->sc_udev); 308 } 309 310 /* detach */ 311 int 312 url_detach(struct device *self, int flags) 313 { 314 struct url_softc *sc = (struct url_softc *)self; 315 struct ifnet *ifp = GET_IFP(sc); 316 int s; 317 318 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 319 320 if (timeout_initialized(&sc->sc_stat_ch)) 321 timeout_del(&sc->sc_stat_ch); 322 323 /* Remove any pending tasks */ 324 usb_rem_task(sc->sc_udev, &sc->sc_tick_task); 325 usb_rem_task(sc->sc_udev, &sc->sc_stop_task); 326 327 s = splusb(); 328 329 if (--sc->sc_refcnt >= 0) { 330 /* Wait for processes to go away */ 331 usb_detach_wait(&sc->sc_dev); 332 } 333 334 if (ifp->if_flags & IFF_RUNNING) 335 url_stop(GET_IFP(sc), 1); 336 337 mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY); 338 ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY); 339 if (ifp->if_softc != NULL) { 340 ether_ifdetach(ifp); 341 if_detach(ifp); 342 } 343 344 #ifdef DIAGNOSTIC 345 if (sc->sc_pipe_tx != NULL) 346 printf("%s: detach has active tx endpoint.\n", 347 sc->sc_dev.dv_xname); 348 if (sc->sc_pipe_rx != NULL) 349 printf("%s: detach has active rx endpoint.\n", 350 sc->sc_dev.dv_xname); 351 if (sc->sc_pipe_intr != NULL) 352 printf("%s: detach has active intr endpoint.\n", 353 sc->sc_dev.dv_xname); 354 #endif 355 356 splx(s); 357 358 return (0); 359 } 360 361 /* read/write memory */ 362 int 363 url_mem(struct url_softc *sc, int cmd, int offset, void *buf, int len) 364 { 365 usb_device_request_t req; 366 usbd_status err; 367 368 if (sc == NULL) 369 return (0); 370 371 DPRINTFN(0x200, 372 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 373 374 if (usbd_is_dying(sc->sc_udev)) 375 return (0); 376 377 if (cmd == URL_CMD_READMEM) 378 req.bmRequestType = UT_READ_VENDOR_DEVICE; 379 else 380 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 381 req.bRequest = URL_REQ_MEM; 382 USETW(req.wValue, offset); 383 USETW(req.wIndex, 0x0000); 384 USETW(req.wLength, len); 385 386 sc->sc_refcnt++; 387 err = usbd_do_request(sc->sc_udev, &req, buf); 388 if (--sc->sc_refcnt < 0) 389 usb_detach_wakeup(&sc->sc_dev); 390 if (err) { 391 DPRINTF(("%s: url_mem(): %s failed. off=%04x, err=%d\n", 392 sc->sc_dev.dv_xname, 393 cmd == URL_CMD_READMEM ? "read" : "write", 394 offset, err)); 395 } 396 397 return (err); 398 } 399 400 /* read 1byte from register */ 401 int 402 url_csr_read_1(struct url_softc *sc, int reg) 403 { 404 u_int8_t val = 0; 405 406 DPRINTFN(0x100, 407 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 408 409 return (url_mem(sc, URL_CMD_READMEM, reg, &val, 1) ? 0 : val); 410 } 411 412 /* read 2bytes from register */ 413 int 414 url_csr_read_2(struct url_softc *sc, int reg) 415 { 416 uWord val; 417 418 DPRINTFN(0x100, 419 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 420 421 USETW(val, 0); 422 return (url_mem(sc, URL_CMD_READMEM, reg, &val, 2) ? 0 : UGETW(val)); 423 } 424 425 /* write 1byte to register */ 426 int 427 url_csr_write_1(struct url_softc *sc, int reg, int aval) 428 { 429 u_int8_t val = aval; 430 431 DPRINTFN(0x100, 432 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 433 434 return (url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 1) ? -1 : 0); 435 } 436 437 /* write 2bytes to register */ 438 int 439 url_csr_write_2(struct url_softc *sc, int reg, int aval) 440 { 441 uWord val; 442 443 DPRINTFN(0x100, 444 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 445 446 USETW(val, aval); 447 448 return (url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 2) ? -1 : 0); 449 } 450 451 /* write 4bytes to register */ 452 int 453 url_csr_write_4(struct url_softc *sc, int reg, int aval) 454 { 455 uDWord val; 456 457 DPRINTFN(0x100, 458 ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 459 460 USETDW(val, aval); 461 462 return (url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 4) ? -1 : 0); 463 } 464 465 int 466 url_init(struct ifnet *ifp) 467 { 468 struct url_softc *sc = ifp->if_softc; 469 struct mii_data *mii = GET_MII(sc); 470 u_char *eaddr; 471 int i, s; 472 473 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 474 475 s = splnet(); 476 477 /* Cancel pending I/O and free all TX/RX buffers */ 478 url_stop(ifp, 1); 479 480 eaddr = sc->sc_ac.ac_enaddr; 481 for (i = 0; i < ETHER_ADDR_LEN; i++) 482 url_csr_write_1(sc, URL_IDR0 + i, eaddr[i]); 483 484 /* Init transmission control register */ 485 URL_CLRBIT(sc, URL_TCR, 486 URL_TCR_TXRR1 | URL_TCR_TXRR0 | 487 URL_TCR_IFG1 | URL_TCR_IFG0 | 488 URL_TCR_NOCRC); 489 490 /* Init receive control register */ 491 URL_SETBIT2(sc, URL_RCR, URL_RCR_TAIL); 492 493 /* Initialize transmit ring */ 494 if (url_tx_list_init(sc) == ENOBUFS) { 495 printf("%s: tx list init failed\n", sc->sc_dev.dv_xname); 496 splx(s); 497 return (EIO); 498 } 499 500 /* Initialize receive ring */ 501 if (url_rx_list_init(sc) == ENOBUFS) { 502 printf("%s: rx list init failed\n", sc->sc_dev.dv_xname); 503 splx(s); 504 return (EIO); 505 } 506 507 /* Program promiscuous mode and multicast filters */ 508 url_iff(sc); 509 510 /* Enable RX and TX */ 511 URL_SETBIT(sc, URL_CR, URL_CR_TE | URL_CR_RE); 512 513 mii_mediachg(mii); 514 515 if (sc->sc_pipe_tx == NULL || sc->sc_pipe_rx == NULL) { 516 if (url_openpipes(sc)) { 517 splx(s); 518 return (EIO); 519 } 520 } 521 522 ifp->if_flags |= IFF_RUNNING; 523 ifq_clr_oactive(&ifp->if_snd); 524 525 splx(s); 526 527 timeout_add_sec(&sc->sc_stat_ch, 1); 528 529 return (0); 530 } 531 532 void 533 url_reset(struct url_softc *sc) 534 { 535 int i; 536 537 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 538 539 if (usbd_is_dying(sc->sc_udev)) 540 return; 541 542 URL_SETBIT(sc, URL_CR, URL_CR_SOFT_RST); 543 544 for (i = 0; i < URL_TX_TIMEOUT; i++) { 545 if (!(url_csr_read_1(sc, URL_CR) & URL_CR_SOFT_RST)) 546 break; 547 delay(10); /* XXX */ 548 } 549 550 delay(10000); /* XXX */ 551 } 552 553 void 554 url_iff(struct url_softc *sc) 555 { 556 struct ifnet *ifp = GET_IFP(sc); 557 struct arpcom *ac = &sc->sc_ac; 558 struct ether_multi *enm; 559 struct ether_multistep step; 560 u_int32_t hashes[2]; 561 u_int16_t rcr; 562 int h = 0; 563 564 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 565 566 if (usbd_is_dying(sc->sc_udev)) 567 return; 568 569 rcr = url_csr_read_2(sc, URL_RCR); 570 rcr &= ~(URL_RCR_AAM | URL_RCR_AAP | URL_RCR_AB | URL_RCR_AD | 571 URL_RCR_AM); 572 bzero(hashes, sizeof(hashes)); 573 ifp->if_flags &= ~IFF_ALLMULTI; 574 575 /* 576 * Always accept broadcast frames. 577 * Always accept frames destined to our station address. 578 */ 579 rcr |= URL_RCR_AB | URL_RCR_AD; 580 581 if (ifp->if_flags & IFF_PROMISC || ac->ac_multirangecnt > 0) { 582 ifp->if_flags |= IFF_ALLMULTI; 583 rcr |= URL_RCR_AAM; 584 if (ifp->if_flags & IFF_PROMISC) 585 rcr |= URL_RCR_AAP; 586 } else { 587 rcr |= URL_RCR_AM; 588 589 /* now program new ones */ 590 ETHER_FIRST_MULTI(step, ac, enm); 591 while (enm != NULL) { 592 h = ether_crc32_be(enm->enm_addrlo, 593 ETHER_ADDR_LEN) >> 26; 594 595 if (h < 32) 596 hashes[0] |= (1 << h); 597 else 598 hashes[1] |= (1 << (h - 32)); 599 600 ETHER_NEXT_MULTI(step, enm); 601 } 602 } 603 604 url_csr_write_4(sc, URL_MAR0, hashes[0]); 605 url_csr_write_4(sc, URL_MAR4, hashes[1]); 606 url_csr_write_2(sc, URL_RCR, rcr); 607 } 608 609 int 610 url_openpipes(struct url_softc *sc) 611 { 612 struct url_chain *c; 613 usbd_status err; 614 int i; 615 int error = 0; 616 617 if (usbd_is_dying(sc->sc_udev)) 618 return (EIO); 619 620 sc->sc_refcnt++; 621 622 /* Open RX pipe */ 623 err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkin_no, 624 USBD_EXCLUSIVE_USE, &sc->sc_pipe_rx); 625 if (err) { 626 printf("%s: open rx pipe failed: %s\n", 627 sc->sc_dev.dv_xname, usbd_errstr(err)); 628 error = EIO; 629 goto done; 630 } 631 632 /* Open TX pipe */ 633 err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkout_no, 634 USBD_EXCLUSIVE_USE, &sc->sc_pipe_tx); 635 if (err) { 636 printf("%s: open tx pipe failed: %s\n", 637 sc->sc_dev.dv_xname, usbd_errstr(err)); 638 error = EIO; 639 goto done; 640 } 641 642 #if 0 643 /* XXX: interrupt endpoint is not yet supported */ 644 /* Open Interrupt pipe */ 645 err = usbd_open_pipe_intr(sc->sc_ctl_iface, sc->sc_intrin_no, 646 USBD_EXCLUSIVE_USE, &sc->sc_pipe_intr, sc, 647 &sc->sc_cdata.url_ibuf, URL_INTR_PKGLEN, 648 url_intr, URL_INTR_INTERVAL); 649 if (err) { 650 printf("%s: open intr pipe failed: %s\n", 651 sc->sc_dev.dv_xname, usbd_errstr(err)); 652 error = EIO; 653 goto done; 654 } 655 #endif 656 657 658 /* Start up the receive pipe. */ 659 for (i = 0; i < URL_RX_LIST_CNT; i++) { 660 c = &sc->sc_cdata.url_rx_chain[i]; 661 usbd_setup_xfer(c->url_xfer, sc->sc_pipe_rx, 662 c, c->url_buf, URL_BUFSZ, 663 USBD_SHORT_XFER_OK | USBD_NO_COPY, 664 USBD_NO_TIMEOUT, url_rxeof); 665 (void)usbd_transfer(c->url_xfer); 666 DPRINTF(("%s: %s: start read\n", sc->sc_dev.dv_xname, 667 __func__)); 668 } 669 670 done: 671 if (--sc->sc_refcnt < 0) 672 usb_detach_wakeup(&sc->sc_dev); 673 674 return (error); 675 } 676 677 int 678 url_newbuf(struct url_softc *sc, struct url_chain *c, struct mbuf *m) 679 { 680 struct mbuf *m_new = NULL; 681 682 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 683 684 if (m == NULL) { 685 MGETHDR(m_new, M_DONTWAIT, MT_DATA); 686 if (m_new == NULL) { 687 printf("%s: no memory for rx list " 688 "-- packet dropped!\n", sc->sc_dev.dv_xname); 689 return (ENOBUFS); 690 } 691 MCLGET(m_new, M_DONTWAIT); 692 if (!(m_new->m_flags & M_EXT)) { 693 printf("%s: no memory for rx list " 694 "-- packet dropped!\n", sc->sc_dev.dv_xname); 695 m_freem(m_new); 696 return (ENOBUFS); 697 } 698 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 699 } else { 700 m_new = m; 701 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 702 m_new->m_data = m_new->m_ext.ext_buf; 703 } 704 705 m_adj(m_new, ETHER_ALIGN); 706 c->url_mbuf = m_new; 707 708 return (0); 709 } 710 711 712 int 713 url_rx_list_init(struct url_softc *sc) 714 { 715 struct url_cdata *cd; 716 struct url_chain *c; 717 int i; 718 719 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 720 721 cd = &sc->sc_cdata; 722 for (i = 0; i < URL_RX_LIST_CNT; i++) { 723 c = &cd->url_rx_chain[i]; 724 c->url_sc = sc; 725 c->url_idx = i; 726 if (url_newbuf(sc, c, NULL) == ENOBUFS) 727 return (ENOBUFS); 728 if (c->url_xfer == NULL) { 729 c->url_xfer = usbd_alloc_xfer(sc->sc_udev); 730 if (c->url_xfer == NULL) 731 return (ENOBUFS); 732 c->url_buf = usbd_alloc_buffer(c->url_xfer, URL_BUFSZ); 733 if (c->url_buf == NULL) { 734 usbd_free_xfer(c->url_xfer); 735 return (ENOBUFS); 736 } 737 } 738 } 739 740 return (0); 741 } 742 743 int 744 url_tx_list_init(struct url_softc *sc) 745 { 746 struct url_cdata *cd; 747 struct url_chain *c; 748 int i; 749 750 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 751 752 cd = &sc->sc_cdata; 753 for (i = 0; i < URL_TX_LIST_CNT; i++) { 754 c = &cd->url_tx_chain[i]; 755 c->url_sc = sc; 756 c->url_idx = i; 757 c->url_mbuf = NULL; 758 if (c->url_xfer == NULL) { 759 c->url_xfer = usbd_alloc_xfer(sc->sc_udev); 760 if (c->url_xfer == NULL) 761 return (ENOBUFS); 762 c->url_buf = usbd_alloc_buffer(c->url_xfer, URL_BUFSZ); 763 if (c->url_buf == NULL) { 764 usbd_free_xfer(c->url_xfer); 765 return (ENOBUFS); 766 } 767 } 768 } 769 770 return (0); 771 } 772 773 void 774 url_start(struct ifnet *ifp) 775 { 776 struct url_softc *sc = ifp->if_softc; 777 struct mbuf *m_head = NULL; 778 779 DPRINTF(("%s: %s: enter, link=%d\n", sc->sc_dev.dv_xname, 780 __func__, sc->sc_link)); 781 782 if (usbd_is_dying(sc->sc_udev)) 783 return; 784 785 if (!sc->sc_link) 786 return; 787 788 if (ifq_is_oactive(&ifp->if_snd)) 789 return; 790 791 m_head = ifq_deq_begin(&ifp->if_snd); 792 if (m_head == NULL) 793 return; 794 795 if (url_send(sc, m_head, 0)) { 796 ifq_deq_rollback(&ifp->if_snd, m_head); 797 ifq_set_oactive(&ifp->if_snd); 798 return; 799 } 800 801 ifq_deq_commit(&ifp->if_snd, m_head); 802 803 #if NBPFILTER > 0 804 if (ifp->if_bpf) 805 bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT); 806 #endif 807 808 ifq_set_oactive(&ifp->if_snd); 809 810 /* Set a timeout in case the chip goes out to lunch. */ 811 ifp->if_timer = 5; 812 } 813 814 int 815 url_send(struct url_softc *sc, struct mbuf *m, int idx) 816 { 817 int total_len; 818 struct url_chain *c; 819 usbd_status err; 820 821 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__)); 822 823 c = &sc->sc_cdata.url_tx_chain[idx]; 824 825 /* Copy the mbuf data into a contiguous buffer */ 826 m_copydata(m, 0, m->m_pkthdr.len, c->url_buf); 827 c->url_mbuf = m; 828 total_len = m->m_pkthdr.len; 829 830 if (total_len < URL_MIN_FRAME_LEN) { 831 bzero(c->url_buf + total_len, URL_MIN_FRAME_LEN - total_len); 832 total_len = URL_MIN_FRAME_LEN; 833 } 834 usbd_setup_xfer(c->url_xfer, sc->sc_pipe_tx, c, c->url_buf, total_len, 835 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 836 URL_TX_TIMEOUT, url_txeof); 837 838 /* Transmit */ 839 sc->sc_refcnt++; 840 err = usbd_transfer(c->url_xfer); 841 if (--sc->sc_refcnt < 0) 842 usb_detach_wakeup(&sc->sc_dev); 843 if (err != USBD_IN_PROGRESS) { 844 printf("%s: url_send error=%s\n", sc->sc_dev.dv_xname, 845 usbd_errstr(err)); 846 /* Stop the interface */ 847 usb_add_task(sc->sc_udev, &sc->sc_stop_task); 848 return (EIO); 849 } 850 851 DPRINTF(("%s: %s: send %d bytes\n", sc->sc_dev.dv_xname, 852 __func__, total_len)); 853 854 sc->sc_cdata.url_tx_cnt++; 855 856 return (0); 857 } 858 859 void 860 url_txeof(struct usbd_xfer *xfer, void *priv, usbd_status status) 861 { 862 struct url_chain *c = priv; 863 struct url_softc *sc = c->url_sc; 864 struct ifnet *ifp = GET_IFP(sc); 865 int s; 866 867 if (usbd_is_dying(sc->sc_udev)) 868 return; 869 870 s = splnet(); 871 872 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 873 874 ifp->if_timer = 0; 875 ifq_clr_oactive(&ifp->if_snd); 876 877 if (status != USBD_NORMAL_COMPLETION) { 878 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { 879 splx(s); 880 return; 881 } 882 ifp->if_oerrors++; 883 printf("%s: usb error on tx: %s\n", sc->sc_dev.dv_xname, 884 usbd_errstr(status)); 885 if (status == USBD_STALLED) { 886 sc->sc_refcnt++; 887 usbd_clear_endpoint_stall_async(sc->sc_pipe_tx); 888 if (--sc->sc_refcnt < 0) 889 usb_detach_wakeup(&sc->sc_dev); 890 } 891 splx(s); 892 return; 893 } 894 895 ifp->if_opackets++; 896 897 m_freem(c->url_mbuf); 898 c->url_mbuf = NULL; 899 900 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 901 url_start(ifp); 902 903 splx(s); 904 } 905 906 void 907 url_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status) 908 { 909 struct url_chain *c = priv; 910 struct url_softc *sc = c->url_sc; 911 struct ifnet *ifp = GET_IFP(sc); 912 struct mbuf_list ml = MBUF_LIST_INITIALIZER(); 913 struct mbuf *m; 914 u_int32_t total_len; 915 url_rxhdr_t rxhdr; 916 int s; 917 918 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__)); 919 920 if (usbd_is_dying(sc->sc_udev)) 921 return; 922 923 if (status != USBD_NORMAL_COMPLETION) { 924 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 925 return; 926 sc->sc_rx_errs++; 927 if (usbd_ratecheck(&sc->sc_rx_notice)) { 928 printf("%s: %u usb errors on rx: %s\n", 929 sc->sc_dev.dv_xname, sc->sc_rx_errs, 930 usbd_errstr(status)); 931 sc->sc_rx_errs = 0; 932 } 933 if (status == USBD_STALLED) { 934 sc->sc_refcnt++; 935 usbd_clear_endpoint_stall_async(sc->sc_pipe_rx); 936 if (--sc->sc_refcnt < 0) 937 usb_detach_wakeup(&sc->sc_dev); 938 } 939 goto done; 940 } 941 942 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL); 943 944 memcpy(mtod(c->url_mbuf, char *), c->url_buf, total_len); 945 946 if (total_len <= ETHER_CRC_LEN) { 947 ifp->if_ierrors++; 948 goto done; 949 } 950 951 memcpy(&rxhdr, c->url_buf + total_len - ETHER_CRC_LEN, sizeof(rxhdr)); 952 953 DPRINTF(("%s: RX Status: %dbytes%s%s%s%s packets\n", 954 sc->sc_dev.dv_xname, 955 UGETW(rxhdr) & URL_RXHDR_BYTEC_MASK, 956 UGETW(rxhdr) & URL_RXHDR_VALID_MASK ? ", Valid" : "", 957 UGETW(rxhdr) & URL_RXHDR_RUNTPKT_MASK ? ", Runt" : "", 958 UGETW(rxhdr) & URL_RXHDR_PHYPKT_MASK ? ", Physical match" : "", 959 UGETW(rxhdr) & URL_RXHDR_MCASTPKT_MASK ? ", Multicast" : "")); 960 961 if ((UGETW(rxhdr) & URL_RXHDR_VALID_MASK) == 0) { 962 ifp->if_ierrors++; 963 goto done; 964 } 965 966 total_len -= ETHER_CRC_LEN; 967 968 m = c->url_mbuf; 969 m->m_pkthdr.len = m->m_len = total_len; 970 ml_enqueue(&ml, m); 971 972 if (url_newbuf(sc, c, NULL) == ENOBUFS) { 973 ifp->if_ierrors++; 974 goto done; 975 } 976 977 DPRINTF(("%s: %s: deliver %d\n", sc->sc_dev.dv_xname, 978 __func__, m->m_len)); 979 980 s = splnet(); 981 if_input(ifp, &ml); 982 splx(s); 983 984 done: 985 /* Setup new transfer */ 986 usbd_setup_xfer(xfer, sc->sc_pipe_rx, c, c->url_buf, URL_BUFSZ, 987 USBD_SHORT_XFER_OK | USBD_NO_COPY, 988 USBD_NO_TIMEOUT, url_rxeof); 989 sc->sc_refcnt++; 990 usbd_transfer(xfer); 991 if (--sc->sc_refcnt < 0) 992 usb_detach_wakeup(&sc->sc_dev); 993 994 DPRINTF(("%s: %s: start rx\n", sc->sc_dev.dv_xname, __func__)); 995 } 996 997 int 998 url_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 999 { 1000 struct url_softc *sc = ifp->if_softc; 1001 struct ifreq *ifr = (struct ifreq *)data; 1002 int s, error = 0; 1003 1004 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1005 1006 if (usbd_is_dying(sc->sc_udev)) 1007 return (EIO); 1008 1009 s = splnet(); 1010 1011 switch (cmd) { 1012 case SIOCSIFADDR: 1013 ifp->if_flags |= IFF_UP; 1014 if (!(ifp->if_flags & IFF_RUNNING)) 1015 url_init(ifp); 1016 break; 1017 1018 case SIOCSIFFLAGS: 1019 if (ifp->if_flags & IFF_UP) { 1020 if (ifp->if_flags & IFF_RUNNING) 1021 error = ENETRESET; 1022 else 1023 url_init(ifp); 1024 } else { 1025 if (ifp->if_flags & IFF_RUNNING) 1026 url_stop(ifp, 1); 1027 } 1028 break; 1029 1030 case SIOCGIFMEDIA: 1031 case SIOCSIFMEDIA: 1032 error = ifmedia_ioctl(ifp, ifr, &sc->sc_mii.mii_media, cmd); 1033 break; 1034 1035 default: 1036 error = ether_ioctl(ifp, &sc->sc_ac, cmd, data); 1037 } 1038 1039 if (error == ENETRESET) { 1040 if (ifp->if_flags & IFF_RUNNING) 1041 url_iff(sc); 1042 error = 0; 1043 } 1044 1045 splx(s); 1046 return (error); 1047 } 1048 1049 void 1050 url_watchdog(struct ifnet *ifp) 1051 { 1052 struct url_softc *sc = ifp->if_softc; 1053 struct url_chain *c; 1054 usbd_status stat; 1055 int s; 1056 1057 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1058 1059 ifp->if_oerrors++; 1060 printf("%s: watchdog timeout\n", sc->sc_dev.dv_xname); 1061 1062 s = splusb(); 1063 c = &sc->sc_cdata.url_tx_chain[0]; 1064 usbd_get_xfer_status(c->url_xfer, NULL, NULL, NULL, &stat); 1065 url_txeof(c->url_xfer, c, stat); 1066 1067 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 1068 url_start(ifp); 1069 splx(s); 1070 } 1071 1072 void 1073 url_stop_task(struct url_softc *sc) 1074 { 1075 url_stop(GET_IFP(sc), 1); 1076 } 1077 1078 /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */ 1079 void 1080 url_stop(struct ifnet *ifp, int disable) 1081 { 1082 struct url_softc *sc = ifp->if_softc; 1083 usbd_status err; 1084 int i; 1085 1086 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1087 1088 ifp->if_timer = 0; 1089 ifp->if_flags &= ~IFF_RUNNING; 1090 ifq_clr_oactive(&ifp->if_snd); 1091 1092 url_reset(sc); 1093 1094 timeout_del(&sc->sc_stat_ch); 1095 1096 /* Stop transfers */ 1097 /* RX endpoint */ 1098 if (sc->sc_pipe_rx != NULL) { 1099 usbd_abort_pipe(sc->sc_pipe_rx); 1100 err = usbd_close_pipe(sc->sc_pipe_rx); 1101 if (err) 1102 printf("%s: close rx pipe failed: %s\n", 1103 sc->sc_dev.dv_xname, usbd_errstr(err)); 1104 sc->sc_pipe_rx = NULL; 1105 } 1106 1107 /* TX endpoint */ 1108 if (sc->sc_pipe_tx != NULL) { 1109 usbd_abort_pipe(sc->sc_pipe_tx); 1110 err = usbd_close_pipe(sc->sc_pipe_tx); 1111 if (err) 1112 printf("%s: close tx pipe failed: %s\n", 1113 sc->sc_dev.dv_xname, usbd_errstr(err)); 1114 sc->sc_pipe_tx = NULL; 1115 } 1116 1117 #if 0 1118 /* XXX: Interrupt endpoint is not yet supported!! */ 1119 /* Interrupt endpoint */ 1120 if (sc->sc_pipe_intr != NULL) { 1121 usbd_abort_pipe(sc->sc_pipe_intr); 1122 err = usbd_close_pipe(sc->sc_pipe_intr); 1123 if (err) 1124 printf("%s: close intr pipe failed: %s\n", 1125 sc->sc_dev.dv_xname, usbd_errstr(err)); 1126 sc->sc_pipe_intr = NULL; 1127 } 1128 #endif 1129 1130 /* Free RX resources. */ 1131 for (i = 0; i < URL_RX_LIST_CNT; i++) { 1132 if (sc->sc_cdata.url_rx_chain[i].url_mbuf != NULL) { 1133 m_freem(sc->sc_cdata.url_rx_chain[i].url_mbuf); 1134 sc->sc_cdata.url_rx_chain[i].url_mbuf = NULL; 1135 } 1136 if (sc->sc_cdata.url_rx_chain[i].url_xfer != NULL) { 1137 usbd_free_xfer(sc->sc_cdata.url_rx_chain[i].url_xfer); 1138 sc->sc_cdata.url_rx_chain[i].url_xfer = NULL; 1139 } 1140 } 1141 1142 /* Free TX resources. */ 1143 for (i = 0; i < URL_TX_LIST_CNT; i++) { 1144 if (sc->sc_cdata.url_tx_chain[i].url_mbuf != NULL) { 1145 m_freem(sc->sc_cdata.url_tx_chain[i].url_mbuf); 1146 sc->sc_cdata.url_tx_chain[i].url_mbuf = NULL; 1147 } 1148 if (sc->sc_cdata.url_tx_chain[i].url_xfer != NULL) { 1149 usbd_free_xfer(sc->sc_cdata.url_tx_chain[i].url_xfer); 1150 sc->sc_cdata.url_tx_chain[i].url_xfer = NULL; 1151 } 1152 } 1153 1154 sc->sc_link = 0; 1155 } 1156 1157 /* Set media options */ 1158 int 1159 url_ifmedia_change(struct ifnet *ifp) 1160 { 1161 struct url_softc *sc = ifp->if_softc; 1162 struct mii_data *mii = GET_MII(sc); 1163 1164 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1165 1166 if (usbd_is_dying(sc->sc_udev)) 1167 return (0); 1168 1169 sc->sc_link = 0; 1170 if (mii->mii_instance) { 1171 struct mii_softc *miisc; 1172 for (miisc = LIST_FIRST(&mii->mii_phys); miisc != NULL; 1173 miisc = LIST_NEXT(miisc, mii_list)) 1174 mii_phy_reset(miisc); 1175 } 1176 1177 return (mii_mediachg(mii)); 1178 } 1179 1180 /* Report current media status. */ 1181 void 1182 url_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr) 1183 { 1184 struct url_softc *sc = ifp->if_softc; 1185 struct mii_data *mii = GET_MII(sc); 1186 1187 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1188 1189 if (usbd_is_dying(sc->sc_udev)) 1190 return; 1191 1192 if ((ifp->if_flags & IFF_RUNNING) == 0) { 1193 ifmr->ifm_active = IFM_ETHER | IFM_NONE; 1194 ifmr->ifm_status = 0; 1195 return; 1196 } 1197 1198 mii_pollstat(mii); 1199 ifmr->ifm_active = mii->mii_media_active; 1200 ifmr->ifm_status = mii->mii_media_status; 1201 } 1202 1203 void 1204 url_tick(void *xsc) 1205 { 1206 struct url_softc *sc = xsc; 1207 1208 if (sc == NULL) 1209 return; 1210 1211 DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname, 1212 __func__)); 1213 1214 if (usbd_is_dying(sc->sc_udev)) 1215 return; 1216 1217 /* Perform periodic stuff in process context */ 1218 usb_add_task(sc->sc_udev, &sc->sc_tick_task); 1219 } 1220 1221 void 1222 url_tick_task(void *xsc) 1223 { 1224 struct url_softc *sc = xsc; 1225 struct ifnet *ifp; 1226 struct mii_data *mii; 1227 int s; 1228 1229 if (sc == NULL) 1230 return; 1231 1232 DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname, 1233 __func__)); 1234 1235 if (usbd_is_dying(sc->sc_udev)) 1236 return; 1237 1238 ifp = GET_IFP(sc); 1239 mii = GET_MII(sc); 1240 1241 if (mii == NULL) 1242 return; 1243 1244 s = splnet(); 1245 1246 mii_tick(mii); 1247 if (!sc->sc_link && mii->mii_media_status & IFM_ACTIVE && 1248 IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { 1249 DPRINTF(("%s: %s: got link\n", 1250 sc->sc_dev.dv_xname, __func__)); 1251 sc->sc_link++; 1252 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 1253 url_start(ifp); 1254 } 1255 1256 timeout_add_sec(&sc->sc_stat_ch, 1); 1257 1258 splx(s); 1259 } 1260 1261 /* Get exclusive access to the MII registers */ 1262 void 1263 url_lock_mii(struct url_softc *sc) 1264 { 1265 DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname, 1266 __func__)); 1267 1268 sc->sc_refcnt++; 1269 rw_enter_write(&sc->sc_mii_lock); 1270 } 1271 1272 void 1273 url_unlock_mii(struct url_softc *sc) 1274 { 1275 DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname, 1276 __func__)); 1277 1278 rw_exit_write(&sc->sc_mii_lock); 1279 if (--sc->sc_refcnt < 0) 1280 usb_detach_wakeup(&sc->sc_dev); 1281 } 1282 1283 int 1284 url_int_miibus_readreg(struct device *dev, int phy, int reg) 1285 { 1286 struct url_softc *sc; 1287 u_int16_t val; 1288 1289 if (dev == NULL) 1290 return (0); 1291 1292 sc = (void *)dev; 1293 1294 DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x\n", 1295 sc->sc_dev.dv_xname, __func__, phy, reg)); 1296 1297 if (usbd_is_dying(sc->sc_udev)) { 1298 #ifdef DIAGNOSTIC 1299 printf("%s: %s: dying\n", sc->sc_dev.dv_xname, 1300 __func__); 1301 #endif 1302 return (0); 1303 } 1304 1305 /* XXX: one PHY only for the RTL8150 internal PHY */ 1306 if (phy != 0) { 1307 DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n", 1308 sc->sc_dev.dv_xname, __func__, phy)); 1309 return (0); 1310 } 1311 1312 url_lock_mii(sc); 1313 1314 switch (reg) { 1315 case MII_BMCR: /* Control Register */ 1316 reg = URL_BMCR; 1317 break; 1318 case MII_BMSR: /* Status Register */ 1319 reg = URL_BMSR; 1320 break; 1321 case MII_PHYIDR1: 1322 case MII_PHYIDR2: 1323 val = 0; 1324 goto R_DONE; 1325 break; 1326 case MII_ANAR: /* Autonegotiation advertisement */ 1327 reg = URL_ANAR; 1328 break; 1329 case MII_ANLPAR: /* Autonegotiation link partner abilities */ 1330 reg = URL_ANLP; 1331 break; 1332 case URLPHY_MSR: /* Media Status Register */ 1333 reg = URL_MSR; 1334 break; 1335 default: 1336 printf("%s: %s: bad register %04x\n", 1337 sc->sc_dev.dv_xname, __func__, reg); 1338 val = 0; 1339 goto R_DONE; 1340 break; 1341 } 1342 1343 if (reg == URL_MSR) 1344 val = url_csr_read_1(sc, reg); 1345 else 1346 val = url_csr_read_2(sc, reg); 1347 1348 R_DONE: 1349 DPRINTFN(0xff, ("%s: %s: phy=%d reg=0x%04x => 0x%04x\n", 1350 sc->sc_dev.dv_xname, __func__, phy, reg, val)); 1351 1352 url_unlock_mii(sc); 1353 return (val); 1354 } 1355 1356 void 1357 url_int_miibus_writereg(struct device *dev, int phy, int reg, int data) 1358 { 1359 struct url_softc *sc; 1360 1361 if (dev == NULL) 1362 return; 1363 1364 sc = (void *)dev; 1365 1366 DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x data=0x%04x\n", 1367 sc->sc_dev.dv_xname, __func__, phy, reg, data)); 1368 1369 if (usbd_is_dying(sc->sc_udev)) { 1370 #ifdef DIAGNOSTIC 1371 printf("%s: %s: dying\n", sc->sc_dev.dv_xname, 1372 __func__); 1373 #endif 1374 return; 1375 } 1376 1377 /* XXX: one PHY only for the RTL8150 internal PHY */ 1378 if (phy != 0) { 1379 DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n", 1380 sc->sc_dev.dv_xname, __func__, phy)); 1381 return; 1382 } 1383 1384 url_lock_mii(sc); 1385 1386 switch (reg) { 1387 case MII_BMCR: /* Control Register */ 1388 reg = URL_BMCR; 1389 break; 1390 case MII_BMSR: /* Status Register */ 1391 reg = URL_BMSR; 1392 break; 1393 case MII_PHYIDR1: 1394 case MII_PHYIDR2: 1395 goto W_DONE; 1396 break; 1397 case MII_ANAR: /* Autonegotiation advertisement */ 1398 reg = URL_ANAR; 1399 break; 1400 case MII_ANLPAR: /* Autonegotiation link partner abilities */ 1401 reg = URL_ANLP; 1402 break; 1403 case URLPHY_MSR: /* Media Status Register */ 1404 reg = URL_MSR; 1405 break; 1406 default: 1407 printf("%s: %s: bad register %04x\n", 1408 sc->sc_dev.dv_xname, __func__, reg); 1409 goto W_DONE; 1410 break; 1411 } 1412 1413 if (reg == URL_MSR) 1414 url_csr_write_1(sc, reg, data); 1415 else 1416 url_csr_write_2(sc, reg, data); 1417 W_DONE: 1418 1419 url_unlock_mii(sc); 1420 return; 1421 } 1422 1423 void 1424 url_miibus_statchg(struct device *dev) 1425 { 1426 #ifdef URL_DEBUG 1427 struct url_softc *sc; 1428 1429 if (dev == NULL) 1430 return; 1431 1432 sc = (void *)dev; 1433 DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__)); 1434 #endif 1435 /* Nothing to do */ 1436 } 1437 1438 #if 0 1439 /* 1440 * external PHYs support, but not test. 1441 */ 1442 int 1443 url_ext_miibus_redreg(struct device *dev, int phy, int reg) 1444 { 1445 struct url_softc *sc = (void *)dev; 1446 u_int16_t val; 1447 1448 DPRINTF(("%s: %s: enter, phy=%d reg=0x%04x\n", 1449 sc->sc_dev.dv_xname, __func__, phy, reg)); 1450 1451 if (usbd_is_dying(sc->sc_udev)) { 1452 #ifdef DIAGNOSTIC 1453 printf("%s: %s: dying\n", sc->sc_dev.dv_xname, 1454 __func__); 1455 #endif 1456 return (0); 1457 } 1458 1459 url_lock_mii(sc); 1460 1461 url_csr_write_1(sc, URL_PHYADD, phy & URL_PHYADD_MASK); 1462 /* 1463 * RTL8150L will initiate a MII management data transaction 1464 * if PHYCNT_OWN bit is set 1 by software. After transaction, 1465 * this bit is auto cleared by TRL8150L. 1466 */ 1467 url_csr_write_1(sc, URL_PHYCNT, 1468 (reg | URL_PHYCNT_PHYOWN) & ~URL_PHYCNT_RWCR); 1469 for (i = 0; i < URL_TIMEOUT; i++) { 1470 if ((url_csr_read_1(sc, URL_PHYCNT) & URL_PHYCNT_PHYOWN) == 0) 1471 break; 1472 } 1473 if (i == URL_TIMEOUT) { 1474 printf("%s: MII read timed out\n", sc->sc_dev.dv_xname); 1475 } 1476 1477 val = url_csr_read_2(sc, URL_PHYDAT); 1478 1479 DPRINTF(("%s: %s: phy=%d reg=0x%04x => 0x%04x\n", 1480 sc->sc_dev.dv_xname, __func__, phy, reg, val)); 1481 1482 url_unlock_mii(sc); 1483 return (val); 1484 } 1485 1486 void 1487 url_ext_miibus_writereg(struct device *dev, int phy, int reg, int data) 1488 { 1489 struct url_softc *sc = (void *)dev; 1490 1491 DPRINTF(("%s: %s: enter, phy=%d reg=0x%04x data=0x%04x\n", 1492 sc->sc_dev.dv_xname, __func__, phy, reg, data)); 1493 1494 if (usbd_is_dying(sc->sc_udev)) { 1495 #ifdef DIAGNOSTIC 1496 printf("%s: %s: dying\n", sc->sc_dev.dv_xname, 1497 __func__); 1498 #endif 1499 return; 1500 } 1501 1502 url_lock_mii(sc); 1503 1504 url_csr_write_2(sc, URL_PHYDAT, data); 1505 url_csr_write_1(sc, URL_PHYADD, phy); 1506 url_csr_write_1(sc, URL_PHYCNT, reg | URL_PHYCNT_RWCR); /* Write */ 1507 1508 for (i=0; i < URL_TIMEOUT; i++) { 1509 if (url_csr_read_1(sc, URL_PHYCNT) & URL_PHYCNT_PHYOWN) 1510 break; 1511 } 1512 1513 if (i == URL_TIMEOUT) { 1514 printf("%s: MII write timed out\n", 1515 sc->sc_dev.dv_xname); 1516 } 1517 1518 url_unlock_mii(sc); 1519 return; 1520 } 1521 #endif 1522 1523