Changeset 271


Ignore:
Timestamp:
Feb 6, 2011, 12:49:56 PM (14 years ago)
Author:
Rick van der Zwet
Message:

Clean code:

  • static functions (usual behaviour)
  • debug statements cleanups


File:
1 edited

Legend:

Unmodified
Added
Removed

  • freebsd-mos-driver/if_mos.c

    r270 r271  
    131131#endif
    132132
     133#define MOS_DPRINTFN(fmt,...) \
     134  DPRINTF("mos: %s: " fmt "\n",__FUNCTION__,## __VA_ARGS__)
     135
    133136#define USB_PRODUCT_MOSCHIP_MCS7730     0x7730          /* MCS7730 Ethernet */
    134137#define USB_PRODUCT_SITECOMEU_LN030     0x0021          /* LN-030 */
    … …  
    145148};
    146149
    147 int mos_probe(device_t dev);
    148 int mos_attach(device_t dev);
    149 void mos_attach_post(struct usb_ether *ue);
    150 int mos_detach(device_t dev);
    151 
    152 int mos_encap(struct mos_softc *, struct mbuf *, int);
    153 void mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error);
    154 void mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error);
    155 void mos_intr_callback(struct usb_xfer *xfer, usb_error_t error);
    156 void mos_tick(struct usb_ether *);
    157 void mos_start(struct usb_ether *);
    158 void mos_init(struct usb_ether *);
    159 void mos_chip_init(struct mos_softc *);
    160 void mos_stop(struct usb_ether *);
    161 void mos_watchdog(struct usb_ether *);
    162 int mos_miibus_readreg(device_t , int, int);
    163 int mos_miibus_writereg(device_t , int, int, int);
    164 void mos_miibus_statchg(device_t);
    165 int mos_ifmedia_upd(struct ifnet *);
    166 void mos_ifmedia_sts(struct ifnet *, struct ifmediareq *);
    167 void mos_reset(struct mos_softc *sc);
    168 
    169 int mos_reg_read_1(struct mos_softc *, int);
    170 int mos_reg_read_2(struct mos_softc *, int);
    171 int mos_reg_write_1(struct mos_softc *, int, int);
    172 int mos_reg_write_2(struct mos_softc *, int, int);
    173 int mos_readmac(struct mos_softc *, uint8_t *);
    174 int mos_writemac(struct mos_softc *, uint8_t *);
    175 int mos_write_mcast(struct mos_softc *, u_char *);
    176 
    177 void mos_setmulti(struct usb_ether *);
     150static int mos_probe(device_t dev);
     151static int mos_attach(device_t dev);
     152static void mos_attach_post(struct usb_ether *ue);
     153static int mos_detach(device_t dev);
     154
     155static void mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error);
     156static void mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error);
     157static void mos_intr_callback(struct usb_xfer *xfer, usb_error_t error);
     158static void mos_tick(struct usb_ether *);
     159static void mos_start(struct usb_ether *);
     160static void mos_init(struct usb_ether *);
     161static void mos_chip_init(struct mos_softc *);
     162static void mos_stop(struct usb_ether *);
     163static int mos_miibus_readreg(device_t , int, int);
     164static int mos_miibus_writereg(device_t , int, int, int);
     165static void mos_miibus_statchg(device_t);
     166static int mos_ifmedia_upd(struct ifnet *);
     167static void mos_ifmedia_sts(struct ifnet *, struct ifmediareq *);
     168static void mos_reset(struct mos_softc *sc);
     169
     170static int mos_reg_read_1(struct mos_softc *, int);
     171static int mos_reg_read_2(struct mos_softc *, int);
     172static int mos_reg_write_1(struct mos_softc *, int, int);
     173static int mos_reg_write_2(struct mos_softc *, int, int);
     174static int mos_readmac(struct mos_softc *, uint8_t *);
     175static int mos_writemac(struct mos_softc *, uint8_t *);
     176static int mos_write_mcast(struct mos_softc *, u_char *);
     177
     178static void mos_setmulti(struct usb_ether *);
     179static void mos_setpromisc(struct usb_ether *);
    178180
    179181static const struct usb_config mos_config[MOS_ENDPT_MAX] = {
    … …  
    248250        .ue_tick = mos_tick,
    249251        .ue_setmulti = mos_setmulti,
    250         //.ue_setpromisc = mos_setpromisc,
     252        .ue_setpromisc = mos_setpromisc,
    251253        .ue_mii_upd = mos_ifmedia_upd,
    252254        .ue_mii_sts = mos_ifmedia_sts,
    … …  
    254256
    255257
    256 int
     258static int
    257259mos_reg_read_1(struct mos_softc *sc, int reg)
    258260{
    … …  
    270272
    271273        if (err) {
    272                 DPRINTF("mos_reg_read_1 error, reg: %d\n", reg);
     274                MOS_DPRINTFN("mos_reg_read_1 error, reg: %d\n", reg);
    273275                return (-1);
    274276        }
    … …  
    277279}
    278280
    279 int
     281static int
    280282mos_reg_read_2(struct mos_softc *sc, int reg)
    281283{
    … …  
    295297
    296298        if (err) {
    297                 DPRINTF("mos_reg_read_2 error, reg: %d\n", reg);
     299                MOS_DPRINTFN("mos_reg_read_2 error, reg: %d", reg);
    298300                return (-1);
    299301        }
    … …  
    302304}
    303305
    304 int
     306static int
    305307mos_reg_write_1(struct mos_softc *sc, int reg, int aval)
    306308{
    … …  
    320322
    321323        if (err) {
    322                 DPRINTF("mos_reg_write_1 error, reg: %d\n", reg);
     324                MOS_DPRINTFN("mos_reg_write_1 error, reg: %d", reg);
    323325                return (-1);
    324326        }
    … …  
    327329}
    328330
    329 int
     331static int
    330332mos_reg_write_2(struct mos_softc *sc, int reg, int aval)
    331333{
    … …  
    345347
    346348        if (err) {
    347                 DPRINTF("mos_reg_write_2 error, reg: %d\n", reg);
     349                MOS_DPRINTFN("mos_reg_write_2 error, reg: %d", reg);
    348350                return (-1);
    349351        }
    … …  
    352354}
    353355
    354 int
     356static int
    355357mos_readmac(struct mos_softc *sc, u_char *mac)
    356358{
    … …  
    373375}
    374376
    375 int
     377static int
    376378mos_writemac(struct mos_softc *sc, uint8_t *mac)
    377379{
    … …  
    388390
    389391        if (err) {
    390                 DPRINTF("mos_writemac error");
     392                MOS_DPRINTFN("mos_writemac error");
    391393                return (-1);
    392394        }
    … …  
    395397}
    396398
    397 int
     399static int
    398400mos_write_mcast(struct mos_softc *sc, u_char *hashtbl)
    399401{
    … …  
    410412
    411413        if (err) {
    412                 DPRINTF("mos_reg_mcast error\n");
     414                MOS_DPRINTFN("mos_reg_mcast error");
    413415                return(-1);
    414416        }
    … …  
    417419}
    418420
    419 int
     421static int
    420422mos_miibus_readreg(struct device *dev, int phy, int reg)
    421423{
    … …  
    441443        }
    442444        if (i == MOS_TIMEOUT) {
    443                 DPRINTF("%s: %s: MII read timeout\n", "mos", __func__);
     445                MOS_DPRINTFN("MII read timeout");
    444446        }
    445447
    … …  
    451453}
    452454
    453 int
     455static int
    454456mos_miibus_writereg(device_t dev, int phy, int reg, int val)
    455457{
    456458        struct mos_softc *sc = device_get_softc(dev);
    457459        int                     i, locked;
    458         DPRINTF("%s enter\n", __func__);
    459460
    460461        locked = mtx_owned(&sc->sc_mtx);
    … …  
    473474        }
    474475        if (i == MOS_TIMEOUT) {
    475                 DPRINTF("%s: MII write timeout\n", "mos");
     476                MOS_DPRINTFN("MII write timeout");
    476477        }
    477478
    … …  
    481482}
    482483
    483 void
     484static void
    484485mos_miibus_statchg(device_t dev)
    485486{
    … …  
    487488        struct mii_data *mii = GET_MII(sc);
    488489        int                     val, err, locked;
    489         DPRINTF("%s enter\n", __func__);
    490490
    491491        locked = mtx_owned(&sc->sc_mtx);
    … …  
    520520
    521521        if (err)
    522                 DPRINTF("%s: media change failed\n", "mos");
     522                MOS_DPRINTFN("media change failed");
    523523
    524524        if (!locked)
    … …  
    529529 * Set media options.
    530530 */
    531 int
     531static int
    532532mos_ifmedia_upd(struct ifnet *ifp)
    533533{
    … …  
    551551 * Report current media status.
    552552 */
    553 void
     553static void
    554554mos_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
    555555{
    … …  
    565565}
    566566
    567 void
     567static void
     568mos_setpromisc(struct usb_ether *ue)
     569{
     570        struct mos_softc *sc = uether_getsc(ue);
     571        struct ifnet *ifp = uether_getifp(ue);
     572
     573        u_int8_t                rxmode;
     574
     575        MOS_LOCK_ASSERT(sc, MA_OWNED);
     576
     577        rxmode = mos_reg_read_1(sc, MOS_CTL);
     578
     579        /* If we want promiscuous mode, set the allframes bit. */
     580        if (ifp->if_flags & IFF_PROMISC) {
     581                rxmode |= MOS_CTL_RX_PROMISC;
     582        } else {
     583                rxmode &= ~MOS_CTL_RX_PROMISC;
     584        }
     585
     586        mos_reg_write_1(sc, MOS_CTL, rxmode);
     587}
     588
     589
     590
     591static void
    568592mos_setmulti(struct usb_ether *ue)
    569593{
    … …  
    576600        u_int8_t                hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    577601        int                     allmulti = 0;
    578         DPRINTF("%s enter\n", __func__);
    579602
    580603        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    610633}
    611634
    612 void
     635static void
    613636mos_reset(struct mos_softc *sc)
    614637{
    615638        u_int8_t ctl;
    616         DPRINTF("%s enter\n", __func__);
    617639
    618640        ctl = mos_reg_read_1(sc, MOS_CTL);
    … …  
    630652}
    631653
    632 void
     654static void
    633655mos_chip_init(struct mos_softc *sc)
    634656{
    635657        int     i;
    636         DPRINTF("%s enter\n", __func__);
    637658
    638659        /*
    … …  
    651672 * Probe for a MCS7x30 chip.
    652673 */
    653 int
     674static int
    654675mos_probe(device_t dev)
    655676{
    … …  
    685706 * setup and ethernet/BPF attach.
    686707 */
    687 int
     708static int
    688709mos_attach(device_t dev)
    689710{
    … …  
    737758
    738759
    739 void
     760static void
    740761mos_attach_post(struct usb_ether *ue)
    741762{
    … …  
    746767        int err = mos_readmac(sc, ue->ue_eaddr);
    747768        if (err) {
    748                 DPRINTF("couldn't get MAC address\n");
    749         }
    750         DPRINTF("address: %s\n", ether_sprintf(ue->ue_eaddr));
     769                MOS_DPRINTFN("couldn't get MAC address");
     770        }
     771        MOS_DPRINTFN("address: %s", ether_sprintf(ue->ue_eaddr));
    751772
    752773        mos_chip_init(sc);
    … …  
    766787}
    767788
    768 int
     789static int
    769790mos_detach(device_t dev)
    770791{
    … …  
    786807 * the higher level protocols.
    787808 */
    788 void
     809static void
    789810mos_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
    790811{
    … …  
    798819        struct usb_page_cache *pc;
    799820
    800         DPRINTF("%s: %s: enter\n", "mos",__func__);
    801821
    802822        usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
    … …  
    805825        switch (USB_GET_STATE(xfer)) {
    806826        case USB_ST_TRANSFERRED:
    807                 DPRINTF("read_callback actlen : %d\n", actlen);
     827                MOS_DPRINTFN("actlen : %d", actlen);
    808828                if (actlen <= 1) {
    809829                        ifp->if_ierrors++;
    … …  
    816836
    817837                if (rxstat != MOS_RXSTS_VALID) {
    818                         DPRINTF("%s: erroneous frame received: ",
    819                             "mos");
     838                        MOS_DPRINTFN("erroneous frame received");
    820839                        if (rxstat & MOS_RXSTS_SHORT_FRAME)
    821                                 DPRINTF("frame size less than 64 bytes\n");
     840                                MOS_DPRINTFN("frame size less than 64 bytes");
    822841                        if (rxstat & MOS_RXSTS_LARGE_FRAME)
    823                                 DPRINTF("frame size larger than 1532 bytes\n");
     842                                MOS_DPRINTFN("frame size larger than 1532 bytes");
    824843                        if (rxstat & MOS_RXSTS_CRC_ERROR)
    825                                 DPRINTF("CRC error\n");
     844                                MOS_DPRINTFN("CRC error");
    826845                        if (rxstat & MOS_RXSTS_ALIGN_ERROR)
    827                                 DPRINTF("alignment error\n");
     846                                MOS_DPRINTFN("alignment error");
    828847                        ifp->if_ierrors++;
    829848                        goto tr_setup;
    … …  
    833852                pktlen = actlen - 1;
    834853                if ( pktlen < sizeof(struct ether_header) ) {
    835                         DPRINTF("mos: pktlen %i is smaller than ether_header %i\n", pktlen, sizeof(struct ether_header));
     854                        MOS_DPRINTFN("error: pktlen %i is smaller than ether_header %i", pktlen, sizeof(struct ether_header));
    836855                        ifp->if_ierrors++;
    837856                        goto tr_setup;
    … …  
    847866                return;
    848867        default: /* Error */
    849                 DPRINTF("bulk read error, %s\n", usbd_errstr(error));
     868                MOS_DPRINTFN("bulk read error, %s", usbd_errstr(error));
    850869                if (error != USB_ERR_CANCELLED) {
    851870                        /* try to clear stall first */
    … …  
    853872                        goto tr_setup;
    854873                }
    855                 DPRINTF("start rx %i\n", usbd_xfer_max_len(xfer));
     874                MOS_DPRINTFN("start rx %i", usbd_xfer_max_len(xfer));
    856875                return;
    857876        }
    … …  
    863882 */
    864883
    865 void
     884static void
    866885mos_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
    867886{
    … …  
    871890        struct mbuf *m;
    872891
    873         DPRINTF("%s: %s: enter\n", "mos",__func__);
    874892
    875893
    876894        switch (USB_GET_STATE(xfer)) {
    877895        case USB_ST_TRANSFERRED:
    878                 DPRINTF("transfer of complete\n");
     896                MOS_DPRINTFN("transfer of complete");
    879897                ifp->if_opackets++;
    880898                /* FALLTHROUGH */
    … …  
    907925                return;
    908926        default: /* Error */
    909                 DPRINTF("%s: usb error on tx: %s\n", "mos", usbd_errstr(error));
     927                MOS_DPRINTFN("usb error on tx: %s\n", usbd_errstr(error));
    910928                ifp->if_oerrors++;
    911929                if (error != USB_ERR_CANCELLED) {
    … …  
    918936}
    919937
    920 void
     938static void
    921939mos_tick(struct usb_ether *ue)
    922940{
    … …  
    925943
    926944        MOS_LOCK_ASSERT(sc, MA_OWNED);
    927         DPRINTF("%s: %s: enter\n", "mos", __func__);
    928945
    929946        mii_tick(mii);
    930947        if (!sc->mos_link && mii->mii_media_status & IFM_ACTIVE &&
    931948            IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
    932                 DPRINTF("%s: %s: got link\n",
    933                          "mos", __func__);
     949                MOS_DPRINTFN("got link");
    934950                sc->mos_link++;
    935951                mos_start(ue);
    … …  
    938954
    939955
    940 //int
    941 //mos_encap(struct mos_softc *sc, struct mbuf *m, int idx)
    942 //{
    943 //      struct mos_chain        *c;
    944 //      int err;
    945 //      int                     length;
    946 //
    947 //      c = &sc->mos_cdata.mos_tx_chain[idx];
    948 //
    949 //      m_copydata(m, 0, m->m_pkthdr.len, c->mos_buf);
    950 //      length = m->m_pkthdr.len;
    951 //
    952 //      c->mos_mbuf = m;
    953 //
    954 //      usbd_setup_xfer(c->mos_xfer, sc->mos_ep[MOS_ENDPT_TX],
    955 //          c, c->mos_buf, length, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
    956 //          10000, mos_txeof);
    957 //
    958 //      /* Transmit */
    959 //      err = usbd_transfer(c->mos_xfer);
    960 //      if (err != USBD_IN_PROGRESS) {
    961 //              mos_stop(sc);
    962 //              return(EIO);
    963 //      }
    964 //
    965 //      sc->mos_cdata.mos_tx_cnt++;
    966 //
    967 //      return(0);
    968 //}
    969 
    970 void
     956static void
    971957mos_start(struct usb_ether *ue)
    972958{
    … …  
    981967}
    982968
    983 void
     969static void
    984970mos_init(struct usb_ether *ue)
    985971{
    … …  
    987973        struct ifnet *ifp = uether_getifp(ue);
    988974        u_int8_t                rxmode;
    989         DPRINTF("%s enter\n", __func__);
    990975
    991976        MOS_LOCK_ASSERT(sc, MA_OWNED);
    … …  
    1014999        rxmode &= ~(MOS_CTL_SLEEP);
    10151000
    1016         /* If we want promiscuous mode, set the allframes bit. */
    1017         if (ifp->if_flags & IFF_PROMISC)
    1018                 rxmode |= MOS_CTL_RX_PROMISC;
     1001        mos_setpromisc(ue);
    10191002
    10201003        /* XXX: broadcast mode? */
    … …  
    10301013
    10311014
    1032 void
     1015static void
    10331016mos_intr_callback(struct usb_xfer *xfer, usb_error_t error)
    10341017{
    … …  
    10391022        long pkt;
    10401023
    1041         //DPRINTF("%s: %s: enter\n", "mos", __func__);
    10421024        ifp->if_oerrors++;
    10431025
    10441026        usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
    1045         DPRINTF("%s: %s: actlen %i\n", "mos", __func__, actlen);
    1046 
    1047         //XXX: Porting, how? mos_txeof(c->mos_xfer, c, stat);
     1027        MOS_DPRINTFN("actlen %i", actlen);
     1028
    10481029        switch (USB_GET_STATE(xfer)) {
    10491030        case USB_ST_TRANSFERRED:
    1050                 DPRINTF("State is ST_TRANS\n");
    10511031
    10521032                pc = usbd_xfer_get_frame(xfer, 0);
    … …  
    10551035        case USB_ST_SETUP:
    10561036tr_setup:
    1057                 DPRINTF("State is ST_SETUP\n");
    1058                 //usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
    1059                 //usbd_transfer_submit(xfer);
    10601037                return;
    10611038        default:                        /* Error */
    1062                 DPRINTF("State is default\n");
    10631039                if (error != USB_ERR_CANCELLED) {
    10641040                        /* try to clear stall first */
    … …  
    10751051 * RX and TX lists.
    10761052 */
    1077 void
     1053static void
    10781054mos_stop(struct usb_ether *ue)
    10791055{
Note: See TracChangeset for help on using the changeset viewer.