sys/dev/usb/if_udav.c

   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-F01-062202s.pdf
  38  */
  39
  40 /*
  41  * TODO:
  42  *      Interrupt Endpoint support
  43  *      External PHYs
  44  *      powerhook() support?
  45  */
  46
  47 #include <sys/cdefs.h>
  48 __FBSDID("$FreeBSD$");
  49
  50 #include "opt_inet.h"
  51 #if defined(__NetBSD__)
  52 #include "opt_ns.h"
  53 #endif
  54 #if defined(__NetBSD__)
  55 #include "bpfilter.h"
  56 #endif
  57 #if defined(__FreeBSD__)
  58 #define NBPFILTER       1
  59 #endif
  60 #if defined(__NetBSD__)
  61 #include "rnd.h"
  62 #endif
  63
  64 #include <sys/param.h>
  65 #include <sys/systm.h>
  66 #include <sys/lock.h>
  67 #include <sys/mbuf.h>
  68 #include <sys/kernel.h>
  69 #include <sys/socket.h>
  70 #if defined(__FreeBSD__)
  71 #include <sys/types.h>
  72 #include <sys/lockmgr.h>
  73 #include <sys/sockio.h>
  74 #endif
  75
  76 #if defined(__NetBSD__)
  77 #include <sys/device.h>
  78 #endif
  79
  80 #if NRND > 0
  81 #include <sys/rnd.h>
  82 #endif
  83
  84 #include <net/if.h>
  85 #include <net/if_arp.h>
  86 #include <net/if_dl.h>
  87 #include <net/if_media.h>
  88 #include <net/ethernet.h>
  89
  90 #if NBPFILTER > 0
  91 #include <net/bpf.h>
  92 #endif
  93 #if defined(__NetBSD__)
  94 #ifndef BPF_MTAP
  95 #define BPF_MTAP(_ifp, _m)      do {                    \
  96         if ((_ifp)->if_bpf)) {                          \
  97                 bpf_mtap((_ifp)->if_bpf, (_m)) ;        \
  98         }                                               \
  99 } while (0)
 100 #endif
 101 #endif
 102
 103 #if defined(__NetBSD__)
 104 #include <net/if_ether.h>
 105 #ifdef INET
 106 #include <netinet/in.h>
 107 #include <netinet/if_inarp.h>
 108 #endif /* INET */
 109 #elif defined(__FreeBSD__) /* defined(__NetBSD__) */
 110 #include <netinet/in.h>
 111 #include <netinet/if_ether.h>
 112 #endif /* defined(__FreeBSD__) */
 113
 114 #if defined(__NetBSD__)
 115 #ifdef NS
 116 #include <netns/ns.h>
 117 #include <netns/ns_if.h>
 118 #endif
 119 #endif /* defined (__NetBSD__) */
 120
 121 #include <sys/bus.h>
 122 #include <machine/bus.h>
 123 #if __FreeBSD_version < 500000
 124 #include <machine/clock.h>
 125 #endif
 126
 127 #include <dev/mii/mii.h>
 128 #include <dev/mii/miivar.h>
 129
 130 #include <dev/usb/usb.h>
 131 #include <dev/usb/usbdi.h>
 132 #include <dev/usb/usbdi_util.h>
 133 #include <dev/usb/usbdevs.h>
 134 #include <dev/usb/usbdivar.h>
 135 #include <dev/usb/usb_ethersubr.h>
 136
 137 #include <dev/usb/if_udavreg.h>
 138
 139 #if defined(__FreeBSD__)
 140 MODULE_DEPEND(udav, usb, 1, 1, 1);
 141 MODULE_DEPEND(udav, ether, 1, 1, 1);
 142 MODULE_DEPEND(udav, miibus, 1, 1, 1);
 143 #endif
 144
 145 /* "controller miibus0" required.  See GENERIC if you get errors here. */
 146 #include "miibus_if.h"
 147
 148 #if !defined(__FreeBSD__)
 149 /* Function declarations */
 150 USB_DECLARE_DRIVER(udav);
 151 #endif
 152
 153 #if defined(__FreeBSD__)
 154 Static int udav_match(device_ptr_t);
 155 Static int udav_attach(device_ptr_t);
 156 Static int udav_detach(device_ptr_t);
 157 Static void udav_shutdown(device_ptr_t);
 158 #endif
 159
 160 Static int udav_openpipes(struct udav_softc *);
 161 Static int udav_rx_list_init(struct udav_softc *);
 162 Static int udav_tx_list_init(struct udav_softc *);
 163 Static int udav_newbuf(struct udav_softc *, struct udav_chain *, struct mbuf *);
 164 Static void udav_start(struct ifnet *);
 165 Static int udav_send(struct udav_softc *, struct mbuf *, int);
 166 Static void udav_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 167 #if defined(__FreeBSD__)
 168 Static void udav_rxstart(struct ifnet *ifp);
 169 #endif
 170 Static void udav_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
 171 Static void udav_tick(void *);
 172 Static void udav_tick_task(void *);
 173 Static int udav_ioctl(struct ifnet *, u_long, caddr_t);
 174 Static void udav_stop_task(struct udav_softc *);
 175 Static void udav_stop(struct ifnet *, int);
 176 Static void udav_watchdog(struct ifnet *);
 177 Static int udav_ifmedia_change(struct ifnet *);
 178 Static void udav_ifmedia_status(struct ifnet *, struct ifmediareq *);
 179 Static void udav_lock_mii(struct udav_softc *);
 180 Static void udav_unlock_mii(struct udav_softc *);
 181 Static int udav_miibus_readreg(device_ptr_t, int, int);
 182 Static void udav_miibus_writereg(device_ptr_t, int, int, int);
 183 Static void udav_miibus_statchg(device_ptr_t);
 184 #if defined(__NetBSD__)
 185 Static int udav_init(struct ifnet *);
 186 #elif defined(__FreeBSD__)
 187 Static void udav_init(void *);
 188 #endif
 189 Static void udav_setmulti(struct udav_softc *);
 190 Static void udav_reset(struct udav_softc *);
 191
 192 Static int udav_csr_read(struct udav_softc *, int, void *, int);
 193 Static int udav_csr_write(struct udav_softc *, int, void *, int);
 194 Static int udav_csr_read1(struct udav_softc *, int);
 195 Static int udav_csr_write1(struct udav_softc *, int, unsigned char);
 196
 197 #if 0
 198 Static int udav_mem_read(struct udav_softc *, int, void *, int);
 199 Static int udav_mem_write(struct udav_softc *, int, void *, int);
 200 Static int udav_mem_write1(struct udav_softc *, int, unsigned char);
 201 #endif
 202
 203 #if defined(__FreeBSD__)
 204 Static device_method_t udav_methods[] = {
 205         /* Device interface */
 206         DEVMETHOD(device_probe,         udav_match),
 207         DEVMETHOD(device_attach,        udav_attach),
 208         DEVMETHOD(device_detach,        udav_detach),
 209         DEVMETHOD(device_shutdown,      udav_shutdown),
 210
 211         /* bus interface */
 212         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 213         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 214
 215         /* MII interface */
 216         DEVMETHOD(miibus_readreg,       udav_miibus_readreg),
 217         DEVMETHOD(miibus_writereg,      udav_miibus_writereg),
 218         DEVMETHOD(miibus_statchg,       udav_miibus_statchg),
 219
 220         { 0, 0 }
 221 };
 222
 223 Static driver_t udav_driver = {
 224         "udav",
 225         udav_methods,
 226         sizeof(struct udav_softc)
 227 };
 228
 229 Static devclass_t udav_devclass;
 230
 231 DRIVER_MODULE(udav, uhub, udav_driver, udav_devclass, usbd_driver_load, 0);
 232 DRIVER_MODULE(miibus, udav, miibus_driver, miibus_devclass, 0, 0);
 233
 234 #endif /* defined(__FreeBSD__) */
 235
 236 /* Macros */
 237 #ifdef UDAV_DEBUG
 238 #define DPRINTF(x)      if (udavdebug) logprintf x
 239 #define DPRINTFN(n,x)   if (udavdebug >= (n)) logprintf x
 240 int udavdebug = 0;
 241 #else
 242 #define DPRINTF(x)
 243 #define DPRINTFN(n,x)
 244 #endif
 245
 246 #define delay(d)        DELAY(d)
 247
 248 #define UDAV_SETBIT(sc, reg, x) \
 249         udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) | (x))
 250
 251 #define UDAV_CLRBIT(sc, reg, x) \
 252         udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) & ~(x))
 253
 254 static const struct udav_type {
 255         struct usb_devno udav_dev;
 256         u_int16_t udav_flags;
 257 #define UDAV_EXT_PHY    0x0001
 258 } udav_devs [] = {
 259         /* Corega USB-TXC */
 260         {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TXC }, 0},
 261 #if 0
 262         /* DAVICOM DM9601 Generic? */
 263         /*  XXX: The following ids was obtained from the data sheet. */
 264         {{ 0x0a46, 0x9601 }, 0},
 265 #endif
 266 };
 267 #define udav_lookup(v, p) ((const struct udav_type *)usb_lookup(udav_devs, v, p))
 268
 269
 270 /* Probe */
 271 USB_MATCH(udav)
 272 {
 273         USB_MATCH_START(udav, uaa);
 274
 275         if (uaa->iface != NULL)
 276                 return (UMATCH_NONE);
 277
 278         return (udav_lookup(uaa->vendor, uaa->product) != NULL ?
 279                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
 280 }
 281
 282 /* Attach */
 283 USB_ATTACH(udav)
 284 {
 285         USB_ATTACH_START(udav, sc, uaa);
 286         usbd_device_handle dev = uaa->device;
 287         usbd_interface_handle iface;
 288         usbd_status err;
 289         usb_interface_descriptor_t *id;
 290         usb_endpoint_descriptor_t *ed;
 291         char devinfo[1024];
 292         const char *devname ;
 293         struct ifnet *ifp;
 294 #if defined(__NetBSD__)
 295         struct mii_data *mii;
 296 #endif
 297         u_char eaddr[ETHER_ADDR_LEN];
 298         int i;
 299 #if defined(__NetBSD__)
 300         int s;
 301 #endif
 302
 303         bzero(sc, sizeof(struct udav_softc));
 304
 305         usbd_devinfo(dev, 0, devinfo);
 306         USB_ATTACH_SETUP;
 307         devname = USBDEVNAME(sc->sc_dev);
 308         printf("%s: %s\n", devname, devinfo);
 309
 310         /* Move the device into the configured state. */
 311         err = usbd_set_config_no(dev, UDAV_CONFIG_NO, 1);
 312         if (err) {
 313                 printf("%s: setting config no failed\n", devname);
 314                 goto bad;
 315         }
 316
 317         usb_init_task(&sc->sc_tick_task, udav_tick_task, sc);
 318         lockinit(&sc->sc_mii_lock, PZERO, "udavmii", 0, 0);
 319         usb_init_task(&sc->sc_stop_task, (void (*)(void *)) udav_stop_task, sc);
 320
 321         /* get control interface */
 322         err = usbd_device2interface_handle(dev, UDAV_IFACE_INDEX, &iface);
 323         if (err) {
 324                 printf("%s: failed to get interface, err=%s\n", devname,
 325                        usbd_errstr(err));
 326                 goto bad;
 327         }
 328
 329         sc->sc_udev = dev;
 330         sc->sc_ctl_iface = iface;
 331         sc->sc_flags = udav_lookup(uaa->vendor, uaa->product)->udav_flags;
 332
 333         /* get interface descriptor */
 334         id = usbd_get_interface_descriptor(sc->sc_ctl_iface);
 335
 336         /* find endpoints */
 337         sc->sc_bulkin_no = sc->sc_bulkout_no = sc->sc_intrin_no = -1;
 338         for (i = 0; i < id->bNumEndpoints; i++) {
 339                 ed = usbd_interface2endpoint_descriptor(sc->sc_ctl_iface, i);
 340                 if (ed == NULL) {
 341                         printf("%s: couldn't get endpoint %d\n", devname, i);
 342                         goto bad;
 343                 }
 344                 if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 345                     UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 346                         sc->sc_bulkin_no = ed->bEndpointAddress; /* RX */
 347                 else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
 348                          UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT)
 349                         sc->sc_bulkout_no = ed->bEndpointAddress; /* TX */
 350                 else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT &&
 351                          UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
 352                         sc->sc_intrin_no = ed->bEndpointAddress; /* Status */
 353         }
 354
 355         if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1 ||
 356             sc->sc_intrin_no == -1) {
 357                 printf("%s: missing endpoint\n", devname);
 358                 goto bad;
 359         }
 360
 361 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 362         mtx_init(&sc->sc_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK,
 363             MTX_DEF | MTX_RECURSE);
 364 #endif
 365 #if defined(__NetBSD__)
 366         s = splnet();
 367 #elif defined(__FreeBSD__)
 368         UDAV_LOCK(sc);
 369 #endif
 370
 371         /* reset the adapter */
 372         udav_reset(sc);
 373
 374         /* Get Ethernet Address */
 375         err = udav_csr_read(sc, UDAV_PAR, (void *)eaddr, ETHER_ADDR_LEN);
 376         if (err) {
 377                 printf("%s: read MAC address failed\n", devname);
 378 #if defined(__NetBSD__)
 379                 splx(s);
 380 #elif defined(__FreeBSD__)
 381                 UDAV_UNLOCK(sc);
 382 #endif
 383                 goto bad;
 384         }
 385
 386         /* Print Ethernet Address */
 387         printf("%s: Ethernet address %s\n", devname, ether_sprintf(eaddr));
 388
 389 #if defined(__FreeBSD__)
 390         bcopy(eaddr, (char *)&sc->sc_ac.ac_enaddr, ETHER_ADDR_LEN);
 391 #endif
 392
 393         /* initialize interface infomation */
 394         ifp = GET_IFP(sc);
 395         ifp->if_softc = sc;
 396         ifp->if_mtu = ETHERMTU;
 397 #if defined(__NetBSD__)
 398         strncpy(ifp->if_xname, devname, IFNAMSIZ);
 399 #elif defined(__FreeBSD__)
 400         if_initname(ifp, "udav",  device_get_unit(self));
 401 #endif
 402         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 403         ifp->if_start = udav_start;
 404         ifp->if_ioctl = udav_ioctl;
 405         ifp->if_watchdog = udav_watchdog;
 406         ifp->if_init = udav_init;
 407 #if defined(__NetBSD__)
 408         ifp->if_stop = udav_stop;
 409 #endif
 410 #if defined(__FreeBSD__)
 411         ifp->if_baudrate = 10000000;
 412         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 413 #endif
 414 #if defined(__NetBSD__)
 415         IFQ_SET_READY(&ifp->if_snd);
 416 #endif
 417
 418
 419 #if defined(__NetBSD__)
 420         /*
 421          * Do ifmedia setup.
 422          */
 423         mii = &sc->sc_mii;
 424         mii->mii_ifp = ifp;
 425         mii->mii_readreg = udav_miibus_readreg;
 426         mii->mii_writereg = udav_miibus_writereg;
 427         mii->mii_statchg = udav_miibus_statchg;
 428         mii->mii_flags = MIIF_AUTOTSLEEP;
 429         ifmedia_init(&mii->mii_media, 0,
 430                      udav_ifmedia_change, udav_ifmedia_status);
 431         mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
 432         if (LIST_FIRST(&mii->mii_phys) == NULL) {
 433                 ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
 434                 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
 435         } else
 436                 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
 437
 438         /* attach the interface */
 439         if_attach(ifp);
 440         Ether_ifattach(ifp, eaddr);
 441 #elif defined(__FreeBSD__)
 442         if (mii_phy_probe(self, &sc->sc_miibus,
 443             udav_ifmedia_change, udav_ifmedia_status)) {
 444                 printf("%s: MII without any PHY!\n", USBDEVNAME(sc->sc_dev));
 445                 UDAV_UNLOCK(sc);
 446                 mtx_destroy(&sc->sc_mtx);
 447                 USB_ATTACH_ERROR_RETURN;
 448         }
 449
 450         sc->sc_qdat.ifp = ifp;
 451         sc->sc_qdat.if_rxstart = udav_rxstart;
 452
 453         /*
 454          * Call MI attach routine.
 455          */
 456
 457         ether_ifattach(ifp, eaddr);
 458 #endif
 459
 460 #if NRND > 0
 461         rnd_attach_source(&sc->rnd_source, devname, RND_TYPE_NET, 0);
 462 #endif
 463
 464         usb_callout_init(sc->sc_stat_ch);
 465 #if defined(__FreeBSD__)
 466         usb_register_netisr();
 467 #endif
 468         sc->sc_attached = 1;
 469 #if defined(__NetBSD__)
 470         splx(s);
 471 #elif defined(__FreeBSD__)
 472         UDAV_UNLOCK(sc);
 473 #endif
 474
 475         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, dev, USBDEV(sc->sc_dev));
 476
 477         USB_ATTACH_SUCCESS_RETURN;
 478
 479  bad:
 480         sc->sc_dying = 1;
 481         USB_ATTACH_ERROR_RETURN;
 482 }
 483
 484 /* detach */
 485 USB_DETACH(udav)
 486 {
 487         USB_DETACH_START(udav, sc);
 488         struct ifnet *ifp = GET_IFP(sc);
 489 #if defined(__NetBSD__)
 490         int s;
 491 #endif
 492
 493         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 494
 495         /* Detached before attached finished */
 496         if (!sc->sc_attached)
 497                 return (0);
 498
 499         UDAV_LOCK(sc);
 500
 501         usb_uncallout(sc->sc_stat_ch, udav_tick, sc);
 502
 503         /* Remove any pending tasks */
 504         usb_rem_task(sc->sc_udev, &sc->sc_tick_task);
 505         usb_rem_task(sc->sc_udev, &sc->sc_stop_task);
 506
 507 #if defined(__NetBSD__)
 508         s = splusb();
 509 #elif defined(__FreeBSD__)
 510         UDAV_LOCK(sc);
 511 #endif
 512
 513         if (--sc->sc_refcnt >= 0) {
 514                 /* Wait for processes to go away */
 515                 usb_detach_wait(USBDEV(sc->sc_dev));
 516         }
 517         if (ifp->if_flags & IFF_RUNNING)
 518                 udav_stop(GET_IFP(sc), 1);
 519
 520 #if NRND > 0
 521         rnd_detach_source(&sc->rnd_source);
 522 #endif
 523 #if defined(__NetBSD__)
 524         mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
 525         ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
 526 #endif
 527         ether_ifdetach(ifp);
 528 #if defined(__NetBSD__)
 529         if_detach(ifp);
 530 #endif
 531
 532 #ifdef DIAGNOSTIC
 533         if (sc->sc_pipe_tx != NULL)
 534                 printf("%s: detach has active tx endpoint.\n",
 535                        USBDEVNAME(sc->sc_dev));
 536         if (sc->sc_pipe_rx != NULL)
 537                 printf("%s: detach has active rx endpoint.\n",
 538                        USBDEVNAME(sc->sc_dev));
 539         if (sc->sc_pipe_intr != NULL)
 540                 printf("%s: detach has active intr endpoint.\n",
 541                        USBDEVNAME(sc->sc_dev));
 542 #endif
 543         sc->sc_attached = 0;
 544
 545 #if defined(__NetBSD__)
 546         splx(s);
 547 #elif defined(__FreeBSD__)
 548         UDAV_UNLOCK(sc);
 549 #endif
 550
 551 #if defined(__FreeBSD__)
 552         mtx_destroy(&sc->sc_mtx);
 553 #endif
 554
 555         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 556                            USBDEV(sc->sc_dev));
 557         return (0);
 558 }
 559
 560 #if 0
 561 /* read memory */
 562 Static int
 563 udav_mem_read(struct udav_softc *sc, int offset, void *buf, int len)
 564 {
 565         usb_device_request_t req;
 566         usbd_status err;
 567
 568         if (sc == NULL)
 569                 return (0);
 570
 571         DPRINTFN(0x200,
 572                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 573
 574         if (sc->sc_dying)
 575                 return (0);
 576
 577         offset &= 0xffff;
 578         len &= 0xff;
 579
 580         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 581         req.bRequest = UDAV_REQ_MEM_READ;
 582         USETW(req.wValue, 0x0000);
 583         USETW(req.wIndex, offset);
 584         USETW(req.wLength, len);
 585
 586         sc->sc_refcnt++;
 587         err = usbd_do_request(sc->sc_udev, &req, buf);
 588         if (--sc->sc_refcnt < 0)
 589                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 590         if (err) {
 591                 DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
 592                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 593         }
 594
 595         return (err);
 596 }
 597
 598 /* write memory */
 599 Static int
 600 udav_mem_write(struct udav_softc *sc, int offset, void *buf, int len)
 601 {
 602         usb_device_request_t req;
 603         usbd_status err;
 604
 605         if (sc == NULL)
 606                 return (0);
 607
 608         DPRINTFN(0x200,
 609                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 610
 611         if (sc->sc_dying)
 612                 return (0);
 613
 614         offset &= 0xffff;
 615         len &= 0xff;
 616
 617         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 618         req.bRequest = UDAV_REQ_MEM_WRITE;
 619         USETW(req.wValue, 0x0000);
 620         USETW(req.wIndex, offset);
 621         USETW(req.wLength, len);
 622
 623         sc->sc_refcnt++;
 624         err = usbd_do_request(sc->sc_udev, &req, buf);
 625         if (--sc->sc_refcnt < 0)
 626                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 627         if (err) {
 628                 DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 629                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 630         }
 631
 632         return (err);
 633 }
 634
 635 /* write memory */
 636 Static int
 637 udav_mem_write1(struct udav_softc *sc, int offset, unsigned char ch)
 638 {
 639         usb_device_request_t req;
 640         usbd_status err;
 641
 642         if (sc == NULL)
 643                 return (0);
 644
 645         DPRINTFN(0x200,
 646                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 647
 648         if (sc->sc_dying)
 649                 return (0);
 650
 651         offset &= 0xffff;
 652
 653         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 654         req.bRequest = UDAV_REQ_MEM_WRITE1;
 655         USETW(req.wValue, ch);
 656         USETW(req.wIndex, offset);
 657         USETW(req.wLength, 0x0000);
 658
 659         sc->sc_refcnt++;
 660         err = usbd_do_request(sc->sc_udev, &req, NULL);
 661         if (--sc->sc_refcnt < 0)
 662                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 663         if (err) {
 664                 DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 665                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 666         }
 667
 668         return (err);
 669 }
 670 #endif
 671
 672 /* read register(s) */
 673 Static int
 674 udav_csr_read(struct udav_softc *sc, int offset, void *buf, int len)
 675 {
 676         usb_device_request_t req;
 677         usbd_status err;
 678
 679         if (sc == NULL)
 680                 return (0);
 681
 682         DPRINTFN(0x200,
 683                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 684
 685         if (sc->sc_dying)
 686                 return (0);
 687
 688         offset &= 0xff;
 689         len &= 0xff;
 690
 691         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 692         req.bRequest = UDAV_REQ_REG_READ;
 693         USETW(req.wValue, 0x0000);
 694         USETW(req.wIndex, offset);
 695         USETW(req.wLength, len);
 696
 697         sc->sc_refcnt++;
 698         err = usbd_do_request(sc->sc_udev, &req, buf);
 699         if (--sc->sc_refcnt < 0)
 700                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 701         if (err) {
 702                 DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
 703                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 704         }
 705
 706         return (err);
 707 }
 708
 709 /* write register(s) */
 710 Static int
 711 udav_csr_write(struct udav_softc *sc, int offset, void *buf, int len)
 712 {
 713         usb_device_request_t req;
 714         usbd_status err;
 715
 716         if (sc == NULL)
 717                 return (0);
 718
 719         DPRINTFN(0x200,
 720                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 721
 722         if (sc->sc_dying)
 723                 return (0);
 724
 725         offset &= 0xff;
 726         len &= 0xff;
 727
 728         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 729         req.bRequest = UDAV_REQ_REG_WRITE;
 730         USETW(req.wValue, 0x0000);
 731         USETW(req.wIndex, offset);
 732         USETW(req.wLength, len);
 733
 734         sc->sc_refcnt++;
 735         err = usbd_do_request(sc->sc_udev, &req, buf);
 736         if (--sc->sc_refcnt < 0)
 737                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 738         if (err) {
 739                 DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 740                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 741         }
 742
 743         return (err);
 744 }
 745
 746 Static int
 747 udav_csr_read1(struct udav_softc *sc, int offset)
 748 {
 749         u_int8_t val = 0;
 750
 751         if (sc == NULL)
 752                 return (0);
 753
 754         DPRINTFN(0x200,
 755                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 756
 757         if (sc->sc_dying)
 758                 return (0);
 759
 760         return (udav_csr_read(sc, offset, &val, 1) ? 0 : val);
 761 }
 762
 763 /* write a register */
 764 Static int
 765 udav_csr_write1(struct udav_softc *sc, int offset, unsigned char ch)
 766 {
 767         usb_device_request_t req;
 768         usbd_status err;
 769
 770         if (sc == NULL)
 771                 return (0);
 772
 773         DPRINTFN(0x200,
 774                 ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 775
 776         if (sc->sc_dying)
 777                 return (0);
 778
 779         offset &= 0xff;
 780
 781         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 782         req.bRequest = UDAV_REQ_REG_WRITE1;
 783         USETW(req.wValue, ch);
 784         USETW(req.wIndex, offset);
 785         USETW(req.wLength, 0x0000);
 786
 787         sc->sc_refcnt++;
 788         err = usbd_do_request(sc->sc_udev, &req, NULL);
 789         if (--sc->sc_refcnt < 0)
 790                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 791         if (err) {
 792                 DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
 793                          USBDEVNAME(sc->sc_dev), __func__, offset, err));
 794         }
 795
 796         return (err);
 797 }
 798
 799 #if defined(__NetBSD__)
 800 Static int
 801 udav_init(struct ifnet *ifp)
 802 #elif defined(__FreeBSD__)
 803 Static void
 804 udav_init(void *xsc)
 805 #endif
 806 {
 807 #if defined(__NetBSD__)
 808         struct udav_softc *sc = ifp->if_softc;
 809 #elif defined(__FreeBSD__)
 810         struct udav_softc *sc = (struct udav_softc *)xsc;
 811         struct ifnet    *ifp = GET_IFP(sc);
 812 #endif
 813         struct mii_data *mii = GET_MII(sc);
 814         u_char *eaddr;
 815 #if defined(__NetBSD__)
 816         int s;
 817 #endif
 818
 819         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 820
 821         if (sc->sc_dying)
 822 #if defined(__NetBSD__)
 823                 return (EIO);
 824 #elif defined(__FreeBSD__)
 825                 return ;
 826 #endif
 827
 828 #if defined(__NetBSD__)
 829         s = splnet();
 830 #elif defined(__FreeBSD__)
 831         UDAV_LOCK(sc);
 832 #endif
 833
 834         /* Cancel pending I/O and free all TX/RX buffers */
 835         udav_stop(ifp, 1);
 836
 837 #if defined(__NetBSD__)
 838         eaddr = LLADDR(ifp->if_sadl);
 839 #elif defined(__FreeBSD__)
 840         eaddr = sc->sc_ac.ac_enaddr ;
 841 #endif
 842         udav_csr_write(sc, UDAV_PAR, eaddr, ETHER_ADDR_LEN);
 843
 844         /* Initialize network control register */
 845         /*  Disable loopback  */
 846         UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_LBK0 | UDAV_NCR_LBK1);
 847
 848         /* Initialize RX control register */
 849         UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_DIS_LONG | UDAV_RCR_DIS_CRC);
 850
 851         /* If we want promiscuous mode, accept all physical frames. */
 852         if (ifp->if_flags & IFF_PROMISC)
 853                 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
 854         else
 855                 UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
 856
 857         /* Initialize transmit ring */
 858         if (udav_tx_list_init(sc) == ENOBUFS) {
 859                 printf("%s: tx list init failed\n", USBDEVNAME(sc->sc_dev));
 860 #if defined(__NetBSD__)
 861                 splx(s);
 862                 return (EIO);
 863 #elif defined(__FreeBSD__)
 864                 UDAV_UNLOCK(sc);
 865                 return ;
 866 #endif
 867
 868         }
 869
 870         /* Initialize receive ring */
 871         if (udav_rx_list_init(sc) == ENOBUFS) {
 872                 printf("%s: rx list init failed\n", USBDEVNAME(sc->sc_dev));
 873 #if defined(__NetBSD__)
 874                 splx(s);
 875                 return (EIO);
 876 #elif defined(__FreeBSD__)
 877                 UDAV_UNLOCK(sc);
 878                 return ;
 879 #endif
 880         }
 881
 882         /* Load the multicast filter */
 883         udav_setmulti(sc);
 884
 885         /* Enable RX */
 886         UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_RXEN);
 887
 888         /* clear POWER_DOWN state of internal PHY */
 889         UDAV_SETBIT(sc, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0);
 890         UDAV_CLRBIT(sc, UDAV_GPR, UDAV_GPR_GEPIO0);
 891
 892         mii_mediachg(mii);
 893
 894         if (sc->sc_pipe_tx == NULL || sc->sc_pipe_rx == NULL) {
 895                 if (udav_openpipes(sc)) {
 896 #if defined(__NetBSD__)
 897                         splx(s);
 898                         return (EIO);
 899 #elif defined(__FreeBSD__)
 900                         UDAV_UNLOCK(sc);
 901                         return ;
 902 #endif
 903                 }
 904         }
 905
 906         ifp->if_flags |= IFF_RUNNING;
 907         ifp->if_flags &= ~IFF_OACTIVE;
 908
 909 #if defined(__NetBSD__)
 910         splx(s);
 911 #elif defined(__FreeBSD__)
 912         UDAV_UNLOCK(sc);
 913 #endif
 914
 915         usb_callout(sc->sc_stat_ch, hz, udav_tick, sc);
 916
 917 #if defined(__NetBSD__)
 918         return (0);
 919 #elif defined(__FreeBSD__)
 920         return ;
 921 #endif
 922 }
 923
 924 Static void
 925 udav_reset(struct udav_softc *sc)
 926 {
 927         int i;
 928
 929         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
 930
 931         if (sc->sc_dying)
 932                 return;
 933
 934         /* Select PHY */
 935 #if 1
 936         /*
 937          * XXX: force select internal phy.
 938          *      external phy routines are not tested.
 939          */
 940         UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
 941 #else
 942         if (sc->sc_flags & UDAV_EXT_PHY) {
 943                 UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
 944         } else {
 945                 UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
 946         }
 947 #endif
 948
 949         UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_RST);
 950
 951         for (i = 0; i < UDAV_TX_TIMEOUT; i++) {
 952                 if (!(udav_csr_read1(sc, UDAV_NCR) & UDAV_NCR_RST))
 953                         break;
 954                 delay(10);      /* XXX */
 955         }
 956         delay(10000);           /* XXX */
 957 }
 958
 959 #if defined(__NetBSD__) || defined(__OpenBSD__)
 960 int
 961 udav_activate(device_ptr_t self, enum devact act)
 962 {
 963         struct udav_softc *sc = (struct udav_softc *)self;
 964
 965         DPRINTF(("%s: %s: enter, act=%d\n", USBDEVNAME(sc->sc_dev),
 966                  __func__, act));
 967         switch (act) {
 968         case DVACT_ACTIVATE:
 969                 return (EOPNOTSUPP);
 970                 break;
 971
 972         case DVACT_DEACTIVATE:
 973                 if_deactivate(&sc->sc_ec.ec_if);
 974                 sc->sc_dying = 1;
 975                 break;
 976         }
 977         return (0);
 978 }
 979 #endif
 980
 981 #define UDAV_BITS       6
 982
 983 #if defined(__NetBSD__)
 984 #define UDAV_CALCHASH(addr) \
 985         (ether_crc32_le((addr), ETHER_ADDR_LEN) & ((1 << UDAV_BITS) - 1))
 986
 987 #elif defined(__FreeBSD__)
 988 Static uint32_t
 989 udav_mchash(const uint8_t *addr)
 990 {
 991         uint32_t crc, carry;
 992         int idx, bit;
 993         uint8_t data;
 994
 995         /* Compute CRC for the address value. */
 996         crc = 0xFFFFFFFF; /* initial value */
 997
 998         for (idx = 0; idx < 6; idx++) {
 999                 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1) {
1000                         carry = ((crc & 0x80000000) ? 1 : 0) ^ (data & 0x01);
1001                         crc <<= 1;
1002                         if (carry)
1003                                 crc = (crc ^ 0x04c11db6) | carry;
1004                 }
1005         }
1006
1007         /* return the filter bit position */
1008         return((crc >> 26) & 0x0000003F);
1009 }
1010 #endif
1011
1012 Static void
1013 udav_setmulti(struct udav_softc *sc)
1014 {
1015         struct ifnet *ifp;
1016 #if defined(__NetBSD__)
1017         struct ether_multi *enm;
1018         struct ether_multistep step;
1019 #elif defined(__FreeBSD__)
1020         struct ifmultiaddr *ifma;
1021 #endif
1022         u_int8_t hashes[8];
1023         int h = 0;
1024
1025         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1026
1027         if (sc->sc_dying)
1028                 return;
1029
1030         ifp = GET_IFP(sc);
1031
1032         if (ifp->if_flags & IFF_PROMISC) {
1033                 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
1034                 return;
1035         } else if (ifp->if_flags & IFF_ALLMULTI) {
1036 #if defined(__NetBSD__)
1037         allmulti:
1038 #endif
1039                 ifp->if_flags |= IFF_ALLMULTI;
1040                 UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
1041                 UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_PRMSC);
1042                 return;
1043         }
1044
1045         /* first, zot all the existing hash bits */
1046         memset(hashes, 0x00, sizeof(hashes));
1047         hashes[7] |= 0x80;      /* broadcast address */
1048         udav_csr_write(sc, UDAV_MAR, hashes, sizeof(hashes));
1049
1050         /* now program new ones */
1051 #if defined(__NetBSD__)
1052         ETHER_FIRST_MULTI(step, &sc->sc_ec, enm);
1053         while (enm != NULL) {
1054                 if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
1055                            ETHER_ADDR_LEN) != 0)
1056                         goto allmulti;
1057
1058                 h = UDAV_CALCHASH(enm->enm_addrlo);
1059                 hashes[h>>3] |= 1 << (h & 0x7);
1060                 ETHER_NEXT_MULTI(step, enm);
1061         }
1062 #elif defined(__FreeBSD__)
1063 #if __FreeBSD_version >= 500000
1064         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
1065 #else
1066         LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
1067 #endif
1068         {
1069                 if (ifma->ifma_addr->sa_family != AF_LINK)
1070                         continue;
1071                 h = udav_mchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1072                 hashes[h / 8] |= 1 << (h % 8);
1073         }
1074 #endif
1075
1076         /* disable all multicast */
1077         ifp->if_flags &= ~IFF_ALLMULTI;
1078         UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
1079
1080         /* write hash value to the register */
1081         udav_csr_write(sc, UDAV_MAR, hashes, sizeof(hashes));
1082 }
1083
1084 Static int
1085 udav_openpipes(struct udav_softc *sc)
1086 {
1087         struct udav_chain *c;
1088         usbd_status err;
1089         int i;
1090         int error = 0;
1091
1092         if (sc->sc_dying)
1093                 return (EIO);
1094
1095         sc->sc_refcnt++;
1096
1097         /* Open RX pipe */
1098         err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkin_no,
1099                              USBD_EXCLUSIVE_USE, &sc->sc_pipe_rx);
1100         if (err) {
1101                 printf("%s: open rx pipe failed: %s\n",
1102                        USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1103                 error = EIO;
1104                 goto done;
1105         }
1106
1107         /* Open TX pipe */
1108         err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkout_no,
1109                              USBD_EXCLUSIVE_USE, &sc->sc_pipe_tx);
1110         if (err) {
1111                 printf("%s: open tx pipe failed: %s\n",
1112                        USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1113                 error = EIO;
1114                 goto done;
1115         }
1116
1117 #if 0
1118         /* XXX: interrupt endpoint is not yet supported */
1119         /* Open Interrupt pipe */
1120         err = usbd_open_pipe_intr(sc->sc_ctl_iface, sc->sc_intrin_no,
1121                                   USBD_EXCLUSIVE_USE, &sc->sc_pipe_intr, sc,
1122                                   &sc->sc_cdata.udav_ibuf, UDAV_INTR_PKGLEN,
1123                                   udav_intr, UDAV_INTR_INTERVAL);
1124         if (err) {
1125                 printf("%s: open intr pipe failed: %s\n",
1126                        USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1127                 error = EIO;
1128                 goto done;
1129         }
1130 #endif
1131
1132
1133         /* Start up the receive pipe. */
1134         for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
1135                 c = &sc->sc_cdata.udav_rx_chain[i];
1136                 usbd_setup_xfer(c->udav_xfer, sc->sc_pipe_rx,
1137                                 c, c->udav_buf, UDAV_BUFSZ,
1138                                 USBD_SHORT_XFER_OK | USBD_NO_COPY,
1139                                 USBD_NO_TIMEOUT, udav_rxeof);
1140                 (void)usbd_transfer(c->udav_xfer);
1141                 DPRINTF(("%s: %s: start read\n", USBDEVNAME(sc->sc_dev),
1142                          __func__));
1143         }
1144
1145  done:
1146         if (--sc->sc_refcnt < 0)
1147                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1148
1149         return (error);
1150 }
1151
1152 Static int
1153 udav_newbuf(struct udav_softc *sc, struct udav_chain *c, struct mbuf *m)
1154 {
1155         struct mbuf *m_new = NULL;
1156
1157         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1158
1159         if (m == NULL) {
1160                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
1161                 if (m_new == NULL) {
1162                         printf("%s: no memory for rx list "
1163                                "-- packet dropped!\n", USBDEVNAME(sc->sc_dev));
1164                         return (ENOBUFS);
1165                 }
1166                 MCLGET(m_new, M_DONTWAIT);
1167                 if (!(m_new->m_flags & M_EXT)) {
1168                         printf("%s: no memory for rx list "
1169                                "-- packet dropped!\n", USBDEVNAME(sc->sc_dev));
1170                         m_freem(m_new);
1171                         return (ENOBUFS);
1172                 }
1173                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
1174         } else {
1175                 m_new = m;
1176                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
1177                 m_new->m_data = m_new->m_ext.ext_buf;
1178         }
1179
1180         m_adj(m_new, ETHER_ALIGN);
1181         c->udav_mbuf = m_new;
1182
1183         return (0);
1184 }
1185
1186
1187 Static int
1188 udav_rx_list_init(struct udav_softc *sc)
1189 {
1190         struct udav_cdata *cd;
1191         struct udav_chain *c;
1192         int i;
1193
1194         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1195
1196         cd = &sc->sc_cdata;
1197         for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
1198                 c = &cd->udav_rx_chain[i];
1199                 c->udav_sc = sc;
1200                 c->udav_idx = i;
1201                 if (udav_newbuf(sc, c, NULL) == ENOBUFS)
1202                         return (ENOBUFS);
1203                 if (c->udav_xfer == NULL) {
1204                         c->udav_xfer = usbd_alloc_xfer(sc->sc_udev);
1205                         if (c->udav_xfer == NULL)
1206                                 return (ENOBUFS);
1207                         c->udav_buf = usbd_alloc_buffer(c->udav_xfer, UDAV_BUFSZ);
1208                         if (c->udav_buf == NULL) {
1209                                 usbd_free_xfer(c->udav_xfer);
1210                                 return (ENOBUFS);
1211                         }
1212                 }
1213         }
1214
1215         return (0);
1216 }
1217
1218 Static int
1219 udav_tx_list_init(struct udav_softc *sc)
1220 {
1221         struct udav_cdata *cd;
1222         struct udav_chain *c;
1223         int i;
1224
1225         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1226
1227         cd = &sc->sc_cdata;
1228         for (i = 0; i < UDAV_TX_LIST_CNT; i++) {
1229                 c = &cd->udav_tx_chain[i];
1230                 c->udav_sc = sc;
1231                 c->udav_idx = i;
1232                 c->udav_mbuf = NULL;
1233                 if (c->udav_xfer == NULL) {
1234                         c->udav_xfer = usbd_alloc_xfer(sc->sc_udev);
1235                         if (c->udav_xfer == NULL)
1236                                 return (ENOBUFS);
1237                         c->udav_buf = usbd_alloc_buffer(c->udav_xfer, UDAV_BUFSZ);
1238                         if (c->udav_buf == NULL) {
1239                                 usbd_free_xfer(c->udav_xfer);
1240                                 return (ENOBUFS);
1241                         }
1242                 }
1243         }
1244
1245         return (0);
1246 }
1247
1248 Static void
1249 udav_start(struct ifnet *ifp)
1250 {
1251         struct udav_softc *sc = ifp->if_softc;
1252         struct mbuf *m_head = NULL;
1253
1254         DPRINTF(("%s: %s: enter, link=%d\n", USBDEVNAME(sc->sc_dev),
1255                  __func__, sc->sc_link));
1256
1257         if (sc->sc_dying)
1258                 return;
1259
1260         if (!sc->sc_link)
1261                 return;
1262
1263         if (ifp->if_flags & IFF_OACTIVE)
1264                 return;
1265 #if defined(__NetBSD__)
1266         IFQ_POLL(&ifp->if_snd, m_head);
1267 #elif defined(__FreeBSD__)
1268         IF_DEQUEUE(&ifp->if_snd, m_head);
1269 #endif
1270         if (m_head == NULL)
1271                 return;
1272
1273         if (udav_send(sc, m_head, 0)) {
1274 #if defined(__FreeBSD__)
1275                 IF_PREPEND(&ifp->if_snd, m_head);
1276 #endif
1277                 ifp->if_flags |= IFF_OACTIVE;
1278                 return;
1279         }
1280
1281 #if defined(__NetBSD__)
1282         IFQ_DEQUEUE(&ifp->if_snd, m_head);
1283 #endif
1284
1285 #if NBPFILTER > 0
1286         BPF_MTAP(ifp, m_head);
1287 #endif
1288
1289         ifp->if_flags |= IFF_OACTIVE;
1290
1291         /* Set a timeout in case the chip goes out to lunch. */
1292         ifp->if_timer = 5;
1293 }
1294
1295 Static int
1296 udav_send(struct udav_softc *sc, struct mbuf *m, int idx)
1297 {
1298         int total_len;
1299         struct udav_chain *c;
1300         usbd_status err;
1301
1302         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),__func__));
1303
1304         c = &sc->sc_cdata.udav_tx_chain[idx];
1305
1306         /* Copy the mbuf data into a contiguous buffer */
1307         /*  first 2 bytes are packet length */
1308         m_copydata(m, 0, m->m_pkthdr.len, c->udav_buf + 2);
1309         c->udav_mbuf = m;
1310         total_len = m->m_pkthdr.len;
1311         if (total_len < UDAV_MIN_FRAME_LEN) {
1312                 memset(c->udav_buf + 2 + total_len, 0,
1313                     UDAV_MIN_FRAME_LEN - total_len);
1314                 total_len = UDAV_MIN_FRAME_LEN;
1315         }
1316
1317         /* Frame length is specified in the first 2bytes of the buffer */
1318         c->udav_buf[0] = (u_int8_t)total_len;
1319         c->udav_buf[1] = (u_int8_t)(total_len >> 8);
1320         total_len += 2;
1321
1322         usbd_setup_xfer(c->udav_xfer, sc->sc_pipe_tx, c, c->udav_buf, total_len,
1323                         USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
1324                         UDAV_TX_TIMEOUT, udav_txeof);
1325
1326         /* Transmit */
1327         sc->sc_refcnt++;
1328         err = usbd_transfer(c->udav_xfer);
1329         if (--sc->sc_refcnt < 0)
1330                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1331         if (err != USBD_IN_PROGRESS) {
1332                 printf("%s: udav_send error=%s\n", USBDEVNAME(sc->sc_dev),
1333                        usbd_errstr(err));
1334                 /* Stop the interface */
1335                 usb_add_task(sc->sc_udev, &sc->sc_stop_task);
1336                 return (EIO);
1337         }
1338
1339         DPRINTF(("%s: %s: send %d bytes\n", USBDEVNAME(sc->sc_dev),
1340                  __func__, total_len));
1341
1342         sc->sc_cdata.udav_tx_cnt++;
1343
1344         return (0);
1345 }
1346
1347 Static void
1348 udav_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
1349 {
1350         struct udav_chain *c = priv;
1351         struct udav_softc *sc = c->udav_sc;
1352         struct ifnet *ifp = GET_IFP(sc);
1353 #if defined(__NetBSD__)
1354         int s;
1355 #endif
1356
1357         if (sc->sc_dying)
1358                 return;
1359
1360 #if defined(__NetBSD__)
1361         s = splnet();
1362 #elif defined(__FreeBSD__)
1363         UDAV_LOCK(sc);
1364 #endif
1365
1366         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1367
1368         ifp->if_timer = 0;
1369         ifp->if_flags &= ~IFF_OACTIVE;
1370
1371         if (status != USBD_NORMAL_COMPLETION) {
1372                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1373 #if defined(__NetBSD__)
1374                         splx(s);
1375 #elif defined(__FreeBSD__)
1376                         UDAV_UNLOCK(sc);
1377 #endif
1378                         return;
1379                 }
1380                 ifp->if_oerrors++;
1381                 printf("%s: usb error on tx: %s\n", USBDEVNAME(sc->sc_dev),
1382                        usbd_errstr(status));
1383                 if (status == USBD_STALLED) {
1384                         sc->sc_refcnt++;
1385                         usbd_clear_endpoint_stall(sc->sc_pipe_tx);
1386                         if (--sc->sc_refcnt < 0)
1387                                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1388                 }
1389 #if defined(__NetBSD__)
1390                 splx(s);
1391 #elif defined(__FreeBSD__)
1392                 UDAV_UNLOCK(sc);
1393 #endif
1394                 return;
1395         }
1396
1397         ifp->if_opackets++;
1398
1399         m_freem(c->udav_mbuf);
1400         c->udav_mbuf = NULL;
1401
1402 #if defined(__NetBSD__)
1403         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1404 #elif defined(__FreeBSD__)
1405         if ( ifp->if_snd.ifq_head != NULL )
1406 #endif
1407                 udav_start(ifp);
1408
1409 #if defined(__NetBSD__)
1410         splx(s);
1411 #elif defined(__FreeBSD__)
1412         UDAV_UNLOCK(sc);
1413 #endif
1414 }
1415
1416 Static void
1417 udav_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
1418 {
1419         struct udav_chain *c = priv;
1420         struct udav_softc *sc = c->udav_sc;
1421         struct ifnet *ifp = GET_IFP(sc);
1422         struct mbuf *m;
1423         u_int32_t total_len;
1424         u_int8_t *pktstat;
1425 #if defined(__NetBSD__)
1426         int s;
1427 #endif
1428
1429         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),__func__));
1430
1431         if (sc->sc_dying)
1432                 return;
1433
1434         if (status != USBD_NORMAL_COMPLETION) {
1435                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
1436                         return;
1437                 sc->sc_rx_errs++;
1438                 if (usbd_ratecheck(&sc->sc_rx_notice)) {
1439                         printf("%s: %u usb errors on rx: %s\n",
1440                                USBDEVNAME(sc->sc_dev), sc->sc_rx_errs,
1441                                usbd_errstr(status));
1442                         sc->sc_rx_errs = 0;
1443                 }
1444                 if (status == USBD_STALLED) {
1445                         sc->sc_refcnt++;
1446                         usbd_clear_endpoint_stall(sc->sc_pipe_rx);
1447                         if (--sc->sc_refcnt < 0)
1448                                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1449                 }
1450                 goto done;
1451         }
1452
1453         usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
1454
1455         /* copy data to mbuf */
1456         m = c->udav_mbuf;
1457         memcpy(mtod(m, char *), c->udav_buf, total_len);
1458
1459         /* first byte in received data */
1460         pktstat = mtod(m, u_int8_t *);
1461         m_adj(m, sizeof(u_int8_t));
1462         DPRINTF(("%s: RX Status: 0x%02x\n", USBDEVNAME(sc->sc_dev), *pktstat));
1463
1464         total_len = UGETW(mtod(m, u_int8_t *));
1465         m_adj(m, sizeof(u_int16_t));
1466
1467         if (*pktstat & UDAV_RSR_LCS) {
1468                 ifp->if_collisions++;
1469                 goto done;
1470         }
1471
1472         if (total_len < sizeof(struct ether_header) ||
1473             *pktstat & UDAV_RSR_ERR) {
1474                 ifp->if_ierrors++;
1475                 goto done;
1476         }
1477
1478         ifp->if_ipackets++;
1479         total_len -= ETHER_CRC_LEN;
1480
1481         m->m_pkthdr.len = m->m_len = total_len;
1482 #if defined(__NetBSD__)
1483         m->m_pkthdr.rcvif = ifp;
1484 #elif defined(__FreeBSD__)
1485         m->m_pkthdr.rcvif = (struct ifnet *)&sc->sc_qdat;
1486 #endif
1487
1488 #if defined(__NetBSD__)
1489         s = splnet();
1490 #elif defined(__FreeBSD__)
1491         UDAV_LOCK(sc);
1492 #endif
1493
1494 #if defined(__NetBSD__)
1495         if (udav_newbuf(sc, c, NULL) == ENOBUFS) {
1496                 ifp->if_ierrors++;
1497                 goto done1;
1498         }
1499 #endif
1500
1501 #if NBPFILTER > 0
1502         BPF_MTAP(ifp, m);
1503 #endif
1504
1505         DPRINTF(("%s: %s: deliver %d\n", USBDEVNAME(sc->sc_dev),
1506                  __func__, m->m_len));
1507 #if defined(__NetBSD__)
1508         IF_INPUT(ifp, m);
1509 #endif
1510 #if defined(__FreeBSD__)
1511         usb_ether_input(m);
1512         UDAV_UNLOCK(sc);
1513         return ;
1514 #endif
1515
1516 #if defined(__NetBSD__)
1517  done1:
1518         splx(s);
1519 #elif defined(__FreeBSD__)
1520         UDAV_UNLOCK(sc);
1521 #endif
1522  done:
1523         /* Setup new transfer */
1524         usbd_setup_xfer(xfer, sc->sc_pipe_rx, c, c->udav_buf, UDAV_BUFSZ,
1525                         USBD_SHORT_XFER_OK | USBD_NO_COPY,
1526                         USBD_NO_TIMEOUT, udav_rxeof);
1527         sc->sc_refcnt++;
1528         usbd_transfer(xfer);
1529         if (--sc->sc_refcnt < 0)
1530                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1531
1532         DPRINTF(("%s: %s: start rx\n", USBDEVNAME(sc->sc_dev), __func__));
1533 }
1534
1535 #if 0
1536 Static void udav_intr()
1537 {
1538 }
1539 #endif
1540
1541 Static int
1542 udav_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1543 {
1544         struct udav_softc *sc = ifp->if_softc;
1545         struct ifreq *ifr = (struct ifreq *)data;
1546         struct mii_data *mii;
1547 #if defined(__NetBSD__)
1548         int s;
1549 #endif
1550         int error = 0;
1551
1552         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1553
1554         if (sc->sc_dying)
1555                 return (EIO);
1556
1557 #if defined(__NetBSD__)
1558         s = splnet();
1559 #elif defined(__FreeBSD__)
1560         UDAV_LOCK(sc);
1561 #endif
1562
1563         switch (cmd) {
1564         case SIOCGIFMEDIA:
1565         case SIOCSIFMEDIA:
1566                 mii = GET_MII(sc);
1567                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1568                 break;
1569
1570         default:
1571                 error = ether_ioctl(ifp, cmd, data);
1572                 if (error == ENETRESET) {
1573                         udav_setmulti(sc);
1574                         error = 0;
1575                 }
1576                 break;
1577         }
1578
1579 #if defined(__NetBSD__)
1580         splx(s);
1581 #elif defined(__FreeBSD__)
1582         UDAV_UNLOCK(sc);
1583 #endif
1584
1585         return (error);
1586 }
1587
1588 Static void
1589 udav_watchdog(struct ifnet *ifp)
1590 {
1591         struct udav_softc *sc = ifp->if_softc;
1592         struct udav_chain *c;
1593         usbd_status stat;
1594 #if defined(__NetBSD__)
1595         int s;
1596 #endif
1597
1598         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1599
1600         ifp->if_oerrors++;
1601         printf("%s: watchdog timeout\n", USBDEVNAME(sc->sc_dev));
1602
1603 #if defined(__NetBSD__)
1604         s = splusb();
1605 #elif defined(__FreeBSD__)
1606         UDAV_LOCK(sc)
1607 #endif
1608         c = &sc->sc_cdata.udav_tx_chain[0];
1609         usbd_get_xfer_status(c->udav_xfer, NULL, NULL, NULL, &stat);
1610         udav_txeof(c->udav_xfer, c, stat);
1611
1612 #if defined(__NetBSD__)
1613         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1614 #elif defined(__FreeBSD__)
1615         if ( ifp->if_snd.ifq_head != NULL )
1616 #endif
1617                 udav_start(ifp);
1618 #if defined(__NetBSD__)
1619         splx(s);
1620 #elif defined(__FreeBSD__)
1621         UDAV_UNLOCK(sc);
1622 #endif
1623 }
1624
1625 Static void
1626 udav_stop_task(struct udav_softc *sc)
1627 {
1628         udav_stop(GET_IFP(sc), 1);
1629 }
1630
1631 /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */
1632 Static void
1633 udav_stop(struct ifnet *ifp, int disable)
1634 {
1635         struct udav_softc *sc = ifp->if_softc;
1636         usbd_status err;
1637         int i;
1638
1639         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1640
1641         ifp->if_timer = 0;
1642
1643         udav_reset(sc);
1644
1645         usb_uncallout(sc->sc_stat_ch, udav_tick, sc);
1646
1647         /* Stop transfers */
1648         /* RX endpoint */
1649         if (sc->sc_pipe_rx != NULL) {
1650                 err = usbd_abort_pipe(sc->sc_pipe_rx);
1651                 if (err)
1652                         printf("%s: abort rx pipe failed: %s\n",
1653                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1654                 err = usbd_close_pipe(sc->sc_pipe_rx);
1655                 if (err)
1656                         printf("%s: close rx pipe failed: %s\n",
1657                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1658                 sc->sc_pipe_rx = NULL;
1659         }
1660
1661         /* TX endpoint */
1662         if (sc->sc_pipe_tx != NULL) {
1663                 err = usbd_abort_pipe(sc->sc_pipe_tx);
1664                 if (err)
1665                         printf("%s: abort tx pipe failed: %s\n",
1666                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1667                 err = usbd_close_pipe(sc->sc_pipe_tx);
1668                 if (err)
1669                         printf("%s: close tx pipe failed: %s\n",
1670                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1671                 sc->sc_pipe_tx = NULL;
1672         }
1673
1674 #if 0
1675         /* XXX: Interrupt endpoint is not yet supported!! */
1676         /* Interrupt endpoint */
1677         if (sc->sc_pipe_intr != NULL) {
1678                 err = usbd_abort_pipe(sc->sc_pipe_intr);
1679                 if (err)
1680                         printf("%s: abort intr pipe failed: %s\n",
1681                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1682                 err = usbd_close_pipe(sc->sc_pipe_intr);
1683                 if (err)
1684                         printf("%s: close intr pipe failed: %s\n",
1685                                USBDEVNAME(sc->sc_dev), usbd_errstr(err));
1686                 sc->sc_pipe_intr = NULL;
1687         }
1688 #endif
1689
1690         /* Free RX resources. */
1691         for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
1692                 if (sc->sc_cdata.udav_rx_chain[i].udav_mbuf != NULL) {
1693                         m_freem(sc->sc_cdata.udav_rx_chain[i].udav_mbuf);
1694                         sc->sc_cdata.udav_rx_chain[i].udav_mbuf = NULL;
1695                 }
1696                 if (sc->sc_cdata.udav_rx_chain[i].udav_xfer != NULL) {
1697                         usbd_free_xfer(sc->sc_cdata.udav_rx_chain[i].udav_xfer);
1698                         sc->sc_cdata.udav_rx_chain[i].udav_xfer = NULL;
1699                 }
1700         }
1701
1702         /* Free TX resources. */
1703         for (i = 0; i < UDAV_TX_LIST_CNT; i++) {
1704                 if (sc->sc_cdata.udav_tx_chain[i].udav_mbuf != NULL) {
1705                         m_freem(sc->sc_cdata.udav_tx_chain[i].udav_mbuf);
1706                         sc->sc_cdata.udav_tx_chain[i].udav_mbuf = NULL;
1707                 }
1708                 if (sc->sc_cdata.udav_tx_chain[i].udav_xfer != NULL) {
1709                         usbd_free_xfer(sc->sc_cdata.udav_tx_chain[i].udav_xfer);
1710                         sc->sc_cdata.udav_tx_chain[i].udav_xfer = NULL;
1711                 }
1712         }
1713
1714         sc->sc_link = 0;
1715         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1716 }
1717
1718 /* Set media options */
1719 Static int
1720 udav_ifmedia_change(struct ifnet *ifp)
1721 {
1722         struct udav_softc *sc = ifp->if_softc;
1723         struct mii_data *mii = GET_MII(sc);
1724
1725         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1726
1727         if (sc->sc_dying)
1728                 return (0);
1729
1730         sc->sc_link = 0;
1731         if (mii->mii_instance) {
1732                 struct mii_softc *miisc;
1733                 for (miisc = LIST_FIRST(&mii->mii_phys); miisc != NULL;
1734                      miisc = LIST_NEXT(miisc, mii_list))
1735                         mii_phy_reset(miisc);
1736         }
1737
1738         return (mii_mediachg(mii));
1739 }
1740
1741 /* Report current media status. */
1742 Static void
1743 udav_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
1744 {
1745         struct udav_softc *sc = ifp->if_softc;
1746         struct mii_data *mii = GET_MII(sc);
1747
1748         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1749
1750         if (sc->sc_dying)
1751                 return;
1752
1753         if ((ifp->if_flags & IFF_RUNNING) == 0) {
1754                 ifmr->ifm_active = IFM_ETHER | IFM_NONE;
1755                 ifmr->ifm_status = 0;
1756                 return;
1757         }
1758
1759         mii_pollstat(mii);
1760         ifmr->ifm_active = mii->mii_media_active;
1761         ifmr->ifm_status = mii->mii_media_status;
1762 }
1763
1764 Static void
1765 udav_tick(void *xsc)
1766 {
1767         struct udav_softc *sc = xsc;
1768
1769         if (sc == NULL)
1770                 return;
1771
1772         DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),
1773                         __func__));
1774
1775         if (sc->sc_dying)
1776                 return;
1777
1778         /* Perform periodic stuff in process context */
1779         usb_add_task(sc->sc_udev, &sc->sc_tick_task);
1780 }
1781
1782 Static void
1783 udav_tick_task(void *xsc)
1784 {
1785         struct udav_softc *sc = xsc;
1786         struct ifnet *ifp;
1787         struct mii_data *mii;
1788 #if defined(__NetBSD__)
1789         int s;
1790 #endif
1791
1792         if (sc == NULL)
1793                 return;
1794
1795         DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),
1796                         __func__));
1797
1798         if (sc->sc_dying)
1799                 return;
1800
1801         ifp = GET_IFP(sc);
1802         mii = GET_MII(sc);
1803
1804         if (mii == NULL)
1805                 return;
1806
1807 #if defined(__NetBSD__)
1808         s = splnet();
1809 #elif defined(__FreeBSD__)
1810         UDAV_LOCK(sc);
1811 #endif
1812
1813         mii_tick(mii);
1814         if (!sc->sc_link) {
1815                 mii_pollstat(mii);
1816                 if (mii->mii_media_status & IFM_ACTIVE &&
1817                     IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1818                         DPRINTF(("%s: %s: got link\n",
1819                                  USBDEVNAME(sc->sc_dev), __func__));
1820                         sc->sc_link++;
1821 #if defined(__NetBSD__)
1822                         if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1823 #elif defined(__FreeBSD__)
1824                         if ( ifp->if_snd.ifq_head != NULL )
1825 #endif
1826                                    udav_start(ifp);
1827                 }
1828         }
1829
1830         usb_callout(sc->sc_stat_ch, hz, udav_tick, sc);
1831
1832 #if defined(__NetBSD__)
1833         splx(s);
1834 #elif defined(__FreeBSD__)
1835         UDAV_UNLOCK(sc);
1836 #endif
1837 }
1838
1839 /* Get exclusive access to the MII registers */
1840 Static void
1841 udav_lock_mii(struct udav_softc *sc)
1842 {
1843         DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),
1844                         __func__));
1845
1846         sc->sc_refcnt++;
1847 #if defined(__NetBSD__)
1848         lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL);
1849 #elif defined(__FreeBSD__)
1850         lockmgr(&sc->sc_mii_lock, LK_EXCLUSIVE, NULL, NULL);
1851 #endif
1852 }
1853
1854 Static void
1855 udav_unlock_mii(struct udav_softc *sc)
1856 {
1857         DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev),
1858                        __func__));
1859
1860 #if defined(__NetBSD__)
1861         lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL);
1862 #elif defined(__FreeBSD__)
1863         lockmgr(&sc->sc_mii_lock, LK_RELEASE, NULL, NULL);
1864 #endif
1865         if (--sc->sc_refcnt < 0)
1866                 usb_detach_wakeup(USBDEV(sc->sc_dev));
1867 }
1868
1869 Static int
1870 udav_miibus_readreg(device_ptr_t dev, int phy, int reg)
1871 {
1872         struct udav_softc *sc;
1873         u_int8_t val[2];
1874         u_int16_t data16;
1875
1876         if (dev == NULL)
1877                 return (0);
1878
1879         sc = USBGETSOFTC(dev);
1880
1881         DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x\n",
1882                  USBDEVNAME(sc->sc_dev), __func__, phy, reg));
1883
1884         if (sc->sc_dying) {
1885 #ifdef DIAGNOSTIC
1886                 printf("%s: %s: dying\n", USBDEVNAME(sc->sc_dev),
1887                        __func__);
1888 #endif
1889                 return (0);
1890         }
1891
1892         /* XXX: one PHY only for the internal PHY */
1893         if (phy != 0) {
1894                 DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
1895                          USBDEVNAME(sc->sc_dev), __func__, phy));
1896                 return (0);
1897         }
1898
1899         udav_lock_mii(sc);
1900
1901         /* select internal PHY and set PHY register address */
1902         udav_csr_write1(sc, UDAV_EPAR,
1903                         UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
1904
1905         /* select PHY operation and start read command */
1906         udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRR);
1907
1908         /* XXX: should be wait? */
1909
1910         /* end read command */
1911         UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRR);
1912
1913         /* retrieve the result from data registers */
1914         udav_csr_read(sc, UDAV_EPDRL, val, 2);
1915
1916         udav_unlock_mii(sc);
1917
1918         data16 = val[0] | (val[1] << 8);
1919
1920         DPRINTFN(0xff, ("%s: %s: phy=%d reg=0x%04x => 0x%04x\n",
1921                  USBDEVNAME(sc->sc_dev), __func__, phy, reg, data16));
1922
1923         return (data16);
1924 }
1925
1926 Static void
1927 udav_miibus_writereg(device_ptr_t dev, int phy, int reg, int data)
1928 {
1929         struct udav_softc *sc;
1930         u_int8_t val[2];
1931
1932         if (dev == NULL)
1933                 return;
1934
1935         sc = USBGETSOFTC(dev);
1936
1937         DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x data=0x%04x\n",
1938                  USBDEVNAME(sc->sc_dev), __func__, phy, reg, data));
1939
1940         if (sc->sc_dying) {
1941 #ifdef DIAGNOSTIC
1942                 printf("%s: %s: dying\n", USBDEVNAME(sc->sc_dev),
1943                        __func__);
1944 #endif
1945                 return;
1946         }
1947
1948         /* XXX: one PHY only for the internal PHY */
1949         if (phy != 0) {
1950                 DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
1951                          USBDEVNAME(sc->sc_dev), __func__, phy));
1952                 return;
1953         }
1954
1955         udav_lock_mii(sc);
1956
1957         /* select internal PHY and set PHY register address */
1958         udav_csr_write1(sc, UDAV_EPAR,
1959                         UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
1960
1961         /* put the value to the data registers */
1962         val[0] = data & 0xff;
1963         val[1] = (data >> 8) & 0xff;
1964         udav_csr_write(sc, UDAV_EPDRL, val, 2);
1965
1966         /* select PHY operation and start write command */
1967         udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRW);
1968
1969         /* XXX: should be wait? */
1970
1971         /* end write command */
1972         UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRW);
1973
1974         udav_unlock_mii(sc);
1975
1976         return;
1977 }
1978
1979 Static void
1980 udav_miibus_statchg(device_ptr_t dev)
1981 {
1982 #ifdef UDAV_DEBUG
1983         struct udav_softc *sc;
1984
1985         if (dev == NULL)
1986                 return;
1987
1988         sc = USBGETSOFTC(dev);
1989         DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__));
1990 #endif
1991         /* Nothing to do */
1992 }
1993
1994 #if defined(__FreeBSD__)
1995 /*
1996  * Stop all chip I/O so that the kernel's probe routines don't
1997  * get confused by errant DMAs when rebooting.
1998  */
1999 Static void
2000 udav_shutdown(device_ptr_t dev)
2001 {
2002         struct udav_softc       *sc;
2003
2004         sc = device_get_softc(dev);
2005
2006         udav_stop_task(sc);
2007
2008         return;
2009 }
2010
2011 Static void
2012 udav_rxstart(struct ifnet *ifp)
2013 {
2014         struct udav_softc       *sc;
2015         struct udav_chain       *c;
2016
2017         sc = ifp->if_softc;
2018         UDAV_LOCK(sc);
2019         c = &sc->sc_cdata.udav_rx_chain[sc->sc_cdata.udav_rx_prod];
2020
2021         if (udav_newbuf(sc, c, NULL) == ENOBUFS) {
2022                 ifp->if_ierrors++;
2023                 UDAV_UNLOCK(sc);
2024                 return;
2025         }
2026
2027         /* Setup new transfer. */
2028         usbd_setup_xfer(c->udav_xfer, sc->sc_pipe_rx,
2029                         c, c->udav_buf, UDAV_BUFSZ,
2030                         USBD_SHORT_XFER_OK | USBD_NO_COPY,
2031                         USBD_NO_TIMEOUT, udav_rxeof);
2032         usbd_transfer(c->udav_xfer);
2033
2034         UDAV_UNLOCK(sc);
2035         return;
2036 }
2037 #endif