diff options
Diffstat (limited to 'drivers/staging/slicoss/slicoss.c')
| -rw-r--r-- | drivers/staging/slicoss/slicoss.c | 646 |
1 files changed, 280 insertions, 366 deletions
diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c index ac126d4f3117..062307ad7fed 100644 --- a/drivers/staging/slicoss/slicoss.c +++ b/drivers/staging/slicoss/slicoss.c @@ -124,31 +124,10 @@ static const struct pci_device_id slic_pci_tbl[] = { { 0 } }; -static struct ethtool_ops slic_ethtool_ops; +static const struct ethtool_ops slic_ethtool_ops; MODULE_DEVICE_TABLE(pci, slic_pci_tbl); -static inline void slic_reg32_write(void __iomem *reg, u32 value, bool flush) -{ - writel(value, reg); - if (flush) - mb(); -} - -static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg, - u32 value, void __iomem *regh, u32 paddrh, - bool flush) -{ - unsigned long flags; - - spin_lock_irqsave(&adapter->bit64reglock, flags); - writel(paddrh, regh); - writel(value, reg); - if (flush) - mb(); - spin_unlock_irqrestore(&adapter->bit64reglock, flags); -} - static void slic_mcast_set_bit(struct adapter *adapter, char *address) { unsigned char crcpoly; @@ -172,8 +151,6 @@ static void slic_mcast_set_bit(struct adapter *adapter, char *address) static void slic_mcast_set_mask(struct adapter *adapter) { - __iomem struct slic_regs *slic_regs = adapter->slic_regs; - if (adapter->macopts & (MAC_ALLMCAST | MAC_PROMISC)) { /* * Turn on all multicast addresses. We have to do this for @@ -181,18 +158,17 @@ static void slic_mcast_set_mask(struct adapter *adapter) * Microcode from having to keep state about the MAC * configuration. */ - slic_reg32_write(&slic_regs->slic_mcastlow, 0xFFFFFFFF, FLUSH); - slic_reg32_write(&slic_regs->slic_mcasthigh, 0xFFFFFFFF, - FLUSH); + slic_write32(adapter, SLIC_REG_MCASTLOW, 0xFFFFFFFF); + slic_write32(adapter, SLIC_REG_MCASTHIGH, 0xFFFFFFFF); } else { /* * Commit our multicast mast to the SLIC by writing to the * multicast address mask registers */ - slic_reg32_write(&slic_regs->slic_mcastlow, - (u32)(adapter->mcastmask & 0xFFFFFFFF), FLUSH); - slic_reg32_write(&slic_regs->slic_mcasthigh, - (u32)((adapter->mcastmask >> 32) & 0xFFFFFFFF), FLUSH); + slic_write32(adapter, SLIC_REG_MCASTLOW, + (u32)(adapter->mcastmask & 0xFFFFFFFF)); + slic_write32(adapter, SLIC_REG_MCASTHIGH, + (u32)((adapter->mcastmask >> 32) & 0xFFFFFFFF)); } } @@ -208,13 +184,6 @@ static void slic_timer_ping(ulong dev) add_timer(&adapter->pingtimer); } -static void slic_unmap_mmio_space(struct adapter *adapter) -{ - if (adapter->slic_regs) - iounmap(adapter->slic_regs); - adapter->slic_regs = NULL; -} - /* * slic_link_config * @@ -224,7 +193,6 @@ static void slic_unmap_mmio_space(struct adapter *adapter) static void slic_link_config(struct adapter *adapter, u32 linkspeed, u32 linkduplex) { - u32 __iomem *wphy; u32 speed; u32 duplex; u32 phy_config; @@ -239,8 +207,6 @@ static void slic_link_config(struct adapter *adapter, if (linkduplex > LINK_AUTOD) linkduplex = LINK_AUTOD; - wphy = &adapter->slic_regs->slic_wphy; - if ((linkspeed == LINK_AUTOSPEED) || (linkspeed == LINK_1000MB)) { if (adapter->flags & ADAPT_FLAGS_FIBERMEDIA) { /* @@ -252,7 +218,7 @@ static void slic_link_config(struct adapter *adapter, phy_advreg = (MIICR_REG_4 | (PAR_ADV1000XFD)); /* enable PAUSE frames */ phy_advreg |= PAR_ASYMPAUSE_FIBER; - slic_reg32_write(wphy, phy_advreg, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_advreg); if (linkspeed == LINK_AUTOSPEED) { /* reset phy, enable auto-neg */ @@ -260,14 +226,17 @@ static void slic_link_config(struct adapter *adapter, (MIICR_REG_PCR | (PCR_RESET | PCR_AUTONEG | PCR_AUTONEG_RST)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); } else { /* forced 1000 Mb FD*/ /* * power down phy to break link * this may not work) */ phy_config = (MIICR_REG_PCR | PCR_POWERDOWN); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); + slic_flush_write(adapter); /* * wait, Marvell says 1 sec, * try to get away with 10 ms @@ -282,7 +251,8 @@ static void slic_link_config(struct adapter *adapter, (MIICR_REG_PCR | (PCR_RESET | PCR_SPEED_1000 | PCR_DUPLEX_FULL)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); } } else { /* copper gigabit */ @@ -309,10 +279,10 @@ static void slic_link_config(struct adapter *adapter, phy_advreg |= PAR_ASYMPAUSE; /* required by the Cicada PHY */ phy_advreg |= PAR_802_3; - slic_reg32_write(wphy, phy_advreg, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_advreg); /* advertise FD only @1000 Mb */ phy_gctlreg = (MIICR_REG_9 | (PGC_ADV1000FD)); - slic_reg32_write(wphy, phy_gctlreg, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_gctlreg); if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) { /* @@ -321,20 +291,23 @@ static void slic_link_config(struct adapter *adapter, */ phy_config = (MIICR_REG_16 | (MRV_REG16_XOVERON)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); /* reset phy, enable auto-neg */ phy_config = (MIICR_REG_PCR | (PCR_RESET | PCR_AUTONEG | PCR_AUTONEG_RST)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); } else { /* it's a Cicada PHY */ /* enable and restart auto-neg (don't reset) */ phy_config = (MIICR_REG_PCR | (PCR_AUTONEG | PCR_AUTONEG_RST)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, + phy_config); } } } else { @@ -354,13 +327,13 @@ static void slic_link_config(struct adapter *adapter, * disable auto crossover */ phy_config = (MIICR_REG_16 | (MRV_REG16_XOVEROFF)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_config); } /* power down phy to break link (this may not work) */ phy_config = (MIICR_REG_PCR | (PCR_POWERDOWN | speed | duplex)); - slic_reg32_write(wphy, phy_config, FLUSH); - + slic_write32(adapter, SLIC_REG_WPHY, phy_config); + slic_flush_write(adapter); /* wait, Marvell says 1 sec, try to get away with 10 ms */ mdelay(10); @@ -372,11 +345,11 @@ static void slic_link_config(struct adapter *adapter, */ phy_config = (MIICR_REG_PCR | (PCR_RESET | speed | duplex)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_config); } else { /* it's a Cicada PHY */ /* disable auto-neg, set speed, powerup */ phy_config = (MIICR_REG_PCR | (speed | duplex)); - slic_reg32_write(wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_config); } } } @@ -386,7 +359,6 @@ static int slic_card_download_gbrcv(struct adapter *adapter) const struct firmware *fw; const char *file = ""; int ret; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; u32 codeaddr; u32 instruction; int index = 0; @@ -427,27 +399,28 @@ static int slic_card_download_gbrcv(struct adapter *adapter) break; } /* start download */ - slic_reg32_write(&slic_regs->slic_rcv_wcs, SLIC_RCVWCS_BEGIN, FLUSH); + slic_write32(adapter, SLIC_REG_RCV_WCS, SLIC_RCVWCS_BEGIN); /* download the rcv sequencer ucode */ for (codeaddr = 0; codeaddr < rcvucodelen; codeaddr++) { /* write out instruction address */ - slic_reg32_write(&slic_regs->slic_rcv_wcs, codeaddr, FLUSH); + slic_write32(adapter, SLIC_REG_RCV_WCS, codeaddr); instruction = *(u32 *)(fw->data + index); index += 4; /* write out the instruction data low addr */ - slic_reg32_write(&slic_regs->slic_rcv_wcs, instruction, FLUSH); + slic_write32(adapter, SLIC_REG_RCV_WCS, instruction); instruction = *(u8 *)(fw->data + index); index++; /* write out the instruction data high addr */ - slic_reg32_write(&slic_regs->slic_rcv_wcs, (u8)instruction, - FLUSH); + slic_write32(adapter, SLIC_REG_RCV_WCS, instruction); } /* download finished */ release_firmware(fw); - slic_reg32_write(&slic_regs->slic_rcv_wcs, SLIC_RCVWCS_FINISH, FLUSH); + slic_write32(adapter, SLIC_REG_RCV_WCS, SLIC_RCVWCS_FINISH); + slic_flush_write(adapter); + return 0; } @@ -462,7 +435,6 @@ static int slic_card_download(struct adapter *adapter) u32 section; int thissectionsize; int codeaddr; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; u32 instruction; u32 baseaddress; u32 i; @@ -506,17 +478,17 @@ static int slic_card_download(struct adapter *adapter) for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) { /* Write out instruction address */ - slic_reg32_write(&slic_regs->slic_wcs, - baseaddress + codeaddr, FLUSH); + slic_write32(adapter, SLIC_REG_WCS, + baseaddress + codeaddr); /* Write out instruction to low addr */ - slic_reg32_write(&slic_regs->slic_wcs, - instruction, FLUSH); + slic_write32(adapter, SLIC_REG_WCS, + instruction); instruction = *(u32 *)(fw->data + index); index += 4; /* Write out instruction to high addr */ - slic_reg32_write(&slic_regs->slic_wcs, - instruction, FLUSH); + slic_write32(adapter, SLIC_REG_WCS, + instruction); instruction = *(u32 *)(fw->data + index); index += 4; } @@ -531,27 +503,25 @@ static int slic_card_download(struct adapter *adapter) for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) { /* Write out instruction address */ - slic_reg32_write(&slic_regs->slic_wcs, - SLIC_WCS_COMPARE | (baseaddress + codeaddr), - FLUSH); + slic_write32(adapter, SLIC_REG_WCS, + SLIC_WCS_COMPARE | (baseaddress + + codeaddr)); /* Write out instruction to low addr */ - slic_reg32_write(&slic_regs->slic_wcs, instruction, - FLUSH); + slic_write32(adapter, SLIC_REG_WCS, instruction); instruction = *(u32 *)(fw->data + index); index += 4; /* Write out instruction to high addr */ - slic_reg32_write(&slic_regs->slic_wcs, instruction, - FLUSH); + slic_write32(adapter, SLIC_REG_WCS, instruction); instruction = *(u32 *)(fw->data + index); index += 4; - } } release_firmware(fw); /* Everything OK, kick off the card */ mdelay(10); - slic_reg32_write(&slic_regs->slic_wcs, SLIC_WCS_START, FLUSH); + slic_write32(adapter, SLIC_REG_WCS, SLIC_WCS_START); + slic_flush_write(adapter); /* * stall for 20 ms, long enough for ucode to init card * and reach mainloop @@ -583,19 +553,21 @@ static void slic_adapter_set_hwaddr(struct adapter *adapter) static void slic_intagg_set(struct adapter *adapter, u32 value) { - slic_reg32_write(&adapter->slic_regs->slic_intagg, value, FLUSH); + slic_write32(adapter, SLIC_REG_INTAGG, value); adapter->card->loadlevel_current = value; } static void slic_soft_reset(struct adapter *adapter) { if (adapter->card->state == CARD_UP) { - slic_reg32_write(&adapter->slic_regs->slic_quiesce, 0, FLUSH); + slic_write32(adapter, SLIC_REG_QUIESCE, 0); + slic_flush_write(adapter); mdelay(1); } - slic_reg32_write(&adapter->slic_regs->slic_reset, SLIC_RESET_MAGIC, - FLUSH); + slic_write32(adapter, SLIC_REG_RESET, SLIC_RESET_MAGIC); + slic_flush_write(adapter); + mdelay(1); } @@ -603,17 +575,16 @@ static void slic_mac_address_config(struct adapter *adapter) { u32 value; u32 value2; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; value = ntohl(*(__be32 *)&adapter->currmacaddr[2]); - slic_reg32_write(&slic_regs->slic_wraddral, value, FLUSH); - slic_reg32_write(&slic_regs->slic_wraddrbl, value, FLUSH); + slic_write32(adapter, SLIC_REG_WRADDRAL, value); + slic_write32(adapter, SLIC_REG_WRADDRBL, value); value2 = (u32)((adapter->currmacaddr[0] << 8 | adapter->currmacaddr[1]) & 0xFFFF); - slic_reg32_write(&slic_regs->slic_wraddrah, value2, FLUSH); - slic_reg32_write(&slic_regs->slic_wraddrbh, value2, FLUSH); + slic_write32(adapter, SLIC_REG_WRADDRAH, value2); + slic_write32(adapter, SLIC_REG_WRADDRBH, value2); /* * Write our multicast mask out to the card. This is done @@ -626,7 +597,6 @@ static void slic_mac_address_config(struct adapter *adapter) static void slic_mac_config(struct adapter *adapter) { u32 value; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; /* Setup GMAC gaps */ if (adapter->linkspeed == LINK_1000MB) { @@ -650,7 +620,7 @@ static void slic_mac_config(struct adapter *adapter) } /* write mac config */ - slic_reg32_write(&slic_regs->slic_wmcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WMCFG, value); /* setup mac addresses */ slic_mac_address_config(adapter); @@ -660,7 +630,6 @@ static void slic_config_set(struct adapter *adapter, bool linkchange) { u32 value; u32 RcrReset; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; if (linkchange) { /* Setup MAC */ @@ -677,7 +646,7 @@ static void slic_config_set(struct adapter *adapter, bool linkchange) GXCR_XMTEN | /* Enable transmit */ GXCR_PAUSEEN); /* Enable pause */ - slic_reg32_write(&slic_regs->slic_wxcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WXCFG, value); /* Setup rcvcfg last */ value = (RcrReset | /* Reset, if linkchange */ @@ -690,7 +659,7 @@ static void slic_config_set(struct adapter *adapter, bool linkchange) value = (GXCR_RESET | /* Always reset */ GXCR_XMTEN); /* Enable transmit */ - slic_reg32_write(&slic_regs->slic_wxcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WXCFG, value); /* Setup rcvcfg last */ value = (RcrReset | /* Reset, if linkchange */ @@ -707,7 +676,7 @@ static void slic_config_set(struct adapter *adapter, bool linkchange) if (adapter->macopts & MAC_PROMISC) value |= GRCR_RCVALL; - slic_reg32_write(&slic_regs->slic_wrcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WRCFG, value); } /* @@ -717,24 +686,23 @@ static void slic_config_clear(struct adapter *adapter) { u32 value; u32 phy_config; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; /* Setup xmtcfg */ value = (GXCR_RESET | /* Always reset */ GXCR_PAUSEEN); /* Enable pause */ - slic_reg32_write(&slic_regs->slic_wxcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WXCFG, value); value = (GRCR_RESET | /* Always reset */ GRCR_CTLEN | /* Enable CTL frames */ GRCR_ADDRAEN | /* Address A enable */ (GRCR_HASHSIZE << GRCR_HASHSIZE_SHIFT)); - slic_reg32_write(&slic_regs->slic_wrcfg, value, FLUSH); + slic_write32(adapter, SLIC_REG_WRCFG, value); /* power down phy */ phy_config = (MIICR_REG_PCR | (PCR_POWERDOWN)); - slic_reg32_write(&slic_regs->slic_wphy, phy_config, FLUSH); + slic_write32(adapter, SLIC_REG_WPHY, phy_config); } static bool slic_mac_filter(struct adapter *adapter, @@ -810,13 +778,11 @@ static void slic_timer_load_check(ulong cardaddr) { struct sliccard *card = (struct sliccard *)cardaddr; struct adapter *adapter = card->master; - u32 __iomem *intagg; u32 load = card->events; u32 level = 0; if ((adapter) && (adapter->state == ADAPT_UP) && (card->state == CARD_UP) && (slic_global.dynamic_intagg)) { - intagg = &adapter->slic_regs->slic_intagg; if (adapter->devid == SLIC_1GB_DEVICE_ID) { if (adapter->linkspeed == LINK_1000MB) level = 100; @@ -836,7 +802,7 @@ static void slic_timer_load_check(ulong cardaddr) } if (card->loadlevel_current != level) { card->loadlevel_current = level; - slic_reg32_write(intagg, level, FLUSH); + slic_write32(adapter, SLIC_REG_INTAGG, level); } } else { if (load > SLIC_LOAD_5) @@ -853,7 +819,7 @@ static void slic_timer_load_check(ulong cardaddr) level = SLIC_INTAGG_0; if (card->loadlevel_current != level) { card->loadlevel_current = level; - slic_reg32_write(intagg, level, FLUSH); + slic_write32(adapter, SLIC_REG_INTAGG, level); } } } @@ -897,7 +863,6 @@ static int slic_upr_queue_request(struct adapter *adapter, static void slic_upr_start(struct adapter *adapter) { struct slic_upr *upr; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; upr = adapter->upr_list; if (!upr) @@ -909,31 +874,27 @@ static void slic_upr_start(struct adapter *adapter) switch (upr->upr_request) { case SLIC_UPR_STATS: if (upr->upr_data_h == 0) { - slic_reg32_write(&slic_regs->slic_stats, upr->upr_data, - FLUSH); + slic_write32(adapter, SLIC_REG_RSTAT, upr->upr_data); } else { - slic_reg64_write(adapter, &slic_regs->slic_stats64, - upr->upr_data, - &slic_regs->slic_addr_upper, - upr->upr_data_h, FLUSH); + slic_write64(adapter, SLIC_REG_RSTAT64, upr->upr_data, + upr->upr_data_h); } break; case SLIC_UPR_RLSR: - slic_reg64_write(adapter, &slic_regs->slic_rlsr, upr->upr_data, - &slic_regs->slic_addr_upper, upr->upr_data_h, - FLUSH); + slic_write64(adapter, SLIC_REG_LSTAT, upr->upr_data, + upr->upr_data_h); break; case SLIC_UPR_RCONFIG: - slic_reg64_write(adapter, &slic_regs->slic_rconfig, - upr->upr_data, &slic_regs->slic_addr_upper, - upr->upr_data_h, FLUSH); + slic_write64(adapter, SLIC_REG_RCONFIG, upr->upr_data, + upr->upr_data_h); break; case SLIC_UPR_PING: - slic_reg32_write(&slic_regs->slic_ping, 1, FLUSH); + slic_write32(adapter, SLIC_REG_PING, 1); break; } + slic_flush_write(adapter); } static int slic_upr_request(struct adapter *adapter, @@ -961,42 +922,34 @@ err_unlock_irq: static void slic_link_upr_complete(struct adapter *adapter, u32 isr) { - u32 linkstatus = adapter->pshmem->linkstatus; + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; + u32 lst = sm_data->lnkstatus; uint linkup; unsigned char linkspeed; unsigned char linkduplex; if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) { - struct slic_shmem *pshmem; + dma_addr_t phaddr = sm->lnkstatus_phaddr; - pshmem = (struct slic_shmem *)(unsigned long) - adapter->phys_shmem; -#if BITS_PER_LONG == 64 - slic_upr_queue_request(adapter, - SLIC_UPR_RLSR, - SLIC_GET_ADDR_LOW(&pshmem->linkstatus), - SLIC_GET_ADDR_HIGH(&pshmem->linkstatus), + slic_upr_queue_request(adapter, SLIC_UPR_RLSR, + cpu_to_le32(lower_32_bits(phaddr)), + cpu_to_le32(upper_32_bits(phaddr)), 0, 0); -#else - slic_upr_queue_request(adapter, - SLIC_UPR_RLSR, - (u32)&pshmem->linkstatus, - SLIC_GET_ADDR_HIGH(pshmem), 0, 0); -#endif return; } if (adapter->state != ADAPT_UP) return; - linkup = linkstatus & GIG_LINKUP ? LINK_UP : LINK_DOWN; - if (linkstatus & GIG_SPEED_1000) + linkup = lst & GIG_LINKUP ? LINK_UP : LINK_DOWN; + if (lst & GIG_SPEED_1000) linkspeed = LINK_1000MB; - else if (linkstatus & GIG_SPEED_100) + else if (lst & GIG_SPEED_100) linkspeed = LINK_100MB; else linkspeed = LINK_10MB; - if (linkstatus & GIG_FULLDUPLEX) + if (lst & GIG_FULLDUPLEX) linkduplex = LINK_FULLD; else linkduplex = LINK_HALFD; @@ -1016,6 +969,7 @@ static void slic_link_upr_complete(struct adapter *adapter, u32 isr) /* link has gone from up to down */ if (linkup == LINK_DOWN) { adapter->linkstate = LINK_DOWN; + netif_carrier_off(adapter->netdev); return; } @@ -1027,7 +981,7 @@ static void slic_link_upr_complete(struct adapter *adapter, u32 isr) /* setup the mac */ slic_config_set(adapter, true); adapter->linkstate = LINK_UP; - netif_start_queue(adapter->netdev); + netif_carrier_on(adapter->netdev); } } @@ -1047,81 +1001,65 @@ static void slic_upr_request_complete(struct adapter *adapter, u32 isr) upr->next = NULL; adapter->upr_busy = 0; switch (upr->upr_request) { - case SLIC_UPR_STATS: - { - struct slic_stats *slicstats = - (struct slic_stats *)&adapter->pshmem->inicstats; - struct slic_stats *newstats = slicstats; - struct slic_stats *old = &adapter->inicstats_prev; - struct slicnet_stats *stst = &adapter->slic_stats; - - if (isr & ISR_UPCERR) { - dev_err(&adapter->netdev->dev, - "SLIC_UPR_STATS command failed isr[%x]\n", - isr); - - break; - } - UPDATE_STATS_GB(stst->tcp.xmit_tcp_segs, - newstats->xmit_tcp_segs_gb, - old->xmit_tcp_segs_gb); - - UPDATE_STATS_GB(stst->tcp.xmit_tcp_bytes, - newstats->xmit_tcp_bytes_gb, - old->xmit_tcp_bytes_gb); - - UPDATE_STATS_GB(stst->tcp.rcv_tcp_segs, - newstats->rcv_tcp_segs_gb, - old->rcv_tcp_segs_gb); - - UPDATE_STATS_GB(stst->tcp.rcv_tcp_bytes, - newstats->rcv_tcp_bytes_gb, - old->rcv_tcp_bytes_gb); - - UPDATE_STATS_GB(stst->iface.xmt_bytes, - newstats->xmit_bytes_gb, - old->xmit_bytes_gb); - - UPDATE_STATS_GB(stst->iface.xmt_ucast, - newstats->xmit_unicasts_gb, - old->xmit_unicasts_gb); - - UPDATE_STATS_GB(stst->iface.rcv_bytes, - newstats->rcv_bytes_gb, - old->rcv_bytes_gb); - - UPDATE_STATS_GB(stst->iface.rcv_ucast, - newstats->rcv_unicasts_gb, - old->rcv_unicasts_gb); - - UPDATE_STATS_GB(stst->iface.xmt_errors, - newstats->xmit_collisions_gb, - old->xmit_collisions_gb); - - UPDATE_STATS_GB(stst->iface.xmt_errors, - newstats->xmit_excess_collisions_gb, - old->xmit_excess_collisions_gb); - - UPDATE_STATS_GB(stst->iface.xmt_errors, - newstats->xmit_other_error_gb, - old->xmit_other_error_gb); - - UPDATE_STATS_GB(stst->iface.rcv_errors, - newstats->rcv_other_error_gb, - old->rcv_other_error_gb); - - UPDATE_STATS_GB(stst->iface.rcv_discards, - newstats->rcv_drops_gb, - old->rcv_drops_gb); - - if (newstats->rcv_drops_gb > old->rcv_drops_gb) { - adapter->rcv_drops += - (newstats->rcv_drops_gb - - old->rcv_drops_gb); - } - memcpy(old, newstats, sizeof(struct slic_stats)); + case SLIC_UPR_STATS: { + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; + struct slic_stats *stats = &sm_data->stats; + struct slic_stats *old = &adapter->inicstats_prev; + struct slicnet_stats *stst = &adapter->slic_stats; + + if (isr & ISR_UPCERR) { + dev_err(&adapter->netdev->dev, + "SLIC_UPR_STATS command failed isr[%x]\n", isr); break; } + + UPDATE_STATS_GB(stst->tcp.xmit_tcp_segs, stats->xmit_tcp_segs, + old->xmit_tcp_segs); + + UPDATE_STATS_GB(stst->tcp.xmit_tcp_bytes, stats->xmit_tcp_bytes, + old->xmit_tcp_bytes); + + UPDATE_STATS_GB(stst->tcp.rcv_tcp_segs, stats->rcv_tcp_segs, + old->rcv_tcp_segs); + + UPDATE_STATS_GB(stst->tcp.rcv_tcp_bytes, stats->rcv_tcp_bytes, + old->rcv_tcp_bytes); + + UPDATE_STATS_GB(stst->iface.xmt_bytes, stats->xmit_bytes, + old->xmit_bytes); + + UPDATE_STATS_GB(stst->iface.xmt_ucast, stats->xmit_unicasts, + old->xmit_unicasts); + + UPDATE_STATS_GB(stst->iface.rcv_bytes, stats->rcv_bytes, + old->rcv_bytes); + + UPDATE_STATS_GB(stst->iface.rcv_ucast, stats->rcv_unicasts, + old->rcv_unicasts); + + UPDATE_STATS_GB(stst->iface.xmt_errors, stats->xmit_collisions, + old->xmit_collisions); + + UPDATE_STATS_GB(stst->iface.xmt_errors, + stats->xmit_excess_collisions, + old->xmit_excess_collisions); + + UPDATE_STATS_GB(stst->iface.xmt_errors, stats->xmit_other_error, + old->xmit_other_error); + + UPDATE_STATS_GB(stst->iface.rcv_errors, stats->rcv_other_error, + old->rcv_other_error); + + UPDATE_STATS_GB(stst->iface.rcv_discards, stats->rcv_drops, + old->rcv_drops); + + if (stats->rcv_drops > old->rcv_drops) + adapter->rcv_drops += (stats->rcv_drops - + old->rcv_drops); + memcpy_fromio(old, stats, sizeof(*stats)); + break; + } case SLIC_UPR_RLSR: slic_link_upr_complete(adapter, isr); break; @@ -1186,7 +1124,6 @@ static int slic_rspqueue_init(struct adapter *adapter) { int i; struct slic_rspqueue *rspq = &adapter->rspqueue; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; u32 paddrh = 0; memset(rspq, 0, sizeof(struct slic_rspqueue)); @@ -1205,14 +1142,12 @@ static int slic_rspqueue_init(struct adapter *adapter) } if (paddrh == 0) { - slic_reg32_write(&slic_regs->slic_rbar, - (rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE), - DONT_FLUSH); + slic_write32(adapter, SLIC_REG_RBAR, + rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE); } else { - slic_reg64_write(adapter, &slic_regs->slic_rbar64, - (rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE), - &slic_regs->slic_addr_upper, - paddrh, DONT_FLUSH); + slic_write64(adapter, SLIC_REG_RBAR64, + rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE, + paddrh); } } rspq->offset = 0; @@ -1233,9 +1168,9 @@ static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter) if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) { rspq->rspbuf++; } else { - slic_reg64_write(adapter, &adapter->slic_regs->slic_rbar64, - (rspq->paddr[rspq->pageindex] | SLIC_RSPQ_BUFSINPAGE), - &adapter->slic_regs->slic_addr_upper, 0, DONT_FLUSH); + slic_write64(adapter, SLIC_REG_RBAR64, + rspq->paddr[rspq->pageindex] | + SLIC_RSPQ_BUFSINPAGE, 0); rspq->pageindex = (rspq->pageindex + 1) % rspq->num_pages; rspq->offset = 0; rspq->rspbuf = (struct slic_rspbuf *) @@ -1569,14 +1504,11 @@ retry_rcvqfill: } #endif if (paddrh == 0) { - slic_reg32_write(&adapter->slic_regs->slic_hbar, - (u32)paddrl, DONT_FLUSH); + slic_write32(adapter, SLIC_REG_HBAR, + (u32)paddrl); } else { - slic_reg64_write(adapter, - &adapter->slic_regs->slic_hbar64, - paddrl, - &adapter->slic_regs->slic_addr_upper, - paddrh, DONT_FLUSH); + slic_write64(adapter, SLIC_REG_HBAR64, paddrl, + paddrh); } if (rcvq->head) rcvq->tail->next = skb; @@ -1698,14 +1630,10 @@ static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb) dev_err(dev, " rcvq->tail[%p]\n", rcvq->tail); dev_err(dev, " rcvq->count[%x]\n", rcvq->count); } - if (paddrh == 0) { - slic_reg32_write(&adapter->slic_regs->slic_hbar, (u32)paddrl, - DONT_FLUSH); - } else { - slic_reg64_write(adapter, &adapter->slic_regs->slic_hbar64, - paddrl, &adapter->slic_regs->slic_addr_upper, - paddrh, DONT_FLUSH); - } + if (paddrh == 0) + slic_write32(adapter, SLIC_REG_HBAR, (u32)paddrl); + else + slic_write64(adapter, SLIC_REG_HBAR64, paddrl, paddrh); if (rcvq->head) rcvq->tail->next = skb; else @@ -1728,26 +1656,17 @@ static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb) static int slic_link_event_handler(struct adapter *adapter) { int status; - struct slic_shmem *pshmem; + struct slic_shmemory *sm = &adapter->shmem; + dma_addr_t phaddr = sm->lnkstatus_phaddr; if (adapter->state != ADAPT_UP) { /* Adapter is not operational. Ignore. */ return -ENODEV; } - - pshmem = (struct slic_shmem *)(unsigned long)adapter->phys_shmem; - -#if BITS_PER_LONG == 64 - status = slic_upr_request(adapter, - SLIC_UPR_RLSR, - SLIC_GET_ADDR_LOW(&pshmem->linkstatus), - SLIC_GET_ADDR_HIGH(&pshmem->linkstatus), - 0, 0); -#else + /* no 4GB wrap guaranteed */ status = slic_upr_request(adapter, SLIC_UPR_RLSR, - (u32)&pshmem->linkstatus, /* no 4GB wrap guaranteed */ - 0, 0, 0); -#endif + cpu_to_le32(lower_32_bits(phaddr)), + cpu_to_le32(upper_32_bits(phaddr)), 0, 0); return status; } @@ -1757,12 +1676,13 @@ static void slic_init_cleanup(struct adapter *adapter) adapter->intrregistered = 0; free_irq(adapter->netdev->irq, adapter->netdev); } - if (adapter->pshmem) { - pci_free_consistent(adapter->pcidev, - sizeof(struct slic_shmem), - adapter->pshmem, adapter->phys_shmem); - adapter->pshmem = NULL; - adapter->phys_shmem = (dma_addr_t)(unsigned long)NULL; + + if (adapter->shmem.shmem_data) { + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; + + pci_free_consistent(adapter->pcidev, sizeof(*sm_data), sm_data, + sm->isr_phaddr); } if (adapter->pingtimerset) { @@ -2147,13 +2067,16 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id) { struct net_device *dev = dev_id; struct adapter *adapter = netdev_priv(dev); + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; u32 isr; - if ((adapter->pshmem) && (adapter->pshmem->isr)) { - slic_reg32_write(&adapter->slic_regs->slic_icr, - ICR_INT_MASK, FLUSH); - isr = adapter->isrcopy = adapter->pshmem->isr; - adapter->pshmem->isr = 0; + if (sm_data->isr) { + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_MASK); + slic_flush_write(adapter); + + isr = sm_data->isr; + sm_data->isr = 0; adapter->num_isrs++; switch (adapter->card->state) { case CARD_UP: @@ -2169,10 +2092,9 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id) break; } - adapter->isrcopy = 0; adapter->all_reg_writes += 2; adapter->isr_reg_writes++; - slic_reg32_write(&adapter->slic_regs->slic_isr, 0, FLUSH); + slic_write32(adapter, SLIC_REG_ISR, 0); } else { adapter->false_interrupts++; } @@ -2224,13 +2146,11 @@ static netdev_tx_t slic_xmit_start(struct sk_buff *skb, struct net_device *dev) } #endif if (hcmd->paddrh == 0) { - slic_reg32_write(&adapter->slic_regs->slic_cbar, - (hcmd->paddrl | hcmd->cmdsize), DONT_FLUSH); + slic_write32(adapter, SLIC_REG_CBAR, (hcmd->paddrl | + hcmd->cmdsize)); } else { - slic_reg64_write(adapter, &adapter->slic_regs->slic_cbar64, - (hcmd->paddrl | hcmd->cmdsize), - &adapter->slic_regs->slic_addr_upper, - hcmd->paddrh, DONT_FLUSH); + slic_write64(adapter, SLIC_REG_CBAR64, + hcmd->paddrl | hcmd->cmdsize, hcmd->paddrh); } xmit_done: return NETDEV_TX_OK; @@ -2290,8 +2210,8 @@ static int slic_if_init(struct adapter *adapter, unsigned long *flags) { struct sliccard *card = adapter->card; struct net_device *dev = adapter->netdev; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; - struct slic_shmem *pshmem; + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; int rc; /* adapter should be down at this point */ @@ -2335,28 +2255,20 @@ static int slic_if_init(struct adapter *adapter, unsigned long *flags) adapter->queues_initialized = 1; } - slic_reg32_write(&slic_regs->slic_icr, ICR_INT_OFF, FLUSH); + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF); + slic_flush_write(adapter); mdelay(1); if (!adapter->isp_initialized) { unsigned long flags; - pshmem = (struct slic_shmem *)(unsigned long) - adapter->phys_shmem; - spin_lock_irqsave(&adapter->bit64reglock, flags); - -#if BITS_PER_LONG == 64 - slic_reg32_write(&slic_regs->slic_addr_upper, - SLIC_GET_ADDR_HIGH(&pshmem->isr), DONT_FLUSH); - slic_reg32_write(&slic_regs->slic_isp, - SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); -#else - slic_reg32_write(&slic_regs->slic_addr_upper, 0, DONT_FLUSH); - slic_reg32_write(&slic_regs->slic_isp, (u32)&pshmem->isr, - FLUSH); -#endif + slic_write32(adapter, SLIC_REG_ADDR_UPPER, + cpu_to_le32(upper_32_bits(sm->isr_phaddr))); + slic_write32(adapter, SLIC_REG_ISP, + cpu_to_le32(lower_32_bits(sm->isr_phaddr))); spin_unlock_irqrestore(&adapter->bit64reglock, flags); + adapter->isp_initialized = 1; } @@ -2383,17 +2295,20 @@ static int slic_if_init(struct adapter *adapter, unsigned long *flags) /* * clear any pending events, then enable interrupts */ - adapter->isrcopy = 0; - adapter->pshmem->isr = 0; - slic_reg32_write(&slic_regs->slic_isr, 0, FLUSH); - slic_reg32_write(&slic_regs->slic_icr, ICR_INT_ON, FLUSH); + sm_data->isr = 0; + slic_write32(adapter, SLIC_REG_ISR, 0); + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_ON); slic_link_config(adapter, LINK_AUTOSPEED, LINK_AUTOD); + slic_flush_write(adapter); + rc = slic_link_event_handler(adapter); if (rc) { /* disable interrupts then clear pending events */ - slic_reg32_write(&slic_regs->slic_icr, ICR_INT_OFF, FLUSH); - slic_reg32_write(&slic_regs->slic_isr, 0, FLUSH); + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF); + slic_write32(adapter, SLIC_REG_ISR, 0); + slic_flush_write(adapter); + if (adapter->pingtimerset) { del_timer(&adapter->pingtimer); adapter->pingtimerset = 0; @@ -2417,7 +2332,7 @@ static int slic_entry_open(struct net_device *dev) unsigned long flags; int status; - netif_stop_queue(adapter->netdev); + netif_carrier_off(dev); spin_lock_irqsave(&slic_global.driver_lock, flags); if (!adapter->activated) { @@ -2440,6 +2355,9 @@ static int slic_entry_open(struct net_device *dev) spin_unlock: spin_unlock_irqrestore(&slic_global.driver_lock, flags); + + netif_start_queue(adapter->netdev); + return status; } @@ -2463,7 +2381,7 @@ static void slic_entry_remove(struct pci_dev *pcidev) unregister_netdev(dev); slic_adapter_freeresources(adapter); - slic_unmap_mmio_space(adapter); + iounmap(adapter->regs); /* free multicast addresses */ mlist = adapter->mcastaddrs; @@ -2497,7 +2415,6 @@ static int slic_entry_halt(struct net_device *dev) { struct adapter *adapter = netdev_priv(dev); struct sliccard *card = adapter->card; - __iomem struct slic_regs *slic_regs = adapter->slic_regs; unsigned long flags; spin_lock_irqsave(&slic_global.driver_lock, flags); @@ -2507,7 +2424,7 @@ static int slic_entry_halt(struct net_device *dev) adapter->upr_list = NULL; adapter->upr_busy = 0; adapter->devflags_prev = 0; - slic_reg32_write(&slic_regs->slic_icr, ICR_INT_OFF, FLUSH); + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF); adapter->all_reg_writes++; adapter->icr_reg_writes++; slic_config_clear(adapter); @@ -2517,8 +2434,10 @@ static int slic_entry_halt(struct net_device *dev) adapter->activated = 0; } #ifdef AUTOMATIC_RESET - slic_reg32_write(&slic_regs->slic_reset_iface, 0, FLUSH); + slic_write32(adapter, SLIC_REG_RESET_IFACE, 0); #endif + slic_flush_write(adapter); + /* * Reset the adapter's cmd queues */ @@ -2530,6 +2449,9 @@ static int slic_entry_halt(struct net_device *dev) #endif spin_unlock_irqrestore(&slic_global.driver_lock, flags); + + netif_carrier_off(dev); + return 0; } @@ -2661,14 +2583,14 @@ static void slic_config_pci(struct pci_dev *pcidev) static int slic_card_init(struct sliccard *card, struct adapter *adapter) { - __iomem struct slic_regs *slic_regs = adapter->slic_regs; + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data = sm->shmem_data; struct slic_eeprom *peeprom; struct oslic_eeprom *pOeeprom; dma_addr_t phys_config; u32 phys_configh; u32 phys_configl; u32 i = 0; - struct slic_shmem *pshmem; int status; uint macaddrs = card->card_size; ushort eecodesize; @@ -2695,27 +2617,26 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) sizeof(struct slic_eeprom), &phys_config); - phys_configl = SLIC_GET_ADDR_LOW(phys_config); - phys_configh = SLIC_GET_ADDR_HIGH(phys_config); - if (!peeprom) { dev_err(&adapter->pcidev->dev, "Failed to allocate DMA memory for EEPROM.\n"); return -ENOMEM; } + phys_configl = SLIC_GET_ADDR_LOW(phys_config); + phys_configh = SLIC_GET_ADDR_HIGH(phys_config); + memset(peeprom, 0, sizeof(struct slic_eeprom)); - slic_reg32_write(&slic_regs->slic_icr, ICR_INT_OFF, FLUSH); + slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF); + slic_flush_write(adapter); mdelay(1); - pshmem = (struct slic_shmem *)(unsigned long) - adapter->phys_shmem; spin_lock_irqsave(&adapter->bit64reglock, flags); - slic_reg32_write(&slic_regs->slic_addr_upper, - SLIC_GET_ADDR_HIGH(&pshmem->isr), DONT_FLUSH); - slic_reg32_write(&slic_regs->slic_isp, - SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); + slic_write32(adapter, SLIC_REG_ADDR_UPPER, + cpu_to_le32(upper_32_bits(sm->isr_phaddr))); + slic_write32(adapter, SLIC_REG_ISP, + cpu_to_le32(lower_32_bits(sm->isr_phaddr))); spin_unlock_irqrestore(&adapter->bit64reglock, flags); status = slic_config_get(adapter, phys_configl, phys_configh); @@ -2726,33 +2647,31 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) } for (;;) { - if (adapter->pshmem->isr) { - if (adapter->pshmem->isr & ISR_UPC) { - adapter->pshmem->isr = 0; - slic_reg64_write(adapter, - &slic_regs->slic_isp, 0, - &slic_regs->slic_addr_upper, - 0, FLUSH); - slic_reg32_write(&slic_regs->slic_isr, - 0, FLUSH); + if (sm_data->isr) { + if (sm_data->isr & ISR_UPC) { + sm_data->isr = 0; + slic_write64(adapter, SLIC_REG_ISP, 0, + 0); + slic_write32(adapter, SLIC_REG_ISR, 0); + slic_flush_write(adapter); slic_upr_request_complete(adapter, 0); break; } - adapter->pshmem->isr = 0; - slic_reg32_write(&slic_regs->slic_isr, - 0, FLUSH); + sm_data->isr = 0; + slic_write32(adapter, SLIC_REG_ISR, 0); + slic_flush_write(adapter); } else { mdelay(1); i++; if (i > 5000) { dev_err(&adapter->pcidev->dev, "Fetch of config data timed out.\n"); - slic_reg64_write(adapter, - &slic_regs->slic_isp, 0, - &slic_regs->slic_addr_upper, - 0, FLUSH); + slic_write64(adapter, SLIC_REG_ISP, + 0, 0); + slic_flush_write(adapter); + status = -EINVAL; goto card_init_err; } @@ -2796,7 +2715,6 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) /* see if the EEPROM is valid by checking it's checksum */ if ((eecodesize <= MAX_EECODE_SIZE) && (eecodesize >= MIN_EECODE_SIZE)) { - ee_chksum = *(u16 *)((char *)peeprom + (eecodesize - 2)); /* @@ -2830,9 +2748,8 @@ static int slic_card_init(struct sliccard *card, struct adapter *adapter) peeprom, phys_config); if (!card->config.EepromValid) { - slic_reg64_write(adapter, &slic_regs->slic_isp, 0, - &slic_regs->slic_addr_upper, - 0, FLUSH); + slic_write64(adapter, SLIC_REG_ISP, 0, 0); + slic_flush_write(adapter); dev_err(&adapter->pcidev->dev, "EEPROM invalid.\n"); return -EINVAL; } @@ -2896,14 +2813,17 @@ static void slic_init_driver(void) } } -static void slic_init_adapter(struct net_device *netdev, - struct pci_dev *pcidev, - const struct pci_device_id *pci_tbl_entry, - void __iomem *memaddr, int chip_idx) +static int slic_init_adapter(struct net_device *netdev, + struct pci_dev *pcidev, + const struct pci_device_id *pci_tbl_entry, + void __iomem *memaddr, int chip_idx) { ushort index; struct slic_handle *pslic_handle; struct adapter *adapter = netdev_priv(netdev); + struct slic_shmemory *sm = &adapter->shmem; + struct slic_shmem_data *sm_data; + dma_addr_t phaddr; /* adapter->pcidev = pcidev;*/ adapter->vendid = pci_tbl_entry->vendor; @@ -2912,7 +2832,7 @@ static void slic_init_adapter(struct net_device *netdev, adapter->busnumber = pcidev->bus->number; adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F); adapter->functionnumber = (pcidev->devfn & 0x7); - adapter->slic_regs = memaddr; + adapter->regs = memaddr; adapter->irq = pcidev->irq; adapter->chipid = chip_idx; adapter->port = 0; @@ -2932,19 +2852,23 @@ static void slic_init_adapter(struct net_device *netdev, */ for (index = 1, pslic_handle = &adapter->slic_handles[1]; index < SLIC_CMDQ_MAXCMDS; index++, pslic_handle++) { - pslic_handle->token.handle_index = index; pslic_handle->type = SLIC_HANDLE_FREE; pslic_handle->next = adapter->pfree_slic_handles; adapter->pfree_slic_handles = pslic_handle; } - adapter->pshmem = (struct slic_shmem *) - pci_alloc_consistent(adapter->pcidev, - sizeof(struct slic_shmem), - &adapter-> - phys_shmem); - if (adapter->pshmem) - memset(adapter->pshmem, 0, sizeof(struct slic_shmem)); + sm_data = pci_zalloc_consistent(adapter->pcidev, sizeof(*sm_data), + &phaddr); + if (!sm_data) + return -ENOMEM; + + sm->shmem_data = sm_data; + sm->isr_phaddr = phaddr; + sm->lnkstatus_phaddr = phaddr + offsetof(struct slic_shmem_data, + lnkstatus); + sm->stats_phaddr = phaddr + offsetof(struct slic_shmem_data, stats); + + return 0; } static const struct net_device_ops slic_netdev_ops = { @@ -2964,27 +2888,9 @@ static u32 slic_card_locate(struct adapter *adapter) struct sliccard *card = slic_global.slic_card; struct physcard *physcard = slic_global.phys_card; ushort card_hostid; - u16 __iomem *hostid_reg; uint i; - uint rdhostid_offset = 0; - - switch (adapter->devid) { - case SLIC_2GB_DEVICE_ID: - rdhostid_offset = SLIC_RDHOSTID_2GB; - break; - case SLIC_1GB_DEVICE_ID: - rdhostid_offset = SLIC_RDHOSTID_1GB; - break; - default: - return -ENODEV; - } - hostid_reg = - (u16 __iomem *)(((u8 __iomem *)(adapter->slic_regs)) + - rdhostid_offset); - - /* read the 16 bit hostid from SRAM */ - card_hostid = (ushort)readw(hostid_reg); + card_hostid = slic_read32(adapter, SLIC_REG_HOSTID); /* Initialize a new card structure if need be */ if (card_hostid == SLIC_HOSTID_DEFAULT) { @@ -3130,7 +3036,7 @@ static int slic_entry_probe(struct pci_dev *pcidev, mmio_start = pci_resource_start(pcidev, 0); mmio_len = pci_resource_len(pcidev, 0); - memmapped_ioaddr = ioremap(mmio_start, mmio_len); + memmapped_ioaddr = ioremap_nocache(mmio_start, mmio_len); if (!memmapped_ioaddr) { dev_err(&pcidev->dev, "cannot remap MMIO region %lx @ %lx\n", mmio_len, mmio_start); @@ -3142,13 +3048,17 @@ static int slic_entry_probe(struct pci_dev *pcidev, slic_init_driver(); - slic_init_adapter(netdev, - pcidev, pci_tbl_entry, memmapped_ioaddr, cards_found); + err = slic_init_adapter(netdev, pcidev, pci_tbl_entry, memmapped_ioaddr, + cards_found); + if (err) { + dev_err(&pcidev->dev, "failed to init adapter: %i\n", err); + goto err_out_unmap; + } err = slic_card_locate(adapter); if (err) { dev_err(&pcidev->dev, "cannot locate card\n"); - goto err_out_unmap; + goto err_clean_init; } card = adapter->card; @@ -3160,7 +3070,7 @@ static int slic_entry_probe(struct pci_dev *pcidev, err = slic_card_init(card, adapter); if (err) - goto err_out_unmap; + goto err_clean_init; slic_adapter_set_hwaddr(adapter); @@ -3168,17 +3078,21 @@ static int slic_entry_probe(struct pci_dev *pcidev, netdev->irq = adapter->irq; netdev->netdev_ops = &slic_netdev_ops; + netif_carrier_off(netdev); + strcpy(netdev->name, "eth%d"); err = register_netdev(netdev); if (err) { dev_err(&pcidev->dev, "Cannot register net device, aborting.\n"); - goto err_out_unmap; + goto err_clean_init; } cards_found++; return 0; +err_clean_init: + slic_init_cleanup(adapter); err_out_unmap: iounmap(memmapped_ioaddr); err_out_free_netdev: @@ -3209,7 +3123,7 @@ static void __exit slic_module_cleanup(void) pci_unregister_driver(&slic_driver); } -static struct ethtool_ops slic_ethtool_ops = { +static const struct ethtool_ops slic_ethtool_ops = { .get_coalesce = slic_get_coalesce, .set_coalesce = slic_set_coalesce }; |