source: trunk/openwrt/target/linux/linux-2.6/patches/generic/003-net-b44.patch @ 1932

Last change on this file since 1932 was 1932, checked in by wbx, 11 years ago

split b44 patch, fix compile warning in b44.h

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.7 KB
  • drivers/net/b44.c

    diff -Nur linux-2.6.12.5/drivers/net/b44.c linux-2.6.12.5-b44/drivers/net/b44.c
    old new  
    1 /* b44.c: Broadcom 4400 device driver. 
     1/* b44.c: Broadcom 4400/47xx device driver. 
    22 * 
    33 * Copyright (C) 2002 David S. Miller (davem@redhat.com) 
    4  * Fixed by Pekka Pietikainen (pp@ee.oulu.fi) 
     4 * Copyright (C) 2004 Pekka Pietikainen (pp@ee.oulu.fi) 
     5 * Copyright (C) 2004 Florian Schirmer (jolt@tuxbox.org) 
    56 * 
    67 * Distribute under GPL. 
    78 */ 
     
    7879        DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n"; 
    7980 
    8081MODULE_AUTHOR("Florian Schirmer, Pekka Pietikainen, David S. Miller"); 
    81 MODULE_DESCRIPTION("Broadcom 4400 10/100 PCI ethernet driver"); 
     82MODULE_DESCRIPTION("Broadcom 4400/47xx 10/100 PCI ethernet driver"); 
    8283MODULE_LICENSE("GPL"); 
    8384MODULE_VERSION(DRV_MODULE_VERSION); 
    8485 
     
    9394          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 
    9495        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B1, 
    9596          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 
     97        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4713, 
     98          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL }, 
    9699        { }     /* terminate list with empty entry */ 
    97100}; 
    98101 
     
    106109static void b44_poll_controller(struct net_device *dev); 
    107110#endif 
    108111 
    109 static inline unsigned long br32(const struct b44 *bp, unsigned long reg) 
    110 { 
    111         return readl(bp->regs + reg); 
    112 } 
    113  
    114 static inline void bw32(const struct b44 *bp,  
    115                         unsigned long reg, unsigned long val) 
    116 { 
    117         writel(val, bp->regs + reg); 
    118 } 
    119  
    120112static int b44_wait_bit(struct b44 *bp, unsigned long reg, 
    121113                        u32 bit, unsigned long timeout, const int clear) 
    122114{ 
    123115        unsigned long i; 
    124116 
    125117        for (i = 0; i < timeout; i++) { 
    126                 u32 val = br32(bp, reg); 
     118                u32 val = br32(reg); 
    127119 
    128120                if (clear && !(val & bit)) 
    129121                        break; 
     
    154146 
    155147static u32 ssb_get_core_rev(struct b44 *bp) 
    156148{ 
    157         return (br32(bp, B44_SBIDHIGH) & SBIDHIGH_RC_MASK); 
     149        return (br32(B44_SBIDHIGH) & SBIDHIGH_RC_MASK); 
    158150} 
    159151 
    160152static u32 ssb_pci_setup(struct b44 *bp, u32 cores) 
     
    165157        pci_write_config_dword(bp->pdev, SSB_BAR0_WIN, BCM4400_PCI_CORE_ADDR); 
    166158        pci_rev = ssb_get_core_rev(bp); 
    167159 
    168         val = br32(bp, B44_SBINTVEC); 
     160        val = br32(B44_SBINTVEC); 
    169161        val |= cores; 
    170         bw32(bp, B44_SBINTVEC, val); 
     162        bw32(B44_SBINTVEC, val); 
    171163 
    172         val = br32(bp, SSB_PCI_TRANS_2); 
     164        val = br32(SSB_PCI_TRANS_2); 
    173165        val |= SSB_PCI_PREF | SSB_PCI_BURST; 
    174         bw32(bp, SSB_PCI_TRANS_2, val); 
     166        bw32(SSB_PCI_TRANS_2, val); 
    175167 
    176168        pci_write_config_dword(bp->pdev, SSB_BAR0_WIN, bar_orig); 
    177169 
     
    180172 
    181173static void ssb_core_disable(struct b44 *bp) 
    182174{ 
    183         if (br32(bp, B44_SBTMSLOW) & SBTMSLOW_RESET) 
     175        if (br32(B44_SBTMSLOW) & SBTMSLOW_RESET) 
    184176                return; 
    185177 
    186         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_CLOCK)); 
     178        bw32(B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_CLOCK)); 
    187179        b44_wait_bit(bp, B44_SBTMSLOW, SBTMSLOW_REJECT, 100000, 0); 
    188180        b44_wait_bit(bp, B44_SBTMSHIGH, SBTMSHIGH_BUSY, 100000, 1); 
    189         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_FGC | SBTMSLOW_CLOCK | 
     181        bw32(B44_SBTMSLOW, (SBTMSLOW_FGC | SBTMSLOW_CLOCK | 
    190182                            SBTMSLOW_REJECT | SBTMSLOW_RESET)); 
    191         br32(bp, B44_SBTMSLOW); 
     183        br32(B44_SBTMSLOW); 
    192184        udelay(1); 
    193         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_RESET)); 
    194         br32(bp, B44_SBTMSLOW); 
     185        bw32(B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_RESET)); 
     186        br32(B44_SBTMSLOW); 
    195187        udelay(1); 
    196188} 
    197189 
     
    200192        u32 val; 
    201193 
    202194        ssb_core_disable(bp); 
    203         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_RESET | SBTMSLOW_CLOCK | SBTMSLOW_FGC)); 
    204         br32(bp, B44_SBTMSLOW); 
     195        bw32(B44_SBTMSLOW, (SBTMSLOW_RESET | SBTMSLOW_CLOCK | SBTMSLOW_FGC)); 
     196        br32(B44_SBTMSLOW); 
    205197        udelay(1); 
    206198 
    207199        /* Clear SERR if set, this is a hw bug workaround.  */ 
    208         if (br32(bp, B44_SBTMSHIGH) & SBTMSHIGH_SERR) 
    209                 bw32(bp, B44_SBTMSHIGH, 0); 
     200        if (br32(B44_SBTMSHIGH) & SBTMSHIGH_SERR) 
     201                bw32(B44_SBTMSHIGH, 0); 
    210202 
    211         val = br32(bp, B44_SBIMSTATE); 
     203        val = br32(B44_SBIMSTATE); 
    212204        if (val & (SBIMSTATE_IBE | SBIMSTATE_TO)) 
    213                 bw32(bp, B44_SBIMSTATE, val & ~(SBIMSTATE_IBE | SBIMSTATE_TO)); 
     205                bw32(B44_SBIMSTATE, val & ~(SBIMSTATE_IBE | SBIMSTATE_TO)); 
    214206 
    215         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK | SBTMSLOW_FGC)); 
    216         br32(bp, B44_SBTMSLOW); 
     207        bw32(B44_SBTMSLOW, (SBTMSLOW_CLOCK | SBTMSLOW_FGC)); 
     208        br32(B44_SBTMSLOW); 
    217209        udelay(1); 
    218210 
    219         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK)); 
    220         br32(bp, B44_SBTMSLOW); 
     211        bw32(B44_SBTMSLOW, (SBTMSLOW_CLOCK)); 
     212        br32(B44_SBTMSLOW); 
    221213        udelay(1); 
    222214} 
    223215 
     216static int b44_4713_instance; 
     217 
    224218static int ssb_core_unit(struct b44 *bp) 
    225219{ 
    226 #if 0 
    227         u32 val = br32(bp, B44_SBADMATCH0); 
    228         u32 base; 
    229  
    230         type = val & SBADMATCH0_TYPE_MASK; 
    231         switch (type) { 
    232         case 0: 
    233                 base = val & SBADMATCH0_BS0_MASK; 
    234                 break; 
    235  
    236         case 1: 
    237                 base = val & SBADMATCH0_BS1_MASK; 
    238                 break; 
    239  
    240         case 2: 
    241         default: 
    242                 base = val & SBADMATCH0_BS2_MASK; 
    243                 break; 
    244         }; 
    245 #endif 
    246         return 0; 
     220        if (bp->pdev->device == PCI_DEVICE_ID_BCM4713) 
     221                return b44_4713_instance++; 
     222        else 
     223                return 0; 
    247224} 
    248225 
    249226static int ssb_is_core_up(struct b44 *bp) 
    250227{ 
    251         return ((br32(bp, B44_SBTMSLOW) & (SBTMSLOW_RESET | SBTMSLOW_REJECT | SBTMSLOW_CLOCK)) 
     228        return ((br32(B44_SBTMSLOW) & (SBTMSLOW_RESET | SBTMSLOW_REJECT | SBTMSLOW_CLOCK)) 
    252229                == SBTMSLOW_CLOCK); 
    253230} 
    254231 
     232static void __b44_cam_read(struct b44 *bp, unsigned char *data, int index) 
     233{ 
     234        u32 val; 
     235 
     236        bw32(B44_CAM_CTRL, (CAM_CTRL_READ | 
     237                            (index << CAM_CTRL_INDEX_SHIFT))); 
     238 
     239        b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);   
     240 
     241        val = br32(B44_CAM_DATA_LO); 
     242 
     243        data[2] = (val >> 24) & 0xFF; 
     244        data[3] = (val >> 16) & 0xFF; 
     245        data[4] = (val >> 8) & 0xFF; 
     246        data[5] = (val >> 0) & 0xFF; 
     247 
     248        val = br32(B44_CAM_DATA_HI); 
     249         
     250        data[0] = (val >> 8) & 0xFF; 
     251        data[1] = (val >> 0) & 0xFF; 
     252} 
     253 
    255254static void __b44_cam_write(struct b44 *bp, unsigned char *data, int index) 
    256255{ 
    257256        u32 val; 
     
    260259        val |= ((u32) data[3]) << 16; 
    261260        val |= ((u32) data[4]) <<  8; 
    262261        val |= ((u32) data[5]) <<  0; 
    263         bw32(bp, B44_CAM_DATA_LO, val); 
     262        bw32(B44_CAM_DATA_LO, val); 
    264263        val = (CAM_DATA_HI_VALID |  
    265264               (((u32) data[0]) << 8) | 
    266265               (((u32) data[1]) << 0)); 
    267         bw32(bp, B44_CAM_DATA_HI, val); 
    268         bw32(bp, B44_CAM_CTRL, (CAM_CTRL_WRITE | 
     266        bw32(B44_CAM_DATA_HI, val); 
     267        bw32(B44_CAM_CTRL, (CAM_CTRL_WRITE | 
    269268                            (index << CAM_CTRL_INDEX_SHIFT))); 
    270269        b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);   
    271270} 
    272271 
    273272static inline void __b44_disable_ints(struct b44 *bp) 
    274273{ 
    275         bw32(bp, B44_IMASK, 0); 
     274        bw32(B44_IMASK, 0); 
    276275} 
    277276 
    278277static void b44_disable_ints(struct b44 *bp) 
     
    280279        __b44_disable_ints(bp); 
    281280 
    282281        /* Flush posted writes. */ 
    283         br32(bp, B44_IMASK); 
     282        br32(B44_IMASK); 
    284283} 
    285284 
    286285static void b44_enable_ints(struct b44 *bp) 
    287286{ 
    288         bw32(bp, B44_IMASK, bp->imask); 
     287        bw32(B44_IMASK, bp->imask); 
    289288} 
    290289 
    291290static int b44_readphy(struct b44 *bp, int reg, u32 *val) 
    292291{ 
    293292        int err; 
    294293 
    295         bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII); 
    296         bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START | 
     294        if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) 
     295                return 0; 
     296 
     297        bw32(B44_EMAC_ISTAT, EMAC_INT_MII); 
     298        bw32(B44_MDIO_DATA, (MDIO_DATA_SB_START | 
    297299                             (MDIO_OP_READ << MDIO_DATA_OP_SHIFT) | 
    298300                             (bp->phy_addr << MDIO_DATA_PMD_SHIFT) | 
    299301                             (reg << MDIO_DATA_RA_SHIFT) | 
    300302                             (MDIO_TA_VALID << MDIO_DATA_TA_SHIFT))); 
    301303        err = b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0); 
    302         *val = br32(bp, B44_MDIO_DATA) & MDIO_DATA_DATA; 
     304        *val = br32(B44_MDIO_DATA) & MDIO_DATA_DATA; 
    303305 
    304306        return err; 
    305307} 
    306308 
    307309static int b44_writephy(struct b44 *bp, int reg, u32 val) 
    308310{ 
    309         bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII); 
    310         bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START | 
     311        if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) 
     312                return 0; 
     313 
     314        bw32(B44_EMAC_ISTAT, EMAC_INT_MII); 
     315        bw32(B44_MDIO_DATA, (MDIO_DATA_SB_START | 
    311316                             (MDIO_OP_WRITE << MDIO_DATA_OP_SHIFT) | 
    312317                             (bp->phy_addr << MDIO_DATA_PMD_SHIFT) | 
    313318                             (reg << MDIO_DATA_RA_SHIFT) | 
     
    344349        u32 val; 
    345350        int err; 
    346351 
     352        if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) 
     353                return 0; 
     354 
    347355        err = b44_writephy(bp, MII_BMCR, BMCR_RESET); 
    348356        if (err) 
    349357                return err; 
     
    367375        bp->flags &= ~(B44_FLAG_TX_PAUSE | B44_FLAG_RX_PAUSE); 
    368376        bp->flags |= pause_flags; 
    369377 
    370         val = br32(bp, B44_RXCONFIG); 
     378        val = br32(B44_RXCONFIG); 
    371379        if (pause_flags & B44_FLAG_RX_PAUSE) 
    372380                val |= RXCONFIG_FLOW; 
    373381        else 
    374382                val &= ~RXCONFIG_FLOW; 
    375         bw32(bp, B44_RXCONFIG, val); 
     383        bw32(B44_RXCONFIG, val); 
    376384 
    377         val = br32(bp, B44_MAC_FLOW); 
     385        val = br32(B44_MAC_FLOW); 
    378386        if (pause_flags & B44_FLAG_TX_PAUSE) 
    379387                val |= (MAC_FLOW_PAUSE_ENAB | 
    380388                        (0xc0 & MAC_FLOW_RX_HI_WATER)); 
    381389        else 
    382390                val &= ~MAC_FLOW_PAUSE_ENAB; 
    383         bw32(bp, B44_MAC_FLOW, val); 
     391        bw32(B44_MAC_FLOW, val); 
    384392} 
    385393 
    386394static void b44_set_flow_ctrl(struct b44 *bp, u32 local, u32 remote) 
     
    414422        u32 val; 
    415423        int err; 
    416424 
     425        if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) 
     426                return 0; 
     427 
    417428        if ((err = b44_readphy(bp, B44_MII_ALEDCTRL, &val)) != 0) 
    418429                goto out; 
    419430        if ((err = b44_writephy(bp, B44_MII_ALEDCTRL, 
     
    476487 
    477488        val = &bp->hw_stats.tx_good_octets; 
    478489        for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL) { 
    479                 *val++ += br32(bp, reg); 
     490                *val++ += br32(reg); 
    480491        } 
    481492        val = &bp->hw_stats.rx_good_octets; 
    482493        for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL) { 
    483                 *val++ += br32(bp, reg); 
     494                *val++ += br32(reg); 
    484495        } 
    485496} 
    486497 
     
    506517{ 
    507518        u32 bmsr, aux; 
    508519 
     520        if (bp->phy_addr == B44_PHY_ADDR_NO_PHY) { 
     521                bp->flags |= B44_FLAG_100_BASE_T; 
     522                bp->flags |= B44_FLAG_FULL_DUPLEX; 
     523                if (!netif_carrier_ok(bp->dev)) { 
     524                        u32 val = br32(B44_TX_CTRL); 
     525                        val |= TX_CTRL_DUPLEX; 
     526                        bw32(B44_TX_CTRL, val); 
     527                        netif_carrier_on(bp->dev); 
     528                        b44_link_report(bp); 
     529                } 
     530                return; 
     531        } 
     532 
    509533        if (!b44_readphy(bp, MII_BMSR, &bmsr) && 
    510534            !b44_readphy(bp, B44_MII_AUXCTRL, &aux) && 
    511535            (bmsr != 0xffff)) { 
     
    520544 
    521545                if (!netif_carrier_ok(bp->dev) && 
    522546                    (bmsr & BMSR_LSTATUS)) { 
    523                         u32 val = br32(bp, B44_TX_CTRL); 
     547                        u32 val = br32(B44_TX_CTRL); 
    524548                        u32 local_adv, remote_adv; 
    525549 
    526550                        if (bp->flags & B44_FLAG_FULL_DUPLEX) 
    527551                                val |= TX_CTRL_DUPLEX; 
    528552                        else 
    529553                                val &= ~TX_CTRL_DUPLEX; 
    530                         bw32(bp, B44_TX_CTRL, val); 
     554                        bw32(B44_TX_CTRL, val); 
    531555 
    532556                        if (!(bp->flags & B44_FLAG_FORCE_LINK) && 
    533557                            !b44_readphy(bp, MII_ADVERTISE, &local_adv) && 
     
    572596{ 
    573597        u32 cur, cons; 
    574598 
    575         cur  = br32(bp, B44_DMATX_STAT) & DMATX_STAT_CDMASK; 
     599        cur  = br32(B44_DMATX_STAT) & DMATX_STAT_CDMASK; 
    576600        cur /= sizeof(struct dma_desc); 
    577601 
    578602        /* XXX needs updating when NETIF_F_SG is supported */ 
     
    596620            TX_BUFFS_AVAIL(bp) > B44_TX_WAKEUP_THRESH) 
    597621                netif_wake_queue(bp->dev); 
    598622 
    599         bw32(bp, B44_GPTIMER, 0); 
     623        bw32(B44_GPTIMER, 0); 
    600624} 
    601625 
    602626/* Works like this.  This chip writes a 'struct rx_header" 30 bytes 
     
    713737        u32 cons, prod; 
    714738 
    715739        received = 0; 
    716         prod  = br32(bp, B44_DMARX_STAT) & DMARX_STAT_CDMASK; 
     740        prod  = br32(B44_DMARX_STAT) & DMARX_STAT_CDMASK; 
    717741        prod /= sizeof(struct dma_desc); 
    718742        cons = bp->rx_cons; 
    719743 
     
    792816        } 
    793817 
    794818        bp->rx_cons = cons; 
    795         bw32(bp, B44_DMARX_PTR, cons * sizeof(struct dma_desc)); 
     819        bw32(B44_DMARX_PTR, cons * sizeof(struct dma_desc)); 
    796820 
    797821        return received; 
    798822} 
     
    856880 
    857881        spin_lock_irqsave(&bp->lock, flags); 
    858882 
    859         istat = br32(bp, B44_ISTAT); 
    860         imask = br32(bp, B44_IMASK); 
     883        istat = br32(B44_ISTAT); 
     884        imask = br32(B44_IMASK); 
    861885 
    862886        /* ??? What the fuck is the purpose of the interrupt mask 
    863887         * ??? register if we have to mask it out by hand anyways? 
     
    877901                               dev->name); 
    878902                } 
    879903 
    880                 bw32(bp, B44_ISTAT, istat); 
    881                 br32(bp, B44_ISTAT); 
     904                bw32(B44_ISTAT, istat); 
     905                br32(B44_ISTAT); 
    882906        } 
    883907        spin_unlock_irqrestore(&bp->lock, flags); 
    884908        return IRQ_RETVAL(handled); 
     
    965989 
    966990        wmb(); 
    967991 
    968         bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc)); 
     992        bw32(B44_DMATX_PTR, entry * sizeof(struct dma_desc)); 
    969993        if (bp->flags & B44_FLAG_BUGGY_TXPTR) 
    970                 bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc)); 
     994                bw32(B44_DMATX_PTR, entry * sizeof(struct dma_desc)); 
    971995        if (bp->flags & B44_FLAG_REORDER_BUG) 
    972                 br32(bp, B44_DMATX_PTR); 
     996                br32(B44_DMATX_PTR); 
    973997 
    974998        if (TX_BUFFS_AVAIL(bp) < 1) 
    975999                netif_stop_queue(dev); 
     
    11371161{ 
    11381162        unsigned long reg; 
    11391163 
    1140         bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ); 
     1164        bw32(B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ); 
    11411165        for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL) 
    1142                 br32(bp, reg); 
     1166                br32(reg); 
    11431167        for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL) 
    1144                 br32(bp, reg); 
     1168                br32(reg); 
    11451169} 
    11461170 
    11471171/* bp->lock is held. */ 
    11481172static void b44_chip_reset(struct b44 *bp) 
    11491173{ 
     1174        unsigned int sb_clock; 
     1175 
    11501176        if (ssb_is_core_up(bp)) { 
    1151                 bw32(bp, B44_RCV_LAZY, 0); 
    1152                 bw32(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE); 
     1177                bw32(B44_RCV_LAZY, 0); 
     1178                bw32(B44_ENET_CTRL, ENET_CTRL_DISABLE); 
    11531179                b44_wait_bit(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE, 100, 1); 
    1154                 bw32(bp, B44_DMATX_CTRL, 0); 
     1180                bw32(B44_DMATX_CTRL, 0); 
    11551181                bp->tx_prod = bp->tx_cons = 0; 
    1156                 if (br32(bp, B44_DMARX_STAT) & DMARX_STAT_EMASK) { 
     1182                if (br32(B44_DMARX_STAT) & DMARX_STAT_EMASK) { 
    11571183                        b44_wait_bit(bp, B44_DMARX_STAT, DMARX_STAT_SIDLE, 
    11581184                                     100, 0); 
    11591185                } 
    1160                 bw32(bp, B44_DMARX_CTRL, 0); 
     1186                bw32(B44_DMARX_CTRL, 0); 
    11611187                bp->rx_prod = bp->rx_cons = 0; 
    11621188        } else { 
    1163                 ssb_pci_setup(bp, (bp->core_unit == 0 ? 
    1164                                    SBINTVEC_ENET0 : 
    1165                                    SBINTVEC_ENET1)); 
     1189                if (bp->pdev->device != PCI_DEVICE_ID_BCM4713) 
     1190                        ssb_pci_setup(bp, (bp->core_unit == 0 ? 
     1191                                           SBINTVEC_ENET0 : 
     1192                                           SBINTVEC_ENET1)); 
    11661193        } 
    11671194 
    11681195        ssb_core_reset(bp); 
     
    11701197        b44_clear_stats(bp); 
    11711198 
    11721199        /* Make PHY accessible. */ 
    1173         bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE | 
    1174                              (0x0d & MDIO_CTRL_MAXF_MASK))); 
    1175         br32(bp, B44_MDIO_CTRL); 
    1176  
    1177         if (!(br32(bp, B44_DEVCTRL) & DEVCTRL_IPP)) { 
    1178                 bw32(bp, B44_ENET_CTRL, ENET_CTRL_EPSEL); 
    1179                 br32(bp, B44_ENET_CTRL); 
     1200        if (bp->pdev->device == PCI_DEVICE_ID_BCM4713) 
     1201                sb_clock = 100000000; /* 100 MHz */ 
     1202        else 
     1203                sb_clock = 62500000; /* 62.5 MHz */ 
     1204 
     1205        bw32(B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE | 
     1206                             (((sb_clock + (B44_MDC_RATIO / 2)) / B44_MDC_RATIO) 
     1207                             & MDIO_CTRL_MAXF_MASK))); 
     1208        br32(B44_MDIO_CTRL); 
     1209 
     1210        if (!(br32(B44_DEVCTRL) & DEVCTRL_IPP)) { 
     1211                bw32(B44_ENET_CTRL, ENET_CTRL_EPSEL); 
     1212                br32(B44_ENET_CTRL); 
    11801213                bp->flags &= ~B44_FLAG_INTERNAL_PHY; 
    11811214        } else { 
    1182                 u32 val = br32(bp, B44_DEVCTRL); 
     1215                u32 val = br32(B44_DEVCTRL); 
    11831216 
    11841217                if (val & DEVCTRL_EPR) { 
    1185                         bw32(bp, B44_DEVCTRL, (val & ~DEVCTRL_EPR)); 
    1186                         br32(bp, B44_DEVCTRL); 
     1218                        bw32(B44_DEVCTRL, (val & ~DEVCTRL_EPR)); 
     1219                        br32(B44_DEVCTRL); 
    11871220                        udelay(100); 
    11881221                } 
    11891222                bp->flags |= B44_FLAG_INTERNAL_PHY; 
     
    12001233/* bp->lock is held. */ 
    12011234static void __b44_set_mac_addr(struct b44 *bp) 
    12021235{ 
    1203         bw32(bp, B44_CAM_CTRL, 0); 
     1236        bw32(B44_CAM_CTRL, 0); 
    12041237        if (!(bp->dev->flags & IFF_PROMISC)) { 
    12051238                u32 val; 
    12061239 
    12071240                __b44_cam_write(bp, bp->dev->dev_addr, 0); 
    1208                 val = br32(bp, B44_CAM_CTRL); 
    1209                 bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE); 
     1241                val = br32(B44_CAM_CTRL); 
     1242                bw32(B44_CAM_CTRL, val | CAM_CTRL_ENABLE); 
    12101243        } 
    12111244} 
    12121245 
     
    12401273        b44_setup_phy(bp); 
    12411274 
    12421275        /* Enable CRC32, set proper LED modes and power on PHY */ 
    1243         bw32(bp, B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL); 
    1244         bw32(bp, B44_RCV_LAZY, (1 << RCV_LAZY_FC_SHIFT)); 
     1276        bw32(B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL); 
     1277        bw32(B44_RCV_LAZY, (1 << RCV_LAZY_FC_SHIFT)); 
    12451278 
    12461279        /* This sets the MAC address too.  */ 
    12471280        __b44_set_rx_mode(bp->dev); 
    12481281 
    12491282        /* MTU + eth header + possible VLAN tag + struct rx_header */ 
    1250         bw32(bp, B44_RXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN); 
    1251         bw32(bp, B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN); 
     1283        bw32(B44_RXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN); 
     1284        bw32(B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN); 
    12521285 
    1253         bw32(bp, B44_TX_WMARK, 56); /* XXX magic */ 
    1254         bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE); 
    1255         bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset); 
    1256         bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE | 
     1286        bw32(B44_TX_WMARK, 56); /* XXX magic */ 
     1287        bw32(B44_DMATX_CTRL, DMATX_CTRL_ENABLE); 
     1288        bw32(B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset); 
     1289        bw32(B44_DMARX_CTRL, (DMARX_CTRL_ENABLE | 
    12571290                              (bp->rx_offset << DMARX_CTRL_ROSHIFT))); 
    1258         bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset); 
     1291        bw32(B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset); 
    12591292 
    1260         bw32(bp, B44_DMARX_PTR, bp->rx_pending); 
     1293        bw32(B44_DMARX_PTR, bp->rx_pending); 
    12611294        bp->rx_prod = bp->rx_pending;    
    12621295 
    1263         bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ); 
     1296        bw32(B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ); 
    12641297 
    1265         val = br32(bp, B44_ENET_CTRL); 
    1266         bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE)); 
     1298        val = br32(B44_ENET_CTRL); 
     1299        bw32(B44_ENET_CTRL, (val | ENET_CTRL_ENABLE)); 
    12671300} 
    12681301 
    12691302static int b44_open(struct net_device *dev) 
     
    14161449        int i=0; 
    14171450        unsigned char zero[6] = {0,0,0,0,0,0}; 
    14181451 
    1419         val = br32(bp, B44_RXCONFIG); 
     1452        val = br32(B44_RXCONFIG); 
    14201453        val &= ~(RXCONFIG_PROMISC | RXCONFIG_ALLMULTI); 
    14211454        if (dev->flags & IFF_PROMISC) { 
    14221455                val |= RXCONFIG_PROMISC; 
    1423                 bw32(bp, B44_RXCONFIG, val); 
     1456                bw32(B44_RXCONFIG, val); 
    14241457        } else { 
    14251458                __b44_set_mac_addr(bp); 
    14261459 
     
    14321465                for(;i<64;i++) { 
    14331466                        __b44_cam_write(bp, zero, i);                    
    14341467                } 
    1435                 bw32(bp, B44_RXCONFIG, val); 
    1436                 val = br32(bp, B44_CAM_CTRL); 
    1437                 bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE); 
     1468                bw32(B44_RXCONFIG, val); 
     1469                val = br32(B44_CAM_CTRL); 
     1470                bw32(B44_CAM_CTRL, val | CAM_CTRL_ENABLE); 
    14381471        } 
    14391472} 
    14401473 
     
    17041737{ 
    17051738        u8 eeprom[128]; 
    17061739        int err; 
     1740        unsigned long flags; 
    17071741 
    1708         err = b44_read_eeprom(bp, &eeprom[0]); 
    1709         if (err) 
    1710                 goto out; 
    1711  
    1712         bp->dev->dev_addr[0] = eeprom[79]; 
    1713         bp->dev->dev_addr[1] = eeprom[78]; 
    1714         bp->dev->dev_addr[2] = eeprom[81]; 
    1715         bp->dev->dev_addr[3] = eeprom[80]; 
    1716         bp->dev->dev_addr[4] = eeprom[83]; 
    1717         bp->dev->dev_addr[5] = eeprom[82]; 
    1718  
    1719         bp->phy_addr = eeprom[90] & 0x1f; 
     1742        if (bp->pdev->device == PCI_DEVICE_ID_BCM4713) { 
     1743                /*  
     1744                 * BCM47xx boards don't have a EEPROM. The MAC is stored in 
     1745                 * a NVRAM area somewhere in the flash memory. As we don't 
     1746                 * know the location and/or the format of the NVRAM area 
     1747                 * here, we simply rely on the bootloader to write the 
     1748                 * MAC into the CAM. 
     1749                 */ 
     1750                spin_lock_irqsave(&bp->lock, flags); 
     1751                __b44_cam_read(bp, bp->dev->dev_addr, 0); 
     1752                spin_unlock_irqrestore(&bp->lock, flags); 
     1753 
     1754                /*  
     1755                 * BCM47xx boards don't have a PHY. Usually there is a switch 
     1756                 * chip with multiple PHYs connected to the PHY port. 
     1757                 */ 
     1758                bp->phy_addr = B44_PHY_ADDR_NO_PHY; 
     1759                bp->dma_offset = 0; 
     1760        } else { 
     1761                err = b44_read_eeprom(bp, &eeprom[0]); 
     1762                if (err) 
     1763                        return err; 
     1764 
     1765                bp->dev->dev_addr[0] = eeprom[79]; 
     1766                bp->dev->dev_addr[1] = eeprom[78]; 
     1767                bp->dev->dev_addr[2] = eeprom[81]; 
     1768                bp->dev->dev_addr[3] = eeprom[80]; 
     1769                bp->dev->dev_addr[4] = eeprom[83]; 
     1770                bp->dev->dev_addr[5] = eeprom[82]; 
     1771 
     1772                bp->phy_addr = eeprom[90] & 0x1f; 
     1773                bp->dma_offset = SB_PCI_DMA; 
     1774        }  
    17201775 
    17211776        /* With this, plus the rx_header prepended to the data by the 
    17221777         * hardware, we'll land the ethernet header on a 2-byte boundary. 
     
    17261781        bp->imask = IMASK_DEF; 
    17271782 
    17281783        bp->core_unit = ssb_core_unit(bp); 
    1729         bp->dma_offset = SB_PCI_DMA; 
    17301784 
    17311785        /* XXX - really required?  
    17321786           bp->flags |= B44_FLAG_BUGGY_TXPTR; 
    17331787         */ 
    1734 out: 
    1735         return err; 
     1788 
     1789        return 0; 
    17361790} 
    17371791 
    17381792static int __devinit b44_init_one(struct pci_dev *pdev, 
     
    18101864 
    18111865        spin_lock_init(&bp->lock); 
    18121866 
    1813         bp->regs = ioremap(b44reg_base, b44reg_len); 
     1867        bp->regs = (unsigned long) ioremap(b44reg_base, b44reg_len); 
    18141868        if (bp->regs == 0UL) { 
    18151869                printk(KERN_ERR PFX "Cannot map device registers, " 
    18161870                       "aborting.\n"); 
     
    18711925 
    18721926        pci_save_state(bp->pdev); 
    18731927 
    1874         printk(KERN_INFO "%s: Broadcom 4400 10/100BaseT Ethernet ", dev->name); 
     1928        printk(KERN_INFO "%s: Broadcom %s 10/100BaseT Ethernet ", dev->name, 
     1929                (pdev->device == PCI_DEVICE_ID_BCM4713) ? "47xx" : "4400"); 
    18751930        for (i = 0; i < 6; i++) 
    18761931                printk("%2.2x%c", dev->dev_addr[i], 
    18771932                       i == 5 ? '\n' : ':'); 
     
    18791934        return 0; 
    18801935 
    18811936err_out_iounmap: 
    1882         iounmap(bp->regs); 
     1937        iounmap((void *) bp->regs); 
    18831938 
    18841939err_out_free_dev: 
    18851940        free_netdev(dev); 
     
    19011956                struct b44 *bp = netdev_priv(dev); 
    19021957 
    19031958                unregister_netdev(dev); 
    1904                 iounmap(bp->regs); 
     1959                iounmap((void *) bp->regs); 
    19051960                free_netdev(dev); 
    19061961                pci_release_regions(pdev); 
    19071962                pci_disable_device(pdev); 
  • drivers/net/b44.h

    diff -Nur linux-2.6.12.5/drivers/net/b44.h linux-2.6.12.5-b44/drivers/net/b44.h
    old new  
    292292#define SSB_PCI_MASK1           0xfc000000 
    293293#define SSB_PCI_MASK2           0xc0000000 
    294294 
     295#define br32(REG)       readl((void *)bp->regs + (REG)) 
     296#define bw32(REG,VAL)   writel((VAL), (void *)bp->regs + (REG)) 
     297 
    295298/* 4400 PHY registers */ 
    296299#define B44_MII_AUXCTRL         24      /* Auxiliary Control */ 
    297300#define  MII_AUXCTRL_DUPLEX     0x0001  /* Full Duplex */ 
     
    345348}; 
    346349 
    347350#define B44_MCAST_TABLE_SIZE    32 
     351#define B44_PHY_ADDR_NO_PHY     30 
     352#define B44_MDC_RATIO           5000000 
    348353 
    349354/* SW copy of device statistics, kept up to date by periodic timer 
    350355 * which probes HW values.  Must have same relative layout as HW 
     
    410415        struct net_device_stats stats; 
    411416        struct b44_hw_stats     hw_stats; 
    412417 
    413         void __iomem            *regs; 
     418        unsigned long           regs; 
    414419        struct pci_dev          *pdev; 
    415420        struct net_device       *dev; 
    416421 
Note: See TracBrowser for help on using the repository browser.