source: hybrid/branches/releng-9.0-ileiden/nanobsd/misc/patches/backport-axe-to-8.2-release-v2.patch@ 10122

Last change on this file since 10122 was 10122, checked in by richardvm, 13 years ago

cleaning
File size: 17.8 KB

  • sys/dev/usb/usbdevs

     
    10441044product ASIX AX88178            0x1780  AX88178
    10451045product ASIX AX88772            0x7720  AX88772
    10461046product ASIX AX88772A           0x772a  AX88772A USB 2.0 10/100 Ethernet
     1047product ASIX AX88772B           0x772b  AX88772B USB 2.0 10/100 Ethernet
    10471048
    10481049/* ASUS products */
    10491050product ASUS2 USBN11            0x0b05  USB-N11

  • sys/dev/usb/net/if_axereg.h

     
    9292#define AXE_CMD_SW_PHY_STATUS                   0x0021
    9393#define AXE_CMD_SW_PHY_SELECT                   0x0122
    9494
     95/* AX88772A and AX88772B only. */
     96#define AXE_CMD_READ_VLAN_CTRL                  0x4027
     97#define AXE_CMD_WRITE_VLAN_CTRL                 0x4028
     98
     99#define AXE_772B_CMD_RXCTL_WRITE_CFG            0x012A
     100
    95101#define AXE_SW_RESET_CLEAR                      0x00
    96102#define AXE_SW_RESET_RR                         0x01
    97103#define AXE_SW_RESET_RT                         0x02
    … …  
    128134#define AXE_178_RXCMD_KEEP_INVALID_CRC          0x0004
    129135#define AXE_RXCMD_BROADCAST                     0x0008
    130136#define AXE_RXCMD_MULTICAST                     0x0010
     137#define AXE_RXCMD_ACCEPT_RUNT                   0x0040  /* AX88772B */
    131138#define AXE_RXCMD_ENABLE                        0x0080
    132139#define AXE_178_RXCMD_MFB_MASK                  0x0300
    133140#define AXE_178_RXCMD_MFB_2048                  0x0000
    134141#define AXE_178_RXCMD_MFB_4096                  0x0100
    135142#define AXE_178_RXCMD_MFB_8192                  0x0200
    136143#define AXE_178_RXCMD_MFB_16384                 0x0300
     144#define AXE_772B_RXCMD_HDR_TYPE_0               0x0000
     145#define AXE_772B_RXCMD_HDR_TYPE_1               0x0100
     146#define AXE_772B_RXCMD_IPHDR_ALIGN              0x0200
     147#define AXE_772B_RXCMD_ADD_CHKSUM               0x0400
     148#define AXE_RXCMD_LOOPBACK                      0x1000  /* AX88772A/AX88772B */
    137149
    138150#define AXE_PHY_SEL_PRI         1
    139151#define AXE_PHY_SEL_SEC         0
    … …  
    172184#define AXE_PHY_MODE_REALTEK_8251CL     0x0E
    173185#define AXE_PHY_MODE_ATTANSIC           0x40
    174186
     187/* AX88772A/AX88772B only. */
     188#define AXE_SW_PHY_SELECT_EXT           0x0000
     189#define AXE_SW_PHY_SELECT_EMBEDDED      0x0001
     190#define AXE_SW_PHY_SELECT_AUTO          0x0002
     191#define AXE_SW_PHY_SELECT_SS_MII        0x0004
     192#define AXE_SW_PHY_SELECT_SS_RVRS_MII   0x0008
     193#define AXE_SW_PHY_SELECT_SS_RVRS_RMII  0x000C
     194#define AXE_SW_PHY_SELECT_SS_ENB        0x0010
     195
     196/* AX88772A/AX88772B VLAN control. */
     197#define AXE_VLAN_CTRL_ENB               0x00001000
     198#define AXE_VLAN_CTRL_STRIP             0x00002000
     199#define AXE_VLAN_CTRL_VID1_MASK         0x00000FFF
     200#define AXE_VLAN_CTRL_VID2_MASK         0x0FFF0000
     201
    175202#define AXE_BULK_BUF_SIZE       16384   /* bytes */
    176203
    177204#define AXE_CTL_READ            0x01
    … …  
    180207#define AXE_CONFIG_IDX          0       /* config number 1 */
    181208#define AXE_IFACE_IDX           0
    182209
     210/* EEPROM Map. */
     211#define AXE_EEPROM_772B_NODE_ID         0x04
     212#define AXE_EEPROM_772B_PHY_PWRCFG      0x18
     213
     214struct ax88772b_mfb {
     215        int     byte_cnt;
     216        int     threshold;
     217        int     size;
     218};
     219#define AX88772B_MFB_2K         0
     220#define AX88772B_MFB_4K         1
     221#define AX88772B_MFB_6K         2
     222#define AX88772B_MFB_8K         3
     223#define AX88772B_MFB_16K        4
     224#define AX88772B_MFB_20K        5
     225#define AX88772B_MFB_24K        6
     226#define AX88772B_MFB_32K        7
     227
    183228struct axe_sframe_hdr {
    184229        uint16_t len;
    185230        uint16_t ilen;
    … …  
    203248        int                     sc_flags;
    204249#define AXE_FLAG_LINK           0x0001
    205250#define AXE_FLAG_772            0x1000  /* AX88772 */
    206 #define AXE_FLAG_178            0x2000  /* AX88178 */
     251#define AXE_FLAG_772A           0x2000  /* AX88772A */
     252#define AXE_FLAG_772B           0x4000  /* AX88772B */
     253#define AXE_FLAG_178            0x8000  /* AX88178 */
    207254
    208255        uint8_t                 sc_ipgs[3];
    209256        uint8_t                 sc_phyaddrs[2];
     257        uint16_t                sc_pwrcfg;
     258        int                     sc_tx_bufsz;
    210259};
    211260
     261#define AXE_IS_178_FAMILY(sc)                                             \
     262        ((sc)->sc_flags & (AXE_FLAG_772 | AXE_FLAG_772A | AXE_FLAG_772B | \
     263        AXE_FLAG_178))
     264
     265#define AXE_IS_772(sc)                                                    \
     266        ((sc)->sc_flags & (AXE_FLAG_772 | AXE_FLAG_772A | AXE_FLAG_772B))
     267
    212268#define AXE_LOCK(_sc)           mtx_lock(&(_sc)->sc_mtx)
    213269#define AXE_UNLOCK(_sc)         mtx_unlock(&(_sc)->sc_mtx)
    214270#define AXE_LOCK_ASSERT(_sc, t) mtx_assert(&(_sc)->sc_mtx, t)

  • sys/dev/usb/net/if_axe.c

     
    8484#include <sys/systm.h>
    8585#include <sys/kernel.h>
    8686#include <sys/bus.h>
    87 #include <sys/linker_set.h>
    8887#include <sys/module.h>
    8988#include <sys/lock.h>
    9089#include <sys/mutex.h>
    … …  
    142141        AXE_DEV(ASIX, AX88172, 0),
    143142        AXE_DEV(ASIX, AX88178, AXE_FLAG_178),
    144143        AXE_DEV(ASIX, AX88772, AXE_FLAG_772),
    145         AXE_DEV(ASIX, AX88772A, AXE_FLAG_772),
     144        AXE_DEV(ASIX, AX88772A, AXE_FLAG_772A),
     145        AXE_DEV(ASIX, AX88772B, AXE_FLAG_772B),
    146146        AXE_DEV(ATEN, UC210T, 0),
    147147        AXE_DEV(BELKIN, F5D5055, AXE_FLAG_178),
    148148        AXE_DEV(BILLIONTON, USB2AR, 0),
    149         AXE_DEV(CISCOLINKSYS, USB200MV2, AXE_FLAG_772),
     149        AXE_DEV(CISCOLINKSYS, USB200MV2, AXE_FLAG_772A),
    150150        AXE_DEV(COREGA, FETHER_USB2_TX, 0),
    151151        AXE_DEV(DLINK, DUBE100, 0),
    152152        AXE_DEV(DLINK, DUBE100B1, AXE_FLAG_772),
    … …  
    191191static int      axe_cmd(struct axe_softc *, int, int, int, void *);
    192192static void     axe_ax88178_init(struct axe_softc *);
    193193static void     axe_ax88772_init(struct axe_softc *);
     194static void     axe_ax88772_phywake(struct axe_softc *);
     195static void     axe_ax88772a_init(struct axe_softc *);
     196static void     axe_ax88772b_init(struct axe_softc *);
    194197static int      axe_get_phyno(struct axe_softc *, int);
    195198
    196199static const struct usb_config axe_config[AXE_N_TRANSFER] = {
    … …  
    199202                .type = UE_BULK,
    200203                .endpoint = UE_ADDR_ANY,
    201204                .direction = UE_DIR_OUT,
    202                 .bufsize = AXE_BULK_BUF_SIZE,
     205                .frames = 16,
     206                .bufsize = 16 * MCLBYTES,
    203207                .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
    204208                .callback = axe_bulk_write_callback,
    205209                .timeout = 10000,       /* 10 seconds */
    … …  
    216220        },
    217221};
    218222
     223static const struct ax88772b_mfb ax88772b_mfb_table[] = {
     224        { 0x8000, 0x8001, 2048 },
     225        { 0x8100, 0x8147, 4096},
     226        { 0x8200, 0x81EB, 6144},
     227        { 0x8300, 0x83D7, 8192},
     228        { 0x8400, 0x851E, 16384},
     229        { 0x8500, 0x8666, 20480},
     230        { 0x8600, 0x87AE, 24576},
     231        { 0x8700, 0x8A3D, 32768}
     232};
     233
    219234static device_method_t axe_methods[] = {
    220235        /* Device interface */
    221236        DEVMETHOD(device_probe, axe_probe),
    … …  
    302317        axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
    303318
    304319        val = le16toh(val);
    305         if ((sc->sc_flags & AXE_FLAG_772) != 0 && reg == MII_BMSR) {
     320        if (AXE_IS_772(sc) && reg == MII_BMSR) {
    306321                /*
    307322                 * BMSR of AX88772 indicates that it supports extended
    308323                 * capability but the extended status register is
    … …  
    384399        val = 0;
    385400        if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
    386401                val |= AXE_MEDIA_FULL_DUPLEX;
    387         if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) {
     402        if (AXE_IS_178_FAMILY(sc)) {
    388403                val |= AXE_178_MEDIA_RX_EN | AXE_178_MEDIA_MAGIC;
    389404                if ((sc->sc_flags & AXE_FLAG_178) != 0)
    390405                        val |= AXE_178_MEDIA_ENCK;
    … …  
    420435
    421436        AXE_LOCK_ASSERT(sc, MA_OWNED);
    422437
    423         if (mii->mii_instance) {
    424                 struct mii_softc *miisc;
     438       if (mii->mii_instance) {
     439               struct mii_softc *miisc;
    425440
    426                 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
    427                         mii_phy_reset(miisc);
    428         }
     441               LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
     442                       mii_phy_reset(miisc);
     443       }
    429444        error = mii_mediachg(mii);
    430445        return (error);
    431446}
    … …  
    516531axe_ax88178_init(struct axe_softc *sc)
    517532{
    518533        struct usb_ether *ue;
    519         int gpio0, phymode;
     534        int gpio0, ledmode, phymode;
    520535        uint16_t eeprom, val;
    521536
    522537        ue = &sc->sc_ue;
    … …  
    530545        if (eeprom == 0xffff) {
    531546                phymode = AXE_PHY_MODE_MARVELL;
    532547                gpio0 = 1;
     548                ledmode = 0;
    533549        } else {
    534550                phymode = eeprom & 0x7f;
    535551                gpio0 = (eeprom & 0x80) ? 0 : 1;
     552                ledmode = eeprom >> 8;
    536553        }
    537554
    538555        if (bootverbose)
    539                 device_printf(sc->sc_ue.ue_dev, "EEPROM data : 0x%04x\n",
    540                     eeprom);
     556                device_printf(sc->sc_ue.ue_dev,
     557                    "EEPROM data : 0x%04x, phymode : 0x%02x\n", eeprom,
     558                    phymode);
    541559        /* Program GPIOs depending on PHY hardware. */
    542560        switch (phymode) {
    543561        case AXE_PHY_MODE_MARVELL:
    … …  
    549567                        AXE_GPIO_WRITE(AXE_GPIO0_EN | AXE_GPIO2_EN, hz / 4);
    550568                        AXE_GPIO_WRITE(AXE_GPIO0_EN | AXE_GPIO2 | AXE_GPIO2_EN,
    551569                            hz / 32);
    552                 } else
     570                } else {
    553571                        AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO1 |
    554                             AXE_GPIO1_EN, hz / 32);
     572                            AXE_GPIO1_EN, hz / 3);
     573                        if (ledmode == 1) {
     574                                AXE_GPIO_WRITE(AXE_GPIO1_EN, hz / 3);
     575                                AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN,
     576                                    hz / 3);
     577                        } else {
     578                                AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
     579                                    AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
     580                                AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
     581                                    AXE_GPIO2_EN, hz / 4);
     582                                AXE_GPIO_WRITE(AXE_GPIO1 | AXE_GPIO1_EN |
     583                                    AXE_GPIO2 | AXE_GPIO2_EN, hz / 32);
     584                        }
     585                }
    555586                break;
    556587        case AXE_PHY_MODE_CICADA:
     588        case AXE_PHY_MODE_CICADA_V2:
     589        case AXE_PHY_MODE_CICADA_V2_ASIX:
    557590                if (gpio0 == 1)
    558591                        AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM | AXE_GPIO0 |
    559592                            AXE_GPIO0_EN, hz / 32);
    … …  
    610643
    611644        axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
    612645}
    613 #undef  AXE_GPIO_WRITE
    614646
    615647static void
    616648axe_ax88772_init(struct axe_softc *sc)
    … …  
    654686}
    655687
    656688static void
     689axe_ax88772_phywake(struct axe_softc *sc)
     690{
     691        struct usb_ether *ue;
     692
     693        ue = &sc->sc_ue;
     694        if (sc->sc_phyno == AXE_772_PHY_NO_EPHY) {
     695                /* Manually select internal(embedded) PHY - MAC mode. */
     696                axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, AXE_SW_PHY_SELECT_SS_ENB |
     697                    AXE_SW_PHY_SELECT_EMBEDDED | AXE_SW_PHY_SELECT_SS_MII,
     698                    NULL);
     699                uether_pause(&sc->sc_ue, hz / 32);
     700        } else {
     701                /*
     702                 * Manually select external PHY - MAC mode.
     703                 * Reverse MII/RMII is for AX88772A PHY mode.
     704                 */
     705                axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, AXE_SW_PHY_SELECT_SS_ENB |
     706                    AXE_SW_PHY_SELECT_EXT | AXE_SW_PHY_SELECT_SS_MII, NULL);
     707                uether_pause(&sc->sc_ue, hz / 32);
     708        }
     709        /* Take PHY out of power down. */
     710        axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPPD |
     711            AXE_SW_RESET_IPRL, NULL);
     712        uether_pause(&sc->sc_ue, hz / 4);
     713        axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPRL, NULL);
     714        uether_pause(&sc->sc_ue, hz);
     715        axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
     716        uether_pause(&sc->sc_ue, hz / 32);
     717        axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_IPRL, NULL);
     718        uether_pause(&sc->sc_ue, hz / 32);
     719}
     720
     721static void
     722axe_ax88772a_init(struct axe_softc *sc)
     723{
     724        struct usb_ether *ue;
     725
     726        ue = &sc->sc_ue;
     727        /* Reload EEPROM. */
     728        AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM, hz / 32);
     729        axe_ax88772_phywake(sc);
     730        /* Stop MAC. */
     731        axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
     732}
     733
     734static void
     735axe_ax88772b_init(struct axe_softc *sc)
     736{
     737        struct usb_ether *ue;
     738        uint16_t eeprom;
     739        uint8_t *eaddr;
     740        int i;
     741
     742        ue = &sc->sc_ue;
     743        /* Reload EEPROM. */
     744        AXE_GPIO_WRITE(AXE_GPIO_RELOAD_EEPROM, hz / 32);
     745        /*
     746         * Save PHY power saving configuration(high byte) and
     747         * clear EEPROM checksum value(low byte).
     748         */
     749        axe_cmd(sc, AXE_CMD_SROM_READ, 0, AXE_EEPROM_772B_PHY_PWRCFG, &eeprom);
     750        sc->sc_pwrcfg = le16toh(eeprom) & 0xFF00;
     751
     752        /*
     753         * Auto-loaded default station address from internal ROM is
     754         * 00:00:00:00:00:00 such that an explicit access to EEPROM
     755         * is required to get real station address.
     756         */
     757        eaddr = ue->ue_eaddr;
     758        for (i = 0; i < ETHER_ADDR_LEN / 2; i++) {
     759                axe_cmd(sc, AXE_CMD_SROM_READ, 0, AXE_EEPROM_772B_NODE_ID + i,
     760                    &eeprom);
     761                eeprom = le16toh(eeprom);
     762                *eaddr++ = (uint8_t)(eeprom & 0xFF);
     763                *eaddr++ = (uint8_t)((eeprom >> 8) & 0xFF);
     764        }
     765        /* Wakeup PHY. */
     766        axe_ax88772_phywake(sc);
     767        /* Stop MAC. */
     768        axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
     769}
     770
     771#undef  AXE_GPIO_WRITE
     772
     773static void
    657774axe_reset(struct axe_softc *sc)
    658775{
    659776        struct usb_config_descriptor *cd;
    … …  
    668785
    669786        /* Wait a little while for the chip to get its brains in order. */
    670787        uether_pause(&sc->sc_ue, hz / 100);
     788
     789        /* Reinitialize controller to achieve full reset. */
     790        if (sc->sc_flags & AXE_FLAG_178)
     791                axe_ax88178_init(sc);
     792        else if (sc->sc_flags & AXE_FLAG_772)
     793                axe_ax88772_init(sc);
     794        else if (sc->sc_flags & AXE_FLAG_772A)
     795                axe_ax88772a_init(sc);
     796        else if (sc->sc_flags & AXE_FLAG_772B)
     797                axe_ax88772b_init(sc);
    671798}
    672799
    673800static void
    … …  
    691818                sc->sc_phyno = 0;
    692819        }
    693820
    694         if (sc->sc_flags & AXE_FLAG_178)
     821        /* Initialize controller and get station address. */
     822        if (sc->sc_flags & AXE_FLAG_178) {
    695823                axe_ax88178_init(sc);
    696         else if (sc->sc_flags & AXE_FLAG_772)
     824                sc->sc_tx_bufsz = 16 * 1024;
     825                axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
     826        } else if (sc->sc_flags & AXE_FLAG_772) {
    697827                axe_ax88772_init(sc);
    698 
    699         /*
    700          * Get station address.
    701          */
    702         if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772))
     828                sc->sc_tx_bufsz = 8 * 1024;
    703829                axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
    704         else
     830        } else if (sc->sc_flags & AXE_FLAG_772A) {
     831                axe_ax88772a_init(sc);
     832                sc->sc_tx_bufsz = 8 * 1024;
     833                axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
     834        } else if (sc->sc_flags & AXE_FLAG_772B) {
     835                axe_ax88772b_init(sc);
     836                sc->sc_tx_bufsz = 8 * 1024;
     837        } else
    705838                axe_cmd(sc, AXE_172_CMD_READ_NODEID, 0, 0, ue->ue_eaddr);
    706839
    707840        /*
    708841         * Fetch IPG values.
    709842         */
    710         axe_cmd(sc, AXE_CMD_READ_IPG012, 0, 0, sc->sc_ipgs);
     843        if (sc->sc_flags & (AXE_FLAG_772A | AXE_FLAG_772B)) {
     844                /* Set IPG values. */
     845                sc->sc_ipgs[0] = 0x15;
     846                sc->sc_ipgs[1] = 0x16;
     847                sc->sc_ipgs[2] = 0x1A;
     848        } else
     849                axe_cmd(sc, AXE_CMD_READ_IPG012, 0, 0, sc->sc_ipgs);
    711850}
    712851
    713852/*
    … …  
    810949                err = 0;
    811950
    812951                pc = usbd_xfer_get_frame(xfer, 0);
    813                 if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) {
     952                if (AXE_IS_178_FAMILY(sc)) {
    814953                        while (pos < actlen) {
    815954                                if ((pos + sizeof(hdr)) > actlen) {
    816955                                        /* too little data */
    … …  
    8751014        struct ifnet *ifp = uether_getifp(&sc->sc_ue);
    8761015        struct usb_page_cache *pc;
    8771016        struct mbuf *m;
    878         int pos;
     1017        int nframes, pos;
    8791018
    8801019        switch (USB_GET_STATE(xfer)) {
    8811020        case USB_ST_TRANSFERRED:
    … …  
    8921031                         */
    8931032                        return;
    8941033                }
    895                 pos = 0;
    896                 pc = usbd_xfer_get_frame(xfer, 0);
    8971034
    898                 while (1) {
    899 
     1035                for (nframes = 0; nframes < 16 &&
     1036                    !IFQ_DRV_IS_EMPTY(&ifp->if_snd); nframes++) {
    9001037                        IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
    901 
    902                         if (m == NULL) {
    903                                 if (pos > 0)
    904                                         break;  /* send out data */
    905                                 return;
    906                         }
    907                         if (m->m_pkthdr.len > MCLBYTES) {
    908                                 m->m_pkthdr.len = MCLBYTES;
    909                         }
    910                         if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) {
    911 
     1038                        if (m == NULL)
     1039                                break;
     1040                        usbd_xfer_set_frame_offset(xfer, nframes * MCLBYTES,
     1041                            nframes);
     1042                        pos = 0;
     1043                        pc = usbd_xfer_get_frame(xfer, nframes);
     1044                        if (AXE_IS_178_FAMILY(sc)) {
    9121045                                hdr.len = htole16(m->m_pkthdr.len);
    9131046                                hdr.ilen = ~hdr.len;
    914 
    9151047                                usbd_copy_in(pc, pos, &hdr, sizeof(hdr));
    916 
    9171048                                pos += sizeof(hdr);
    918 
    919                                 /*
    920                                  * NOTE: Some drivers force a short packet
    921                                  * by appending a dummy header with zero
    922                                  * length at then end of the USB transfer.
    923                                  * This driver uses the
    924                                  * USB_FORCE_SHORT_XFER flag instead.
    925                                  */
     1049                                usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
     1050                                pos += m->m_pkthdr.len;
     1051                                if ((pos % 512) == 0) {
     1052                                        hdr.len = 0;
     1053                                        hdr.ilen = 0xffff;
     1054                                        usbd_copy_in(pc, pos, &hdr,
     1055                                            sizeof(hdr));
     1056                                        pos += sizeof(hdr);
     1057                                }
     1058                        } else {
     1059                                usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
     1060                                pos += m->m_pkthdr.len;
    9261061                        }
    927                         usbd_m_copy_in(pc, pos, m, 0, m->m_pkthdr.len);
    928                         pos += m->m_pkthdr.len;
    9291062
    9301063                        /*
    9311064                         * XXX
    … …  
    9461079
    9471080                        m_freem(m);
    9481081
    949                         if (sc->sc_flags & (AXE_FLAG_772 | AXE_FLAG_178)) {
    950                                 if (pos > (AXE_BULK_BUF_SIZE - MCLBYTES - sizeof(hdr))) {
    951                                         /* send out frame(s) */
    952                                         break;
    953                                 }
    954                         } else {
    955                                 /* send out frame */
    956                                 break;
    957                         }
     1082                        /* Set frame length. */
     1083                        usbd_xfer_set_frame_len(xfer, nframes, pos);
    9581084                }
    959 
    960                 usbd_xfer_set_frame_len(xfer, 0, pos);
    961                 usbd_transfer_submit(xfer);
    962                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
     1085                if (nframes != 0) {
     1086                        usbd_xfer_set_frames(xfer, nframes);
     1087                        usbd_transfer_submit(xfer);
     1088                        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
     1089                }
    9631090                return;
    964 
     1091                /* NOTREACHED */
    9651092        default:                        /* Error */
    9661093                DPRINTFN(11, "transfer error, %s\n",
    9671094                    usbd_errstr(error));
    … …  
    10161143
    10171144        AXE_LOCK_ASSERT(sc, MA_OWNED);
    10181145
     1146        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
     1147                return;
     1148
    10191149        /* Cancel pending I/O */
    10201150        axe_stop(ue);
    10211151
     1152        axe_reset(sc);
     1153
    10221154        /* Set MAC address. */
    1023         if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772))
     1155        if (AXE_IS_178_FAMILY(sc))
    10241156                axe_cmd(sc, AXE_178_CMD_WRITE_NODEID, 0, 0, IF_LLADDR(ifp));
    10251157        else
    10261158                axe_cmd(sc, AXE_172_CMD_WRITE_NODEID, 0, 0, IF_LLADDR(ifp));
    10271159
    10281160        /* Set transmitter IPG values */
    1029         if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) {
     1161        if (AXE_IS_178_FAMILY(sc))
    10301162                axe_cmd(sc, AXE_178_CMD_WRITE_IPG012, sc->sc_ipgs[2],
    10311163                    (sc->sc_ipgs[1] << 8) | (sc->sc_ipgs[0]), NULL);
    1032         } else {
     1164        else {
    10331165                axe_cmd(sc, AXE_172_CMD_WRITE_IPG0, 0, sc->sc_ipgs[0], NULL);
    10341166                axe_cmd(sc, AXE_172_CMD_WRITE_IPG1, 0, sc->sc_ipgs[1], NULL);
    10351167                axe_cmd(sc, AXE_172_CMD_WRITE_IPG2, 0, sc->sc_ipgs[2], NULL);
    10361168        }
    10371169
    1038         /* Enable receiver, set RX mode */
     1170        /* AX88772B uses different maximum frame burst configuration. */
     1171        if (sc->sc_flags & AXE_FLAG_772B)
     1172                axe_cmd(sc, AXE_772B_CMD_RXCTL_WRITE_CFG,
     1173                    ax88772b_mfb_table[AX88772B_MFB_16K].threshold,
     1174                    ax88772b_mfb_table[AX88772B_MFB_16K].byte_cnt, NULL);
     1175
     1176        /* Enable receiver, set RX mode. */
    10391177        rxmode = (AXE_RXCMD_MULTICAST | AXE_RXCMD_ENABLE);
    1040         if (sc->sc_flags & (AXE_FLAG_178 | AXE_FLAG_772)) {
    1041 #if 0
    1042                 rxmode |= AXE_178_RXCMD_MFB_2048;       /* chip default */
    1043 #else
    1044                 /*
    1045                  * Default Rx buffer size is too small to get
    1046                  * maximum performance.
    1047                  */
    1048                 rxmode |= AXE_178_RXCMD_MFB_16384;
    1049 #endif
     1178        if (AXE_IS_178_FAMILY(sc)) {
     1179                if (sc->sc_flags & AXE_FLAG_772B) {
     1180                        /*
     1181                         * Select RX header format type 1.  Aligning IP
     1182                         * header on 4 byte boundary is not needed
     1183                         * because we always copy the received frame in
     1184                         * RX handler.
     1185                         */
     1186                        rxmode |= AXE_772B_RXCMD_HDR_TYPE_1;
     1187                } else {
     1188                        /*
     1189                         * Default Rx buffer size is too small to get
     1190                         * maximum performance.
     1191                         */
     1192                        rxmode |= AXE_178_RXCMD_MFB_16384;
     1193                }
    10501194        } else {
    10511195                rxmode |= AXE_172_RXCMD_UNICAST;
    10521196        }
    … …  
    10661210        usbd_xfer_set_stall(sc->sc_xfer[AXE_BULK_DT_WR]);
    10671211
    10681212        ifp->if_drv_flags |= IFF_DRV_RUNNING;
     1213        /* Switch to selected media. */
     1214        axe_ifmedia_upd(ifp);
    10691215        axe_start(ue);
    10701216}
    10711217
    … …  
    11071253         */
    11081254        usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_WR]);
    11091255        usbd_transfer_stop(sc->sc_xfer[AXE_BULK_DT_RD]);
    1110 
    1111         axe_reset(sc);
    11121256}
Note: See TracBrowser for help on using the repository browser.