Changeset 273 for freebsd-mos-driver


Ignore:
Timestamp:
Feb 13, 2011, 2:54:18 PM (14 years ago)
Author:
Rick van der Zwet
Message:

Cosmetic cleanup, remove unused code

Location:
freebsd-mos-driver
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • freebsd-mos-driver/if_mos.c

    r272 r273  
    11/*      $OpenBSD: if_mos.c,v 1.7 2009/10/13 19:33:17 pirofti Exp $      */
    2 #define USB_DEBUG 1
    3 /*
     2/*-
    43 * Copyright (c) 2011 Rick van der Zwet <info@rickvanderzwet.nl>
    54 *
    … …  
    1716 */
    1817
    19 /*
     18/*-
    2019 * Copyright (c) 2008 Johann Christian Rode <jcrode@gmx.net>
    2120 *
    … …  
    3332 */
    3433
    35 /*
     34/*-
    3635 * Copyright (c) 2005, 2006, 2007 Jonathan Gray <jsg@openbsd.org>
    3736 *
    … …  
    4948 */
    5049
    51 /*
     50/*-
    5251 * Copyright (c) 1997, 1998, 1999, 2000-2003
    5352 *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
    … …  
    8483
    8584/*
    86  * Moschip MCS7730/MCS7830 USB to Ethernet controller 
    87  * The datasheet is available at the following URL: 
     85 * Moschip MCS7730/MCS7830 USB to Ethernet controller
     86 * The datasheet is available at the following URL:
    8887 * http://www.moschip.com/data/products/MCS7830/Data%20Sheet_7830.pdf
    8988 */
    … …  
    9695 * Mixed together with the OpenBSD if_mos.c driver for validation and checking
    9796 * and the FreeBSD if_reu.c as reference for the USB Ethernet framework.
    98  */ 
     97 */
    9998
    10099#include <sys/stdint.h>
    … …  
    143142  DPRINTF("mos: %s: " fmt "\n",__FUNCTION__,## __VA_ARGS__)
    144143
    145 #define USB_PRODUCT_MOSCHIP_MCS7730     0x7730          /* MCS7730 Ethernet */
    146 #define USB_PRODUCT_SITECOMEU_LN030     0x0021          /* LN-030 */
     144#define USB_PRODUCT_MOSCHIP_MCS7730     0x7730  /* MCS7730 Ethernet */
     145#define USB_PRODUCT_SITECOMEU_LN030     0x0021  /* LN-030 */
    147146
    148147
    … …  
    152151 */
    153152static const struct usb_device_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_SITECOMEU, USB_PRODUCT_SITECOMEU_LN030 , MCS7830) },
     153        {USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7730, MCS7730)},
     154        {USB_VPI(USB_VENDOR_MOSCHIP, USB_PRODUCT_MOSCHIP_MCS7830, MCS7830)},
     155        {USB_VPI(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_LN030, MCS7830)},
    157156};
    158157
    … …  
    170169static void mos_chip_init(struct mos_softc *);
    171170static void mos_stop(struct usb_ether *);
    172 static int mos_miibus_readreg(device_t , int, int);
    173 static int mos_miibus_writereg(device_t , int, int, int);
     171static int mos_miibus_readreg(device_t, int, int);
     172static int mos_miibus_writereg(device_t, int, int, int);
    174173static void mos_miibus_statchg(device_t);
    175174static int mos_ifmedia_upd(struct ifnet *);
    … …  
    214213                .direction = UE_DIR_IN,
    215214                .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
    216                 .bufsize = 0,   /* use wMaxPacketSize */
     215                .bufsize = 0,           /* use wMaxPacketSize */
    217216                .callback = mos_intr_callback,
    218217        },
    … …  
    268267mos_reg_read_1(struct mos_softc *sc, int reg)
    269268{
    270         struct usb_device_request       req;
    271         usb_error_t                     err;
    272         uByte                           val = 0;
     269        struct usb_device_request req;
     270        usb_error_t err;
     271        uByte val = 0;
    273272
    274273        req.bmRequestType = UT_READ_VENDOR_DEVICE;
    … …  
    284283                return (-1);
    285284        }
    286 
    287285        return (val);
    288286}
    … …  
    291289mos_reg_read_2(struct mos_softc *sc, int reg)
    292290{
    293         struct usb_device_request       req;
    294         usb_error_t                     err;
    295         uWord                           val;
    296 
    297         USETW(val,0);
    298 
    299         req.bmRequestType = UT_READ_VENDOR_DEVICE;
    300         req.bRequest = MOS_UR_READREG;
    301         USETW(req.wValue, 0);
    302         USETW(req.wIndex, reg);
    303         USETW(req.wLength, 2);
    304 
    305         err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
    306 
    307         if (err) {
    308                 MOS_DPRINTFN("mos_reg_read_2 error, reg: %d", reg);
    309                 return (-1);
    310         }
    311 
    312         return(UGETW(val));
     291struct usb_device_request req;
     292usb_error_t err;
     293uWord val;
     294
     295USETW(val, 0);
     296
     297req.bmRequestType = UT_READ_VENDOR_DEVICE;
     298req.bRequest = MOS_UR_READREG;
     299USETW(req.wValue, 0);
     300USETW(req.wIndex, reg);
     301USETW(req.wLength, 2);
     302
     303err = uether_do_request(&sc->sc_ue, &req, &val, 1000);
     304
     305if (err) {
     306        MOS_DPRINTFN("mos_reg_read_2 error, reg: %d", reg);
     307        return (-1);
     308}
     309return (UGETW(val));
    313310}
    314311
    … …  
    316313mos_reg_write_1(struct mos_softc *sc, int reg, int aval)
    317314{
    318         struct usb_device_request       req;
    319         usb_error_t                     err;
    320         uByte                           val;
     315        struct usb_device_request req;
     316        usb_error_t err;
     317        uByte val;
    321318
    322319        val = aval;
    … …  
    334331                return (-1);
    335332        }
    336 
    337         return(0);
     333        return (0);
    338334}
    339335
    … …  
    341337mos_reg_write_2(struct mos_softc *sc, int reg, int aval)
    342338{
    343         struct usb_device_request       req;
    344         usb_error_t                     err;
    345         uWord                           val;
     339        struct usb_device_request req;
     340        usb_error_t err;
     341        uWord val;
    346342
    347343        USETW(val, aval);
    … …  
    359355                return (-1);
    360356        }
    361 
    362357        return (0);
    363358}
    … …  
    366361mos_readmac(struct mos_softc *sc, u_char *mac)
    367362{
    368         struct usb_device_request       req;
    369         usb_error_t                     err;
     363        struct usb_device_request req;
     364        usb_error_t err;
    370365
    371366        req.bmRequestType = UT_READ_VENDOR_DEVICE;
    … …  
    380375                return (-1);
    381376        }
    382 
    383377        return (0);
    384378}
    … …  
    387381mos_writemac(struct mos_softc *sc, uint8_t *mac)
    388382{
    389         struct usb_device_request       req;
    390         usb_error_t                     err;
     383        struct usb_device_request req;
     384        usb_error_t err;
    391385
    392386        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    … …  
    402396                return (-1);
    403397        }
    404 
    405398        return (0);
    406399}
    … …  
    409402mos_write_mcast(struct mos_softc *sc, u_char *hashtbl)
    410403{
    411         struct usb_device_request       req;
    412         usb_error_t                     err;
     404        struct usb_device_request req;
     405        usb_error_t err;
    413406
    414407        req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    … …  
    422415        if (err) {
    423416                MOS_DPRINTFN("mos_reg_mcast error");
    424                 return(-1);
    425         }
    426 
    427         return(0);
     417                return (-1);
     418        }
     419        return (0);
    428420}
    429421
    … …  
    432424{
    433425        struct mos_softc *sc = device_get_softc(dev);
    434         uWord                   val;
    435         int                     i,res, locked;
     426        uWord val;
     427        int i, res, locked;
    436428
    437429        USETW(val, 0);
    … …  
    454446                MOS_DPRINTFN("MII read timeout");
    455447        }
    456 
    457448        res = mos_reg_read_2(sc, MOS_PHY_DATA);
    458449
    … …  
    466457{
    467458        struct mos_softc *sc = device_get_softc(dev);
    468         int                     i, locked;
     459        int i, locked;
    469460
    470461        locked = mtx_owned(&sc->sc_mtx);
    … …  
    485476                MOS_DPRINTFN("MII write timeout");
    486477        }
    487 
    488478        if (!locked)
    489479                MOS_UNLOCK(sc);
    … …  
    496486        struct mos_softc *sc = device_get_softc(dev);
    497487        struct mii_data *mii = GET_MII(sc);
    498         int                     val, err, locked;
     488        int val, err, locked;
    499489
    500490        locked = mtx_owned(&sc->sc_mtx);
    … …  
    516506
    517507        switch (IFM_SUBTYPE(mii->mii_media_active)) {
    518                 case IFM_100_TX:
    519                         val |= MOS_CTL_SPEEDSEL;
    520                         break;
    521                 case IFM_10_T:
    522                         val &= ~(MOS_CTL_SPEEDSEL);
    523                         break;
     508        case IFM_100_TX:
     509                val |= MOS_CTL_SPEEDSEL;
     510                break;
     511        case IFM_10_T:
     512                val &= ~(MOS_CTL_SPEEDSEL);
     513                break;
    524514        }
    525515
    … …  
    541531mos_ifmedia_upd(struct ifnet *ifp)
    542532{
    543         struct mos_softc        *sc = ifp->if_softc;
    544         struct mii_data         *mii = GET_MII(sc);
     533        struct mos_softc *sc = ifp->if_softc;
     534        struct mii_data *mii = GET_MII(sc);
    545535
    546536        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    551541
    552542                LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
    553                         mii_phy_reset(miisc);
     543                    mii_phy_reset(miisc);
    554544        }
    555545        mii_mediachg(mii);
    … …  
    563553mos_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
    564554{
    565         struct mos_softc        *sc = ifp->if_softc;
    566         struct mii_data         *mii = GET_MII(sc);
     555        struct mos_softc *sc = ifp->if_softc;
     556        struct mii_data *mii = GET_MII(sc);
    567557
    568558        MOS_LOCK(sc);
    … …  
    580570        struct ifnet *ifp = uether_getifp(ue);
    581571
    582         u_int8_t                rxmode;
     572        u_int8_t rxmode;
    583573
    584574        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    589579        if (ifp->if_flags & IFF_PROMISC) {
    590580                rxmode |= MOS_CTL_RX_PROMISC;
    591         } else {
    592                 rxmode &= ~MOS_CTL_RX_PROMISC;
    593         }
     581        } else {
     582                rxmode &= ~MOS_CTL_RX_PROMISC;
     583        }
    594584
    595585        mos_reg_write_1(sc, MOS_CTL, rxmode);
    … …  
    603593        struct mos_softc *sc = uether_getsc(ue);
    604594        struct ifnet *ifp = uether_getifp(ue);
    605         struct ifmultiaddr      *ifma;
    606 
    607         u_int32_t               h = 0;
    608         u_int8_t                rxmode;
    609         u_int8_t                hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    610         int                     allmulti = 0;
     595        struct ifmultiaddr *ifma;
     596
     597        u_int32_t h = 0;
     598        u_int8_t rxmode;
     599        u_int8_t hashtbl[8] = {0, 0, 0, 0, 0, 0, 0, 0};
     600        int allmulti = 0;
    611601
    612602        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    625615                };
    626616                h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
    627                     ifma->ifma_addr), ETHER_ADDR_LEN)  >> 26;
     617                    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
    628618                //h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26;
    629619                hashtbl[h / 8] |= 1 << (h % 8);
    … …  
    664654mos_chip_init(struct mos_softc *sc)
    665655{
    666         int     i;
     656        int i;
    667657
    668658        /*
    … …  
    671661         */
    672662        if (mos_reg_read_1(sc, MOS_PAUSE_TRHD) != -1) {
    673                 for (i=0;i<MOS_PAUSE_REWRITES;i++)
     663                for (i = 0; i < MOS_PAUSE_REWRITES; i++)
    674664                        mos_reg_write_1(sc, MOS_PAUSE_TRHD, 0);
    675665        }
    676 
    677         sc->mos_phyaddrs[0] = 1; sc->mos_phyaddrs[1] = 0xFF;
     666        sc->mos_phyaddrs[0] = 1;
     667        sc->mos_phyaddrs[1] = 0xFF;
    678668}
    679669
    … …  
    691681                return (ENXIO);
    692682        }
    693         //uint8_t bIfaceIndex;
    694         //uint8_t bIfaceNum;
    695         //uint8_t bConfigIndex;
    696         //uint8_t bConfigNum;
    697683
    698684        if (uaa->info.bConfigNum != MOS_CONFIG_NO) {
    699                 DPRINTFN(11, "mos: not MOS_CONFIG_NO %i vs %i\n", uaa->info.bConfigNum , MOS_CONFIG_NO);
     685                DPRINTFN(11, "mos: not MOS_CONFIG_NO %i vs %i\n", uaa->info.bConfigNum, MOS_CONFIG_NO);
    700686                return (ENXIO);
    701687        }
    … …  
    704690                return (ENXIO);
    705691        }
    706 
    707692        DPRINTFN(11, "mos: probe by generic means\n");
    708693        int retval = usbd_lookup_id_by_uaa(mos_devs, sizeof(mos_devs), uaa);
     694
    709695        DPRINTFN(11, "mos: probe retval: %i (ENXIO:%i)\n", retval, ENXIO);
    710696        return retval;
    … …  
    715701 * setup and ethernet/BPF attach.
    716702 */
    717 static int 
     703static int
    718704mos_attach(device_t dev)
    719705{
    … …  
    739725                goto detach;
    740726        }
    741 
    742727        ue->ue_sc = sc;
    743728        ue->ue_dev = dev;
    … …  
    752737                DPRINTF("model: MCS7830\n");
    753738        }
    754 
    755739        error = uether_ifattach(ue);
    756740        if (error) {
    … …  
    771755{
    772756        struct mos_softc *sc = uether_getsc(ue);
     757
    773758        /*
    774759         * Read MAC address, inform the world.
    775760         */
    776761        int err = mos_readmac(sc, ue->ue_eaddr);
     762
    777763        if (err) {
    778764                MOS_DPRINTFN("couldn't get MAC address");
    … …  
    781767
    782768        mos_chip_init(sc);
    783 
    784         // ifp = GET_IFP(sc);
    785         // ifp->if_softc = sc;
    786         // ifp->if_flags = IFF_SIMPLEX | IFF_MULTICAST;
    787         // ifp->if_ioctl = mos_ioctl;
    788         // ifp->if_start = mos_start;
    789         // ifp->if_watchdog = mos_watchdog;
    790         // strlcpy(ifp->if_xname, sc->mos_dev.dv_xname, IFNAMSIZ);
    791 
    792         // IFQ_SET_READY(&ifp->if_snd);
    793         // ifp->if_capabilities = IFCAP_VLAN_MTU;
    794 
    795         sc->mos_attached = 1;
    796769}
    797770
    … …  
    819792mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
    820793{
    821         struct mos_softc        *sc = usbd_xfer_softc(xfer);
    822         struct usb_ether        *ue = &sc->sc_ue;
    823         struct ifnet            *ifp = uether_getifp(ue);
    824 
    825         uint8_t                 rxstat = 0;
    826         uint32_t                actlen;
    827         uint16_t                pktlen = 0;
     794        struct mos_softc *sc = usbd_xfer_softc(xfer);
     795        struct usb_ether *ue = &sc->sc_ue;
     796        struct ifnet *ifp = uether_getifp(ue);
     797
     798        uint8_t rxstat = 0;
     799        uint32_t actlen;
     800        uint16_t pktlen = 0;
    828801        struct usb_page_cache *pc;
    829802
    … …  
    836809                MOS_DPRINTFN("actlen : %d", actlen);
    837810                if (actlen <= 1) {
    838                         ifp->if_ierrors++;
     811                        ifp->if_ierrors++;
    839812                        goto tr_setup;
    840                 }
    841 
     813                }
    842814                /* evaluate status byte at the end */
    843815                usbd_copy_out(pc, actlen - sizeof(rxstat), &rxstat,
    … …  
    857829                        goto tr_setup;
    858830                }
    859 
    860                 /* Remember the last byte was used for the status fields */
    861                 pktlen = actlen - 1;
    862                 if ( pktlen < sizeof(struct ether_header) ) {
    863                         MOS_DPRINTFN("error: pktlen %i is smaller than ether_header %i", pktlen, sizeof(struct ether_header));
     831                /* Remember the last byte was used for the status fields */
     832                pktlen = actlen - 1;
     833                if (pktlen < sizeof(struct ether_header)) {
     834                        MOS_DPRINTFN("error: pktlen %i is smaller than ether_header %i", pktlen, sizeof(struct ether_header));
    864835                        ifp->if_ierrors++;
    865836                        goto tr_setup;
    866837                }
    867 
    868838                uether_rxbuf(ue, pc, 0, actlen);
    869   /* FALLTHROUGH */
     839                /* FALLTHROUGH */
    870840        case USB_ST_SETUP:
    871841tr_setup:
    … …  
    874844                uether_rxflush(ue);
    875845                return;
    876         default: /* Error */
     846        default:                        /* Error */
    877847                MOS_DPRINTFN("bulk read error, %s", usbd_errstr(error));
    878848                if (error != USB_ERR_CANCELLED) {
    … …  
    912882                 */
    913883                IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
    914                 if (m == NULL)
    915                         return;
    916 
    917                 pc = usbd_xfer_get_frame(xfer, 0);
     884                if (m == NULL)
     885                        return;
     886
     887                pc = usbd_xfer_get_frame(xfer, 0);
    918888                usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);
    919889
    … …  
    933903                ifp->if_opackets++;
    934904                return;
    935         default: /* Error */
     905        default:                        /* Error */
    936906                MOS_DPRINTFN("usb error on tx: %s\n", usbd_errstr(error));
    937907                ifp->if_oerrors++;
    938908                if (error != USB_ERR_CANCELLED) {
    939                   /* try to clear stall first */
    940                   usbd_xfer_set_stall(xfer);
    941                   goto tr_setup;
     909                        /* try to clear stall first */
     910                        usbd_xfer_set_stall(xfer);
     911                        goto tr_setup;
    942912                }
    943                 return;
     913                return;
    944914        }
    945915}
    … …  
    981951        struct mos_softc *sc = uether_getsc(ue);
    982952        struct ifnet *ifp = uether_getifp(ue);
    983         u_int8_t                rxmode;
     953        u_int8_t rxmode;
    984954
    985955        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    1003973        mos_reg_write_1(sc, MOS_IPG1, sc->mos_ipgs[1]);
    1004974
    1005         /* Enable receiver and transmitter, bridge controls speed/duplex mode */
     975        /*
     976         * Enable receiver and transmitter, bridge controls speed/duplex
     977         * mode
     978         */
    1006979        rxmode = mos_reg_read_1(sc, MOS_CTL);
    1007980        rxmode |= MOS_CTL_RX_ENB | MOS_CTL_TX_ENB | MOS_CTL_BS_ENB;
    1008981        rxmode &= ~(MOS_CTL_SLEEP);
    1009982
    1010         mos_setpromisc(ue);
     983        mos_setpromisc(ue);
    1011984
    1012985        /* XXX: broadcast mode? */
    … …  
    10291002        struct usb_page_cache *pc;
    10301003        int actlen;
    1031         long pkt;
     1004        long pkt;
    10321005
    10331006        ifp->if_oerrors++;
    10341007
    10351008        usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
    1036         MOS_DPRINTFN("actlen %i", actlen);
     1009        MOS_DPRINTFN("actlen %i", actlen);
    10371010
    10381011        switch (USB_GET_STATE(xfer)) {
    10391012        case USB_ST_TRANSFERRED:
    10401013
    1041                 pc = usbd_xfer_get_frame(xfer, 0);
    1042                 usbd_copy_out(pc, 0, &pkt, sizeof(pkt));
     1014                pc = usbd_xfer_get_frame(xfer, 0);
     1015                usbd_copy_out(pc, 0, &pkt, sizeof(pkt));
    10431016                /* FALLTHROUGH */
    10441017        case USB_ST_SETUP:
    … …  
    10801053        sc->mos_link = 0;
    10811054}
    1082 

  • freebsd-mos-driver/if_mosreg.h

    r176 r273  
    1 /*      $OpenBSD: if_mosreg.h,v 1.3 2008/11/22 09:46:12 deraadt Exp $   */
    2 /*
    3  * Copyright (c) 2010 Rick van der Zwet <info@rickvanderzwet.nl>
     1/*-
     2 * Copyright (c) 2010, 2011 Rick van der Zwet <info@rickvanderzwet.nl>
    43 *
    54 * Permission to use, copy, modify, and distribute this software for any
    … …  
    1615 */
    1716
    18 /*
     17/*-
    1918 * Copyright (c) 2008 Johann Christian Rode <jcrode@gmx.net>
    2019 *
    … …  
    3231 */
    3332
    34 /*
     33/*-
    3534 * Copyright (c) 1997, 1998, 1999, 2000-2003
    3635 *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
    … …  
    151150#define MOS_IFACE_IDX           0
    152151
    153 //struct mos_type {
    154 //      struct usb_devno        mos_dev;
    155 //      u_int16_t               mos_flags;
    156152#define MCS7730 0x0001          /* MCS7730 */
    157153#define MCS7830 0x0002          /* MCS7830 */
    158 //};
    159154
    160155#define MOS_INC(x, y)           (x) = (x + 1) % y
    161 
    162 //struct mos_softc;
    163 //
    164 struct mos_chain {
    165         char                    *mos_buf;
    166         struct mbuf             *mos_mbuf;
    167         int                     mos_accum;
    168         int                     mos_idx;
    169 };
    170 //
    171 //struct mos_cdata {
    172 //      struct mos_chain        mos_tx_chain[MOS_TX_LIST_CNT];
    173 //      struct mos_chain        mos_rx_chain[MOS_RX_LIST_CNT];
    174 //      int                     mos_tx_prod;
    175 //      int                     mos_tx_cons;
    176 //      int                     mos_tx_cnt;
    177 //      int                     mos_rx_prod;
    178 //};
    179156
    180157struct mos_softc {
    … …  
    182159        struct ifnet            ifp;
    183160
    184 //      struct device           mos_dev;
    185 //#define GET_MII(sc) (&(sc)->mos_mii)
    186 //#define GET_IFP(sc) (&(sc)->arpcom.ac_if)
    187 //      struct mii_data         mos_mii;
    188 //      usbd_device_handle      mos_udev;
    189 //      usbd_interface_handle   mos_iface;
    190 
    191161        u_int16_t               mos_flags;
    192 
    193 //      int                     mos_ed[MOS_ENDPT_MAX];
    194 //      usbd_pipe_handle        mos_ep[MOS_ENDPT_MAX];
    195         int                     mos_unit;
    196         int                     mos_if_flags;
    197 //      struct mos_cdata        mos_cdata;
    198 //      struct timeout          mos_stat_ch;
    199 
    200         int                     mos_refcnt;
    201         char                    mos_dying;
    202         char                    mos_attached;
    203162
    204163        int                     mos_link;
    205164        unsigned char           mos_ipgs[2];
    206165        unsigned char           mos_phyaddrs[2];
    207         struct timeval          mos_rx_notice;
    208 
    209         u_int16_t               mos_tspeed;
    210         u_int16_t               mos_maxpacket;
    211 
    212 //      struct usb_task         mos_tick_task;
    213 //      struct usb_task         mos_stop_task;
    214 
    215166
    216167        struct mtx              sc_mtx;
    217168        struct usb_xfer *sc_xfer[MOS_ENDPT_MAX];
    218 
    219         u_int                   mos_bufsz;
    220169};
    221170
Note: See TracChangeset for help on using the changeset viewer.