sys/dev/usb/net/if_mos.c

   1 /*-
   2  * Copyright (c) 2011 Rick van der Zwet <info@rickvanderzwet.nl>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 /*-
  18  * Copyright (c) 2008 Johann Christian Rode <jcrode@gmx.net>
  19  *
  20  * Permission to use, copy, modify, and distribute this software for any
  21  * purpose with or without fee is hereby granted, provided that the above
  22  * copyright notice and this permission notice appear in all copies.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  25  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  27  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  28  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  29  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  30  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  31  */
  32
  33 /*-
  34  * Copyright (c) 2005, 2006, 2007 Jonathan Gray <jsg@openbsd.org>
  35  *
  36  * Permission to use, copy, modify, and distribute this software for any
  37  * purpose with or without fee is hereby granted, provided that the above
  38  * copyright notice and this permission notice appear in all copies.
  39  *
  40  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  41  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  42  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  43  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  44  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  45  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  46  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  47  */
  48
  49 /*-
  50  * Copyright (c) 1997, 1998, 1999, 2000-2003
  51  *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
  52  *
  53  * Redistribution and use in source and binary forms, with or without
  54  * modification, are permitted provided that the following conditions
  55  * are met:
  56  * 1. Redistributions of source code must retain the above copyright
  57  *    notice, this list of conditions and the following disclaimer.
  58  * 2. Redistributions in binary form must reproduce the above copyright
  59  *    notice, this list of conditions and the following disclaimer in the
  60  *    documentation and/or other materials provided with the distribution.
  61  * 3. All advertising materials mentioning features or use of this software
  62  *    must display the following acknowledgement:
  63  *      This product includes software developed by Bill Paul.
  64  * 4. Neither the name of the author nor the names of any co-contributors
  65  *    may be used to endorse or promote products derived from this software
  66  *    without specific prior written permission.
  67  *
  68  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  69  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  70  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  71  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  72  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  73  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  74  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  75  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  76  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  77  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  78  * THE POSSIBILITY OF SUCH DAMAGE.
  79  */
  80
  81 #include <sys/cdefs.h>
  82 __FBSDID("$FreeBSD$");
  83
  84 /*
  85  * Moschip MCS7730/MCS7830/MCS7832 USB to Ethernet controller
  86  * The datasheet is available at the following URL:
  87  * http://www.moschip.com/data/products/MCS7830/Data%20Sheet_7830.pdf
  88  */
  89
  90 /*
  91  * The FreeBSD if_mos.c driver is based on various different sources:
  92  * The vendor provided driver at the following URL:
  93  * http://www.moschip.com/data/products/MCS7830/Driver_FreeBSD_7830.tar.gz
  94  *
  95  * Mixed together with the OpenBSD if_mos.c driver for validation and checking
  96  * and the FreeBSD if_reu.c as reference for the USB Ethernet framework.
  97  */
  98
  99 #include <sys/stdint.h>
 100 #include <sys/stddef.h>
 101 #include <sys/param.h>
 102 #include <sys/queue.h>
 103 #include <sys/types.h>
 104 #include <sys/systm.h>
 105 #include <sys/socket.h>
 106 #include <sys/kernel.h>
 107 #include <sys/bus.h>
 108 #include <sys/module.h>
 109 #include <sys/lock.h>
 110 #include <sys/mutex.h>
 111 #include <sys/condvar.h>
 112 #include <sys/sysctl.h>
 113 #include <sys/sx.h>
 114 #include <sys/unistd.h>
 115 #include <sys/callout.h>
 116 #include <sys/malloc.h>
 117 #include <sys/priv.h>
 118
 119 #include <net/if.h>
 120 #include <net/if_var.h>
 121
 122 #include <dev/usb/usb.h>
 123 #include <dev/usb/usbdi.h>
 124 #include <dev/usb/usbdi_util.h>
 125 #include "usbdevs.h"
 126
 127 #define USB_DEBUG_VAR mos_debug
 128 #include <dev/usb/usb_debug.h>
 129 #include <dev/usb/usb_process.h>
 130
 131 #include <dev/usb/net/usb_ethernet.h>
 132
 133 //#include <dev/usb/net/if_mosreg.h>
 134 #include "if_mosreg.h"
 135
 136 #ifdef USB_DEBUG
 137 static int mos_debug = 0;
 138
 139 static SYSCTL_NODE(_hw_usb, OID_AUTO, mos, CTLFLAG_RW, 0, "USB mos");
 140 SYSCTL_INT(_hw_usb_mos, OID_AUTO, debug, CTLFLAG_RW, &mos_debug, 0,
 141     "Debug level");
 142 #endif
 143
 144 #define MOS_DPRINTFN(fmt,...) \
 145   DPRINTF("mos: %s: " fmt "\n",__FUNCTION__,## __VA_ARGS__)
 146
 147 #define USB_PRODUCT_MOSCHIP_MCS7730     0x7730
 148 #define USB_PRODUCT_SITECOMEU_LN030     0x0021
 149
 150
 151
 152 /* Various supported device vendors/products. */
 153 static const STRUCT_USB_HOST_ID mos_devs[] = {
 154         {USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7730, MCS7730)},
 155         {USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7830, MCS7830)},
 156         {USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7832, MCS7832)},
 157         {USB_VPI(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_LN030, MCS7830)},
 158 };
 159
 160 static int mos_probe(device_t dev);
 161 static int mos_attach(device_t dev);
 162 static void mos_attach_post(struct usb_ether *ue);
 163 static int mos_detach(device_t dev);
 164
 165 static void mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error);
 166 static void mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error);
 167 static void mos_intr_callback(struct usb_xfer *xfer, usb_error_t error);
 168 static void mos_tick(struct usb_ether *);
 169 static void mos_start(struct usb_ether *);
 170 static void mos_init(struct usb_ether *);
 171 static void mos_chip_init(struct mos_softc *);
 172 static void mos_stop(struct usb_ether *);
 173 static int mos_miibus_readreg(device_t, int, int);
 174 static int mos_miibus_writereg(device_t, int, int, int);
 175 static void mos_miibus_statchg(device_t);
 176 static int mos_ifmedia_upd(struct ifnet *);
 177 static void mos_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 178 static void mos_reset(struct mos_softc *sc);
 179
 180 static int mos_reg_read_1(struct mos_softc *, int);
 181 static int mos_reg_read_2(struct mos_softc *, int);
 182 static int mos_reg_write_1(struct mos_softc *, int, int);
 183 static int mos_reg_write_2(struct mos_softc *, int, int);
 184 static int mos_readmac(struct mos_softc *, uint8_t *);
 185 static int mos_writemac(struct mos_softc *, uint8_t *);
 186 static int mos_write_mcast(struct mos_softc *, u_char *);
 187
 188 static void mos_setmulti(struct usb_ether *);
 189 static void mos_setpromisc(struct usb_ether *);
 190
 191 static const struct usb_config mos_config[MOS_ENDPT_MAX] = {
 192
 193         [MOS_ENDPT_TX] = {
 194                 .type = UE_BULK,
 195                 .endpoint = UE_ADDR_ANY,
 196                 .direction = UE_DIR_OUT,
 197                 .bufsize = (MCLBYTES + 2),
 198                 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
 199                 .callback = mos_bulk_write_callback,
 200                 .timeout = 10000,
 201         },
 202
 203         [MOS_ENDPT_RX] = {
 204                 .type = UE_BULK,
 205                 .endpoint = UE_ADDR_ANY,
 206                 .direction = UE_DIR_IN,
 207                 .bufsize = (MCLBYTES + 4 + ETHER_CRC_LEN),
 208                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 209                 .callback = mos_bulk_read_callback,
 210         },
 211
 212         [MOS_ENDPT_INTR] = {
 213                 .type = UE_INTERRUPT,
 214                 .endpoint = UE_ADDR_ANY,
 215                 .direction = UE_DIR_IN,
 216                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 217                 .bufsize = 0,
 218                 .callback = mos_intr_callback,
 219         },
 220 };
 221
 222 static device_method_t mos_methods[] = {
 223         /* Device interface */
 224         DEVMETHOD(device_probe, mos_probe),
 225         DEVMETHOD(device_attach, mos_attach),
 226         DEVMETHOD(device_detach, mos_detach),
 227
 228         /* MII interface */
 229         DEVMETHOD(miibus_readreg, mos_miibus_readreg),
 230         DEVMETHOD(miibus_writereg, mos_miibus_writereg),
 231         DEVMETHOD(miibus_statchg, mos_miibus_statchg),
 232
 233         DEVMETHOD_END
 234 };
 235
 236 static driver_t mos_driver = {
 237         .name = "mos",
 238         .methods = mos_methods,
 239         .size = sizeof(struct mos_softc)
 240 };
 241
 242 static devclass_t mos_devclass;
 243
 244 DRIVER_MODULE(mos, uhub, mos_driver, mos_devclass, NULL, 0);
 245 DRIVER_MODULE(miibus, mos, miibus_driver, miibus_devclass, 0, 0);
 246 MODULE_DEPEND(mos, uether, 1, 1, 1);
 247 MODULE_DEPEND(mos, usb, 1, 1, 1);
 248 MODULE_DEPEND(mos, ether, 1, 1, 1);
 249 MODULE_DEPEND(mos, miibus, 1, 1, 1);
 250
 251 static const struct usb_ether_methods mos_ue_methods = {
 252         .ue_attach_post = mos_attach_post,
 253         .ue_start = mos_start,
 254         .ue_init = mos_init,
 255         .ue_stop = mos_stop,
 256         .ue_tick = mos_tick,
 257         .ue_setmulti = mos_setmulti,
 258         .ue_setpromisc = mos_setpromisc,
 259         .ue_mii_upd = mos_ifmedia_upd,
 260         .ue_mii_sts = mos_ifmedia_sts,
 261 };
 262
 263
 264 static int
 265 mos_reg_read_1(struct mos_softc *sc, int reg)
 266 {
 267         struct usb_device_request req;
 268         usb_error_t err;
 269         uByte val = 0;
 270
 271         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 272         req.bRequest = MOS_UR_READREG;
 273         USETW(req.wValue, 0);
 274         USETW(req.wIndex, reg);
 275         USETW(req.wLength, 1);
 276
 277         err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 278
 279         if (err) {
 280                 MOS_DPRINTFN("mos_reg_read_1 error, reg: %d\n", reg);
 281                 return (-1);
 282         }
 283         return (val);
 284 }
 285
 286 static int
 287 mos_reg_read_2(struct mos_softc *sc, int reg)
 288 {
 289         struct usb_device_request req;
 290         usb_error_t err;
 291         uWord val;
 292
 293         USETW(val, 0);
 294
 295         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 296         req.bRequest = MOS_UR_READREG;
 297         USETW(req.wValue, 0);
 298         USETW(req.wIndex, reg);
 299         USETW(req.wLength, 2);
 300
 301         err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 302
 303         if (err) {
 304                 MOS_DPRINTFN("mos_reg_read_2 error, reg: %d", reg);
 305                 return (-1);
 306         }
 307         return (UGETW(val));
 308 }
 309
 310 static int
 311 mos_reg_write_1(struct mos_softc *sc, int reg, int aval)
 312 {
 313         struct usb_device_request req;
 314         usb_error_t err;
 315         uByte val;
 316         val = aval;
 317
 318         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 319         req.bRequest = MOS_UR_WRITEREG;
 320         USETW(req.wValue, 0);
 321         USETW(req.wIndex, reg);
 322         USETW(req.wLength, 1);
 323
 324         err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 325
 326         if (err) {
 327                 MOS_DPRINTFN("mos_reg_write_1 error, reg: %d", reg);
 328                 return (-1);
 329         }
 330         return (0);
 331 }
 332
 333 static int
 334 mos_reg_write_2(struct mos_softc *sc, int reg, int aval)
 335 {
 336         struct usb_device_request req;
 337         usb_error_t err;
 338         uWord val;
 339
 340         USETW(val, aval);
 341
 342         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 343         req.bRequest = MOS_UR_WRITEREG;
 344         USETW(req.wValue, 0);
 345         USETW(req.wIndex, reg);
 346         USETW(req.wLength, 2);
 347
 348         err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
 349
 350         if (err) {
 351                 MOS_DPRINTFN("mos_reg_write_2 error, reg: %d", reg);
 352                 return (-1);
 353         }
 354         return (0);
 355 }
 356
 357 static int
 358 mos_readmac(struct mos_softc *sc, u_char *mac)
 359 {
 360         struct usb_device_request req;
 361         usb_error_t err;
 362
 363         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 364         req.bRequest = MOS_UR_READREG;
 365         USETW(req.wValue, 0);
 366         USETW(req.wIndex, MOS_MAC);
 367         USETW(req.wLength, ETHER_ADDR_LEN);
 368
 369         err = uether_do_request(&sc->sc_ue, &req, mac, 1000);
 370
 371         if (err) {
 372                 return (-1);
 373         }
 374         return (0);
 375 }
 376
 377 static int
 378 mos_writemac(struct mos_softc *sc, uint8_t *mac)
 379 {
 380         struct usb_device_request req;
 381         usb_error_t err;
 382
 383         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 384         req.bRequest = MOS_UR_WRITEREG;
 385         USETW(req.wValue, 0);
 386         USETW(req.wIndex, MOS_MAC);
 387         USETW(req.wLength, ETHER_ADDR_LEN);
 388
 389         err = uether_do_request(&sc->sc_ue, &req, mac, 1000);
 390
 391         if (err) {
 392                 MOS_DPRINTFN("mos_writemac error");
 393                 return (-1);
 394         }
 395         return (0);
 396 }
 397
 398 static int
 399 mos_write_mcast(struct mos_softc *sc, u_char *hashtbl)
 400 {
 401         struct usb_device_request req;
 402         usb_error_t err;
 403
 404         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 405         req.bRequest = MOS_UR_WRITEREG;
 406         USETW(req.wValue, 0);
 407         USETW(req.wIndex, MOS_MCAST_TABLE);
 408         USETW(req.wLength, 8);
 409
 410         err = uether_do_request(&sc->sc_ue, &req, hashtbl, 1000);
 411
 412         if (err) {
 413                 MOS_DPRINTFN("mos_reg_mcast error");
 414                 return (-1);
 415         }
 416         return (0);
 417 }
 418
 419 static int
 420 mos_miibus_readreg(struct device *dev, int phy, int reg)
 421 {
 422         struct mos_softc *sc = device_get_softc(dev);
 423         uWord val;
 424         int i, res, locked;
 425
 426         USETW(val, 0);
 427
 428         locked = mtx_owned(&sc->sc_mtx);
 429         if (!locked)
 430                 MOS_LOCK(sc);
 431
 432         mos_reg_write_2(sc, MOS_PHY_DATA, 0);
 433         mos_reg_write_1(sc, MOS_PHY_CTL, (phy & MOS_PHYCTL_PHYADDR) |
 434             MOS_PHYCTL_READ);
 435         mos_reg_write_1(sc, MOS_PHY_STS, (reg & MOS_PHYSTS_PHYREG) |
 436             MOS_PHYSTS_PENDING);
 437
 438         for (i = 0; i < MOS_TIMEOUT; i++) {
 439                 if (mos_reg_read_1(sc, MOS_PHY_STS) & MOS_PHYSTS_READY)
 440                         break;
 441         }
 442         if (i == MOS_TIMEOUT) {
 443                 MOS_DPRINTFN("MII read timeout");
 444         }
 445         res = mos_reg_read_2(sc, MOS_PHY_DATA);
 446
 447         if (!locked)
 448                 MOS_UNLOCK(sc);
 449         return (res);
 450 }
 451
 452 static int
 453 mos_miibus_writereg(device_t dev, int phy, int reg, int val)
 454 {
 455         struct mos_softc *sc = device_get_softc(dev);
 456         int i, locked;
 457
 458         locked = mtx_owned(&sc->sc_mtx);
 459         if (!locked)
 460                 MOS_LOCK(sc);
 461
 462         mos_reg_write_2(sc, MOS_PHY_DATA, val);
 463         mos_reg_write_1(sc, MOS_PHY_CTL, (phy & MOS_PHYCTL_PHYADDR) |
 464             MOS_PHYCTL_WRITE);
 465         mos_reg_write_1(sc, MOS_PHY_STS, (reg & MOS_PHYSTS_PHYREG) |
 466             MOS_PHYSTS_PENDING);
 467
 468         for (i = 0; i < MOS_TIMEOUT; i++) {
 469                 if (mos_reg_read_1(sc, MOS_PHY_STS) & MOS_PHYSTS_READY)
 470                         break;
 471         }
 472         if (i == MOS_TIMEOUT)
 473                 MOS_DPRINTFN("MII write timeout");
 474
 475         if (!locked)
 476                 MOS_UNLOCK(sc);
 477         return 0;
 478 }
 479
 480 static void
 481 mos_miibus_statchg(device_t dev)
 482 {
 483         struct mos_softc *sc = device_get_softc(dev);
 484         struct mii_data *mii = GET_MII(sc);
 485         int val, err, locked;
 486
 487         locked = mtx_owned(&sc->sc_mtx);
 488         if (!locked)
 489                 MOS_LOCK(sc);
 490
 491         /* disable RX, TX prior to changing FDX, SPEEDSEL */
 492         val = mos_reg_read_1(sc, MOS_CTL);
 493         val &= ~(MOS_CTL_TX_ENB | MOS_CTL_RX_ENB);
 494         mos_reg_write_1(sc, MOS_CTL, val);
 495
 496         /* reset register which counts dropped frames */
 497         mos_reg_write_1(sc, MOS_FRAME_DROP_CNT, 0);
 498
 499         if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
 500                 val |= MOS_CTL_FDX_ENB;
 501         else
 502                 val &= ~(MOS_CTL_FDX_ENB);
 503
 504         switch (IFM_SUBTYPE(mii->mii_media_active)) {
 505         case IFM_100_TX:
 506                 val |= MOS_CTL_SPEEDSEL;
 507                 break;
 508         case IFM_10_T:
 509                 val &= ~(MOS_CTL_SPEEDSEL);
 510                 break;
 511         }
 512
 513         /* re-enable TX, RX */
 514         val |= (MOS_CTL_TX_ENB | MOS_CTL_RX_ENB);
 515         err = mos_reg_write_1(sc, MOS_CTL, val);
 516
 517         if (err)
 518                 MOS_DPRINTFN("media change failed");
 519
 520         if (!locked)
 521                 MOS_UNLOCK(sc);
 522 }
 523
 524 /*
 525  * Set media options.
 526  */
 527 static int
 528 mos_ifmedia_upd(struct ifnet *ifp)
 529 {
 530         struct mos_softc *sc = ifp->if_softc;
 531         struct mii_data *mii = GET_MII(sc);
 532         struct mii_softc *miisc;
 533         int error;
 534
 535         MOS_LOCK_ASSERT(sc, MA_OWNED);
 536
 537         sc->mos_link = 0;
 538         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
 539                 PHY_RESET(miisc);
 540         error = mii_mediachg(mii);
 541         return (error);
 542 }
 543
 544 /*
 545  * Report current media status.
 546  */
 547 static void
 548 mos_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 549 {
 550         struct mos_softc *sc = ifp->if_softc;
 551         struct mii_data *mii = GET_MII(sc);
 552
 553         MOS_LOCK(sc);
 554         mii_pollstat(mii);
 555
 556         ifmr->ifm_active = mii->mii_media_active;
 557         ifmr->ifm_status = mii->mii_media_status;
 558         MOS_UNLOCK(sc);
 559 }
 560
 561 static void
 562 mos_setpromisc(struct usb_ether *ue)
 563 {
 564         struct mos_softc *sc = uether_getsc(ue);
 565         struct ifnet *ifp = uether_getifp(ue);
 566
 567         uint8_t rxmode;
 568
 569         MOS_LOCK_ASSERT(sc, MA_OWNED);
 570
 571         rxmode = mos_reg_read_1(sc, MOS_CTL);
 572
 573         /* If we want promiscuous mode, set the allframes bit. */
 574         if (ifp->if_flags & IFF_PROMISC) {
 575                 rxmode |= MOS_CTL_RX_PROMISC;
 576         } else {
 577                 rxmode &= ~MOS_CTL_RX_PROMISC;
 578         }
 579
 580         mos_reg_write_1(sc, MOS_CTL, rxmode);
 581 }
 582
 583
 584
 585 static void
 586 mos_setmulti(struct usb_ether *ue)
 587 {
 588         struct mos_softc *sc = uether_getsc(ue);
 589         struct ifnet *ifp = uether_getifp(ue);
 590         struct ifmultiaddr *ifma;
 591
 592         uint32_t h = 0;
 593         uint8_t rxmode;
 594         uint8_t hashtbl[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 595         int allmulti = 0;
 596
 597         MOS_LOCK_ASSERT(sc, MA_OWNED);
 598
 599         rxmode = mos_reg_read_1(sc, MOS_CTL);
 600
 601         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC)
 602                 allmulti = 1;
 603
 604         /* get all new ones */
 605         if_maddr_rlock(ifp);
 606         TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 607                 if (ifma->ifma_addr->sa_family != AF_LINK) {
 608                         allmulti = 1;
 609                         continue;
 610                 };
 611                 h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
 612                     ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
 613                 hashtbl[h / 8] |= 1 << (h % 8);
 614         }
 615         if_maddr_runlock(ifp);
 616
 617         /* now program new ones */
 618         if (allmulti == 1) {
 619                 rxmode |= MOS_CTL_ALLMULTI;
 620                 mos_reg_write_1(sc, MOS_CTL, rxmode);
 621         } else {
 622                 rxmode &= ~MOS_CTL_ALLMULTI;
 623                 mos_write_mcast(sc, (void *)&hashtbl);
 624                 mos_reg_write_1(sc, MOS_CTL, rxmode);
 625         }
 626 }
 627
 628 static void
 629 mos_reset(struct mos_softc *sc)
 630 {
 631         uint8_t ctl;
 632
 633         ctl = mos_reg_read_1(sc, MOS_CTL);
 634         ctl &= ~(MOS_CTL_RX_PROMISC | MOS_CTL_ALLMULTI | MOS_CTL_TX_ENB |
 635             MOS_CTL_RX_ENB);
 636         /* Disable RX, TX, promiscuous and allmulticast mode */
 637         mos_reg_write_1(sc, MOS_CTL, ctl);
 638
 639         /* Reset frame drop counter register to zero */
 640         mos_reg_write_1(sc, MOS_FRAME_DROP_CNT, 0);
 641
 642         /* Wait a little while for the chip to get its brains in order. */
 643         usb_pause_mtx(&sc->sc_mtx, hz / 128);
 644         return;
 645 }
 646
 647 static void
 648 mos_chip_init(struct mos_softc *sc)
 649 {
 650         int i;
 651
 652         /*
 653          * Rev.C devices have a pause threshold register which needs to be set
 654          * at startup.
 655          */
 656         if (mos_reg_read_1(sc, MOS_PAUSE_TRHD) != -1) {
 657                 for (i = 0; i < MOS_PAUSE_REWRITES; i++)
 658                         mos_reg_write_1(sc, MOS_PAUSE_TRHD, 0);
 659         }
 660         sc->mos_phyaddrs[0] = 1;
 661         sc->mos_phyaddrs[1] = 0xFF;
 662 }
 663
 664 /*
 665  * Probe for a MCS7x30 chip.
 666  */
 667 static int
 668 mos_probe(device_t dev)
 669 {
 670         struct usb_attach_arg *uaa = device_get_ivars(dev);
 671         int retval;
 672
 673         if (uaa->usb_mode != USB_MODE_HOST)
 674                 return (ENXIO);
 675         if (uaa->info.bConfigIndex != MOS_CONFIG_IDX)
 676                 return (ENXIO);
 677         if (uaa->info.bIfaceIndex != MOS_IFACE_IDX)
 678                 return (ENXIO);
 679
 680         retval = usbd_lookup_id_by_uaa(mos_devs, sizeof(mos_devs), uaa);
 681         return (retval);
 682 }
 683
 684 /*
 685  * Attach the interface. Allocate softc structures, do ifmedia
 686  * setup and ethernet/BPF attach.
 687  */
 688 static int
 689 mos_attach(device_t dev)
 690 {
 691         struct usb_attach_arg *uaa = device_get_ivars(dev);
 692         struct mos_softc *sc = device_get_softc(dev);
 693         struct usb_ether *ue = &sc->sc_ue;
 694         uint8_t iface_index;
 695         int error;
 696
 697         sc->mos_flags = USB_GET_DRIVER_INFO(uaa);
 698
 699         device_set_usb_desc(dev);
 700         mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 701
 702         iface_index = MOS_IFACE_IDX;
 703         error = usbd_transfer_setup(uaa->device, &iface_index,
 704             sc->sc_xfer, mos_config, MOS_ENDPT_MAX,
 705             sc, &sc->sc_mtx);
 706
 707         if (error) {
 708                 device_printf(dev, "allocating USB transfers failed\n");
 709                 goto detach;
 710         }
 711         ue->ue_sc = sc;
 712         ue->ue_dev = dev;
 713         ue->ue_udev = uaa->device;
 714         ue->ue_mtx = &sc->sc_mtx;
 715         ue->ue_methods = &mos_ue_methods;
 716
 717
 718         if (sc->mos_flags & MCS7730) {
 719                 MOS_DPRINTFN("model: MCS7730");
 720         } else if (sc->mos_flags & MCS7830) {
 721                 MOS_DPRINTFN("model: MCS7830");
 722         } else if (sc->mos_flags & MCS7832) {
 723                 MOS_DPRINTFN("model: MCS7832");
 724         }
 725         error = uether_ifattach(ue);
 726         if (error) {
 727                 device_printf(dev, "could not attach interface\n");
 728                 goto detach;
 729         }
 730         return (0);
 731
 732
 733 detach:
 734         mos_detach(dev);
 735         return (ENXIO);
 736 }
 737
 738
 739 static void
 740 mos_attach_post(struct usb_ether *ue)
 741 {
 742         struct mos_softc *sc = uether_getsc(ue);
 743         int err;
 744
 745         /* Read MAC address, inform the world. */
 746         err = mos_readmac(sc, ue->ue_eaddr);
 747
 748         if (err)
 749           MOS_DPRINTFN("couldn't get MAC address");
 750
 751         MOS_DPRINTFN("address: %s", ether_sprintf(ue->ue_eaddr));
 752
 753         mos_chip_init(sc);
 754 }
 755
 756 static int
 757 mos_detach(device_t dev)
 758 {
 759         struct mos_softc *sc = device_get_softc(dev);
 760         struct usb_ether *ue = &sc->sc_ue;
 761
 762         usbd_transfer_unsetup(sc->sc_xfer, MOS_ENDPT_MAX);
 763         uether_ifdetach(ue);
 764         mtx_destroy(&sc->sc_mtx);
 765
 766         return (0);
 767 }
 768
 769
 770
 771
 772 /*
 773  * A frame has been uploaded: pass the resulting mbuf chain up to
 774  * the higher level protocols.
 775  */
 776 static void
 777 mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
 778 {
 779         struct mos_softc *sc = usbd_xfer_softc(xfer);
 780         struct usb_ether *ue = &sc->sc_ue;
 781         struct ifnet *ifp = uether_getifp(ue);
 782
 783         uint8_t rxstat = 0;
 784         uint32_t actlen;
 785         uint16_t pktlen = 0;
 786         struct usb_page_cache *pc;
 787
 788         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 789         pc = usbd_xfer_get_frame(xfer, 0);
 790
 791         switch (USB_GET_STATE(xfer)) {
 792         case USB_ST_TRANSFERRED:
 793                 MOS_DPRINTFN("actlen : %d", actlen);
 794                 if (actlen <= 1) {
 795                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 796                         goto tr_setup;
 797                 }
 798                 /* evaluate status byte at the end */
 799                 usbd_copy_out(pc, actlen - sizeof(rxstat), &rxstat,
 800                     sizeof(rxstat));
 801
 802                 if (rxstat != MOS_RXSTS_VALID) {
 803                         MOS_DPRINTFN("erroneous frame received");
 804                         if (rxstat & MOS_RXSTS_SHORT_FRAME)
 805                                 MOS_DPRINTFN("frame size less than 64 bytes");
 806                         if (rxstat & MOS_RXSTS_LARGE_FRAME) {
 807                                 MOS_DPRINTFN("frame size larger than "
 808                                     "1532 bytes");
 809                         }
 810                         if (rxstat & MOS_RXSTS_CRC_ERROR)
 811                                 MOS_DPRINTFN("CRC error");
 812                         if (rxstat & MOS_RXSTS_ALIGN_ERROR)
 813                                 MOS_DPRINTFN("alignment error");
 814                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 815                         goto tr_setup;
 816                 }
 817                 /* Remember the last byte was used for the status fields */
 818                 pktlen = actlen - 1;
 819                 if (pktlen < sizeof(struct ether_header)) {
 820                         MOS_DPRINTFN("error: pktlen %d is smaller "
 821                             "than ether_header %zd", pktlen,
 822                             sizeof(struct ether_header));
 823                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 824                         goto tr_setup;
 825                 }
 826                 uether_rxbuf(ue, pc, 0, actlen);
 827                 /* FALLTHROUGH */
 828         case USB_ST_SETUP:
 829 tr_setup:
 830                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 831                 usbd_transfer_submit(xfer);
 832                 uether_rxflush(ue);
 833                 return;
 834         default:
 835                 MOS_DPRINTFN("bulk read error, %s", usbd_errstr(error));
 836                 if (error != USB_ERR_CANCELLED) {
 837                         usbd_xfer_set_stall(xfer);
 838                         goto tr_setup;
 839                 }
 840                 MOS_DPRINTFN("start rx %i", usbd_xfer_max_len(xfer));
 841                 return;
 842         }
 843 }
 844
 845 /*
 846  * A frame was downloaded to the chip. It's safe for us to clean up
 847  * the list buffers.
 848  */
 849 static void
 850 mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
 851 {
 852         struct mos_softc *sc = usbd_xfer_softc(xfer);
 853         struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 854         struct usb_page_cache *pc;
 855         struct mbuf *m;
 856
 857
 858
 859         switch (USB_GET_STATE(xfer)) {
 860         case USB_ST_TRANSFERRED:
 861                 MOS_DPRINTFN("transfer of complete");
 862                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 863                 /* FALLTHROUGH */
 864         case USB_ST_SETUP:
 865 tr_setup:
 866                 /*
 867                  * XXX: don't send anything if there is no link?
 868                  */
 869                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
 870                 if (m == NULL)
 871                         return;
 872
 873                 pc = usbd_xfer_get_frame(xfer, 0);
 874                 usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);
 875
 876                 usbd_xfer_set_frame_len(xfer, 0, m->m_pkthdr.len);
 877
 878
 879                 /*
 880                  * if there's a BPF listener, bounce a copy
 881                  * of this frame to him:
 882                  */
 883                 BPF_MTAP(ifp, m);
 884
 885                 m_freem(m);
 886
 887                 usbd_transfer_submit(xfer);
 888
 889                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 890                 return;
 891         default:
 892                 MOS_DPRINTFN("usb error on tx: %s\n", usbd_errstr(error));
 893                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 894                 if (error != USB_ERR_CANCELLED) {
 895                         usbd_xfer_set_stall(xfer);
 896                         goto tr_setup;
 897                 }
 898                 return;
 899         }
 900 }
 901
 902 static void
 903 mos_tick(struct usb_ether *ue)
 904 {
 905         struct mos_softc *sc = uether_getsc(ue);
 906         struct mii_data *mii = GET_MII(sc);
 907
 908         MOS_LOCK_ASSERT(sc, MA_OWNED);
 909
 910         mii_tick(mii);
 911         if (!sc->mos_link && mii->mii_media_status & IFM_ACTIVE &&
 912             IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
 913                 MOS_DPRINTFN("got link");
 914                 sc->mos_link++;
 915                 mos_start(ue);
 916         }
 917 }
 918
 919
 920 static void
 921 mos_start(struct usb_ether *ue)
 922 {
 923         struct mos_softc *sc = uether_getsc(ue);
 924
 925         /*
 926          * start the USB transfers, if not already started:
 927          */
 928         usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_TX]);
 929         usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_RX]);
 930         usbd_transfer_start(sc->sc_xfer[MOS_ENDPT_INTR]);
 931 }
 932
 933 static void
 934 mos_init(struct usb_ether *ue)
 935 {
 936         struct mos_softc *sc = uether_getsc(ue);
 937         struct ifnet *ifp = uether_getifp(ue);
 938         uint8_t rxmode;
 939
 940         MOS_LOCK_ASSERT(sc, MA_OWNED);
 941
 942         /* Cancel pending I/O and free all RX/TX buffers. */
 943         mos_reset(sc);
 944
 945         /* Write MAC address */
 946         mos_writemac(sc, IF_LLADDR(ifp));
 947
 948         /* Read and set transmitter IPG values */
 949         sc->mos_ipgs[0] = mos_reg_read_1(sc, MOS_IPG0);
 950         sc->mos_ipgs[1] = mos_reg_read_1(sc, MOS_IPG1);
 951         mos_reg_write_1(sc, MOS_IPG0, sc->mos_ipgs[0]);
 952         mos_reg_write_1(sc, MOS_IPG1, sc->mos_ipgs[1]);
 953
 954         /*
 955          * Enable receiver and transmitter, bridge controls speed/duplex
 956          * mode
 957          */
 958         rxmode = mos_reg_read_1(sc, MOS_CTL);
 959         rxmode |= MOS_CTL_RX_ENB | MOS_CTL_TX_ENB | MOS_CTL_BS_ENB;
 960         rxmode &= ~(MOS_CTL_SLEEP);
 961
 962         mos_setpromisc(ue);
 963
 964         /* XXX: broadcast mode? */
 965         mos_reg_write_1(sc, MOS_CTL, rxmode);
 966
 967         /* Load the multicast filter. */
 968         mos_setmulti(ue);
 969
 970         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 971         mos_start(ue);
 972 }
 973
 974
 975 static void
 976 mos_intr_callback(struct usb_xfer *xfer, usb_error_t error)
 977 {
 978         struct mos_softc *sc = usbd_xfer_softc(xfer);
 979         struct ifnet *ifp = uether_getifp(&sc->sc_ue);
 980         struct usb_page_cache *pc;
 981         uint32_t pkt;
 982         int actlen;
 983
 984         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
 985
 986         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 987         MOS_DPRINTFN("actlen %i", actlen);
 988
 989         switch (USB_GET_STATE(xfer)) {
 990         case USB_ST_TRANSFERRED:
 991
 992                 pc = usbd_xfer_get_frame(xfer, 0);
 993                 usbd_copy_out(pc, 0, &pkt, sizeof(pkt));
 994                 /* FALLTHROUGH */
 995         case USB_ST_SETUP:
 996 tr_setup:
 997                 return;
 998         default:
 999                 if (error != USB_ERR_CANCELLED) {
1000                         usbd_xfer_set_stall(xfer);
1001                         goto tr_setup;
1002                 }
1003                 return;
1004         }
1005 }
1006
1007
1008 /*
1009  * Stop the adapter and free any mbufs allocated to the
1010  * RX and TX lists.
1011  */
1012 static void
1013 mos_stop(struct usb_ether *ue)
1014 {
1015         struct mos_softc *sc = uether_getsc(ue);
1016         struct ifnet *ifp = uether_getifp(ue);
1017
1018         mos_reset(sc);
1019
1020         MOS_LOCK_ASSERT(sc, MA_OWNED);
1021         ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1022
1023         /* stop all the transfers, if not already stopped */
1024         usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_TX]);
1025         usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_RX]);
1026         usbd_transfer_stop(sc->sc_xfer[MOS_ENDPT_INTR]);
1027
1028         sc->mos_link = 0;
1029 }