Lines Matching refs:bp
244 static void bnx2_init_napi(struct bnx2 *bp);
245 static void bnx2_del_napi(struct bnx2 *bp);
247 static inline u32 bnx2_tx_avail(struct bnx2 *bp, struct bnx2_tx_ring_info *txr)
260 return bp->tx_ring_size - diff;
264 bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset)
269 spin_lock_irqsave(&bp->indirect_lock, flags);
270 BNX2_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
271 val = BNX2_RD(bp, BNX2_PCICFG_REG_WINDOW);
272 spin_unlock_irqrestore(&bp->indirect_lock, flags);
277 bnx2_reg_wr_ind(struct bnx2 *bp, u32 offset, u32 val)
281 spin_lock_irqsave(&bp->indirect_lock, flags);
282 BNX2_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, offset);
283 BNX2_WR(bp, BNX2_PCICFG_REG_WINDOW, val);
284 spin_unlock_irqrestore(&bp->indirect_lock, flags);
288 bnx2_shmem_wr(struct bnx2 *bp, u32 offset, u32 val)
290 bnx2_reg_wr_ind(bp, bp->shmem_base + offset, val);
294 bnx2_shmem_rd(struct bnx2 *bp, u32 offset)
296 return bnx2_reg_rd_ind(bp, bp->shmem_base + offset);
300 bnx2_ctx_wr(struct bnx2 *bp, u32 cid_addr, u32 offset, u32 val)
305 spin_lock_irqsave(&bp->indirect_lock, flags);
306 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
309 BNX2_WR(bp, BNX2_CTX_CTX_DATA, val);
310 BNX2_WR(bp, BNX2_CTX_CTX_CTRL,
313 val = BNX2_RD(bp, BNX2_CTX_CTX_CTRL);
319 BNX2_WR(bp, BNX2_CTX_DATA_ADR, offset);
320 BNX2_WR(bp, BNX2_CTX_DATA, val);
322 spin_unlock_irqrestore(&bp->indirect_lock, flags);
329 struct bnx2 *bp = netdev_priv(dev);
334 bnx2_reg_wr_ind(bp, io->offset, io->data);
337 io->data = bnx2_reg_rd_ind(bp, io->offset);
340 bnx2_ctx_wr(bp, io->cid_addr, io->offset, io->data);
348 static void bnx2_setup_cnic_irq_info(struct bnx2 *bp)
350 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
351 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
354 if (bp->flags & BNX2_FLAG_USING_MSIX) {
357 sb_id = bp->irq_nvecs;
367 cp->irq_arr[0].vector = bp->irq_tbl[sb_id].vector;
378 struct bnx2 *bp = netdev_priv(dev);
379 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
387 if (!bnx2_reg_rd_ind(bp, BNX2_FW_MAX_ISCSI_CONN))
390 bp->cnic_data = data;
391 rcu_assign_pointer(bp->cnic_ops, ops);
396 bnx2_setup_cnic_irq_info(bp);
403 struct bnx2 *bp = netdev_priv(dev);
404 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
405 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
407 mutex_lock(&bp->cnic_lock);
410 RCU_INIT_POINTER(bp->cnic_ops, NULL);
411 mutex_unlock(&bp->cnic_lock);
418 struct bnx2 *bp = netdev_priv(dev);
419 struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
425 cp->chip_id = bp->chip_id;
426 cp->pdev = bp->pdev;
427 cp->io_base = bp->regview;
436 bnx2_cnic_stop(struct bnx2 *bp)
441 mutex_lock(&bp->cnic_lock);
442 c_ops = rcu_dereference_protected(bp->cnic_ops,
443 lockdep_is_held(&bp->cnic_lock));
446 c_ops->cnic_ctl(bp->cnic_data, &info);
448 mutex_unlock(&bp->cnic_lock);
452 bnx2_cnic_start(struct bnx2 *bp)
457 mutex_lock(&bp->cnic_lock);
458 c_ops = rcu_dereference_protected(bp->cnic_ops,
459 lockdep_is_held(&bp->cnic_lock));
461 if (!(bp->flags & BNX2_FLAG_USING_MSIX)) {
462 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
467 c_ops->cnic_ctl(bp->cnic_data, &info);
469 mutex_unlock(&bp->cnic_lock);
475 bnx2_cnic_stop(struct bnx2 *bp)
480 bnx2_cnic_start(struct bnx2 *bp)
487 bnx2_read_phy(struct bnx2 *bp, u32 reg, u32 *val)
492 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
493 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
496 BNX2_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
497 BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
502 val1 = (bp->phy_addr << 21) | (reg << 16) |
505 BNX2_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
510 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_COMM);
514 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_COMM);
530 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
531 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
534 BNX2_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
535 BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
544 bnx2_write_phy(struct bnx2 *bp, u32 reg, u32 val)
549 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
550 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
553 BNX2_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
554 BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
559 val1 = (bp->phy_addr << 21) | (reg << 16) | val |
562 BNX2_WR(bp, BNX2_EMAC_MDIO_COMM, val1);
567 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_COMM);
579 if (bp->phy_flags & BNX2_PHY_FLAG_INT_MODE_AUTO_POLLING) {
580 val1 = BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
583 BNX2_WR(bp, BNX2_EMAC_MDIO_MODE, val1);
584 BNX2_RD(bp, BNX2_EMAC_MDIO_MODE);
593 bnx2_disable_int(struct bnx2 *bp)
598 for (i = 0; i < bp->irq_nvecs; i++) {
599 bnapi = &bp->bnx2_napi[i];
600 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
603 BNX2_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
607 bnx2_enable_int(struct bnx2 *bp)
612 for (i = 0; i < bp->irq_nvecs; i++) {
613 bnapi = &bp->bnx2_napi[i];
615 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
620 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
624 BNX2_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
628 bnx2_disable_int_sync(struct bnx2 *bp)
632 atomic_inc(&bp->intr_sem);
633 if (!netif_running(bp->dev))
636 bnx2_disable_int(bp);
637 for (i = 0; i < bp->irq_nvecs; i++)
638 synchronize_irq(bp->irq_tbl[i].vector);
642 bnx2_napi_disable(struct bnx2 *bp)
646 for (i = 0; i < bp->irq_nvecs; i++)
647 napi_disable(&bp->bnx2_napi[i].napi);
651 bnx2_napi_enable(struct bnx2 *bp)
655 for (i = 0; i < bp->irq_nvecs; i++)
656 napi_enable(&bp->bnx2_napi[i].napi);
660 bnx2_netif_stop(struct bnx2 *bp, bool stop_cnic)
663 bnx2_cnic_stop(bp);
664 if (netif_running(bp->dev)) {
665 bnx2_napi_disable(bp);
666 netif_tx_disable(bp->dev);
668 bnx2_disable_int_sync(bp);
669 netif_carrier_off(bp->dev); /* prevent tx timeout */
673 bnx2_netif_start(struct bnx2 *bp, bool start_cnic)
675 if (atomic_dec_and_test(&bp->intr_sem)) {
676 if (netif_running(bp->dev)) {
677 netif_tx_wake_all_queues(bp->dev);
678 spin_lock_bh(&bp->phy_lock);
679 if (bp->link_up)
680 netif_carrier_on(bp->dev);
681 spin_unlock_bh(&bp->phy_lock);
682 bnx2_napi_enable(bp);
683 bnx2_enable_int(bp);
685 bnx2_cnic_start(bp);
691 bnx2_free_tx_mem(struct bnx2 *bp)
695 for (i = 0; i < bp->num_tx_rings; i++) {
696 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
700 dma_free_coherent(&bp->pdev->dev, TXBD_RING_SIZE,
711 bnx2_free_rx_mem(struct bnx2 *bp)
715 for (i = 0; i < bp->num_rx_rings; i++) {
716 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
720 for (j = 0; j < bp->rx_max_ring; j++) {
722 dma_free_coherent(&bp->pdev->dev, RXBD_RING_SIZE,
730 for (j = 0; j < bp->rx_max_pg_ring; j++) {
732 dma_free_coherent(&bp->pdev->dev, RXBD_RING_SIZE,
743 bnx2_alloc_tx_mem(struct bnx2 *bp)
747 for (i = 0; i < bp->num_tx_rings; i++) {
748 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
756 dma_alloc_coherent(&bp->pdev->dev, TXBD_RING_SIZE,
765 bnx2_alloc_rx_mem(struct bnx2 *bp)
769 for (i = 0; i < bp->num_rx_rings; i++) {
770 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
775 vzalloc(array_size(SW_RXBD_RING_SIZE, bp->rx_max_ring));
779 for (j = 0; j < bp->rx_max_ring; j++) {
781 dma_alloc_coherent(&bp->pdev->dev,
790 if (bp->rx_pg_ring_size) {
793 bp->rx_max_pg_ring));
799 for (j = 0; j < bp->rx_max_pg_ring; j++) {
801 dma_alloc_coherent(&bp->pdev->dev,
816 struct bnx2 *bp = netdev_priv(dev);
818 if (bp->status_blk) {
819 dma_free_coherent(&bp->pdev->dev, bp->status_stats_size,
820 bp->status_blk,
821 bp->status_blk_mapping);
822 bp->status_blk = NULL;
823 bp->stats_blk = NULL;
832 struct bnx2 *bp = netdev_priv(dev);
836 if (bp->flags & BNX2_FLAG_MSIX_CAP)
839 bp->status_stats_size = status_blk_size +
841 status_blk = dma_alloc_coherent(&bp->pdev->dev, bp->status_stats_size,
842 &bp->status_blk_mapping, GFP_KERNEL);
846 bp->status_blk = status_blk;
847 bp->stats_blk = status_blk + status_blk_size;
848 bp->stats_blk_mapping = bp->status_blk_mapping + status_blk_size;
854 bnx2_free_mem(struct bnx2 *bp)
857 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
859 bnx2_free_tx_mem(bp);
860 bnx2_free_rx_mem(bp);
862 for (i = 0; i < bp->ctx_pages; i++) {
863 if (bp->ctx_blk[i]) {
864 dma_free_coherent(&bp->pdev->dev, BNX2_PAGE_SIZE,
865 bp->ctx_blk[i],
866 bp->ctx_blk_mapping[i]);
867 bp->ctx_blk[i] = NULL;
876 bnx2_alloc_mem(struct bnx2 *bp)
881 bnapi = &bp->bnx2_napi[0];
882 bnapi->status_blk.msi = bp->status_blk;
887 if (bp->flags & BNX2_FLAG_MSIX_CAP) {
888 for (i = 1; i < bp->irq_nvecs; i++) {
891 bnapi = &bp->bnx2_napi[i];
893 sblk = (bp->status_blk + BNX2_SBLK_MSIX_ALIGN_SIZE * i);
903 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
904 bp->ctx_pages = 0x2000 / BNX2_PAGE_SIZE;
905 if (bp->ctx_pages == 0)
906 bp->ctx_pages = 1;
907 for (i = 0; i < bp->ctx_pages; i++) {
908 bp->ctx_blk[i] = dma_alloc_coherent(&bp->pdev->dev,
910 &bp->ctx_blk_mapping[i],
912 if (!bp->ctx_blk[i])
917 err = bnx2_alloc_rx_mem(bp);
921 err = bnx2_alloc_tx_mem(bp);
928 bnx2_free_mem(bp);
933 bnx2_report_fw_link(struct bnx2 *bp)
937 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
940 if (bp->link_up) {
943 switch (bp->line_speed) {
945 if (bp->duplex == DUPLEX_HALF)
951 if (bp->duplex == DUPLEX_HALF)
957 if (bp->duplex == DUPLEX_HALF)
963 if (bp->duplex == DUPLEX_HALF)
972 if (bp->autoneg) {
975 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
976 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
979 bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)
988 bnx2_shmem_wr(bp, BNX2_LINK_STATUS, fw_link_status);
992 bnx2_xceiver_str(struct bnx2 *bp)
994 return (bp->phy_port == PORT_FIBRE) ? "SerDes" :
995 ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) ? "Remote Copper" :
1000 bnx2_report_link(struct bnx2 *bp)
1002 if (bp->link_up) {
1003 netif_carrier_on(bp->dev);
1004 netdev_info(bp->dev, "NIC %s Link is Up, %d Mbps %s duplex",
1005 bnx2_xceiver_str(bp),
1006 bp->line_speed,
1007 bp->duplex == DUPLEX_FULL ? "full" : "half");
1009 if (bp->flow_ctrl) {
1010 if (bp->flow_ctrl & FLOW_CTRL_RX) {
1012 if (bp->flow_ctrl & FLOW_CTRL_TX)
1022 netif_carrier_off(bp->dev);
1023 netdev_err(bp->dev, "NIC %s Link is Down\n",
1024 bnx2_xceiver_str(bp));
1027 bnx2_report_fw_link(bp);
1031 bnx2_resolve_flow_ctrl(struct bnx2 *bp)
1035 bp->flow_ctrl = 0;
1036 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
1039 if (bp->duplex == DUPLEX_FULL) {
1040 bp->flow_ctrl = bp->req_flow_ctrl;
1045 if (bp->duplex != DUPLEX_FULL) {
1049 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1050 (BNX2_CHIP(bp) == BNX2_CHIP_5708)) {
1053 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
1055 bp->flow_ctrl |= FLOW_CTRL_TX;
1057 bp->flow_ctrl |= FLOW_CTRL_RX;
1061 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
1062 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
1064 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1085 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
1088 bp->flow_ctrl = FLOW_CTRL_RX;
1093 bp->flow_ctrl = FLOW_CTRL_TX | FLOW_CTRL_RX;
1101 bp->flow_ctrl = FLOW_CTRL_TX;
1107 bnx2_5709s_linkup(struct bnx2 *bp)
1111 bp->link_up = 1;
1113 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_GP_STATUS);
1114 bnx2_read_phy(bp, MII_BNX2_GP_TOP_AN_STATUS1, &val);
1115 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
1117 if ((bp->autoneg & AUTONEG_SPEED) == 0) {
1118 bp->line_speed = bp->req_line_speed;
1119 bp->duplex = bp->req_duplex;
1125 bp->line_speed = SPEED_10;
1128 bp->line_speed = SPEED_100;
1132 bp->line_speed = SPEED_1000;
1135 bp->line_speed = SPEED_2500;
1139 bp->duplex = DUPLEX_FULL;
1141 bp->duplex = DUPLEX_HALF;
1146 bnx2_5708s_linkup(struct bnx2 *bp)
1150 bp->link_up = 1;
1151 bnx2_read_phy(bp, BCM5708S_1000X_STAT1, &val);
1154 bp->line_speed = SPEED_10;
1157 bp->line_speed = SPEED_100;
1160 bp->line_speed = SPEED_1000;
1163 bp->line_speed = SPEED_2500;
1167 bp->duplex = DUPLEX_FULL;
1169 bp->duplex = DUPLEX_HALF;
1175 bnx2_5706s_linkup(struct bnx2 *bp)
1179 bp->link_up = 1;
1180 bp->line_speed = SPEED_1000;
1182 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1184 bp->duplex = DUPLEX_FULL;
1187 bp->duplex = DUPLEX_HALF;
1194 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
1195 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
1201 bp->duplex = DUPLEX_FULL;
1204 bp->duplex = DUPLEX_HALF;
1212 bnx2_copper_linkup(struct bnx2 *bp)
1216 bp->phy_flags &= ~BNX2_PHY_FLAG_MDIX;
1218 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1222 bnx2_read_phy(bp, MII_CTRL1000, &local_adv);
1223 bnx2_read_phy(bp, MII_STAT1000, &remote_adv);
1227 bp->line_speed = SPEED_1000;
1228 bp->duplex = DUPLEX_FULL;
1231 bp->line_speed = SPEED_1000;
1232 bp->duplex = DUPLEX_HALF;
1235 bnx2_read_phy(bp, bp->mii_adv, &local_adv);
1236 bnx2_read_phy(bp, bp->mii_lpa, &remote_adv);
1240 bp->line_speed = SPEED_100;
1241 bp->duplex = DUPLEX_FULL;
1244 bp->line_speed = SPEED_100;
1245 bp->duplex = DUPLEX_HALF;
1248 bp->line_speed = SPEED_10;
1249 bp->duplex = DUPLEX_FULL;
1252 bp->line_speed = SPEED_10;
1253 bp->duplex = DUPLEX_HALF;
1256 bp->line_speed = 0;
1257 bp->link_up = 0;
1263 bp->line_speed = SPEED_100;
1266 bp->line_speed = SPEED_10;
1269 bp->duplex = DUPLEX_FULL;
1272 bp->duplex = DUPLEX_HALF;
1276 if (bp->link_up) {
1279 bnx2_read_phy(bp, MII_BNX2_EXT_STATUS, &ext_status);
1281 bp->phy_flags |= BNX2_PHY_FLAG_MDIX;
1288 bnx2_init_rx_context(struct bnx2 *bp, u32 cid)
1296 if (bp->flow_ctrl & FLOW_CTRL_TX)
1299 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_CTX_TYPE, val);
1303 bnx2_init_all_rx_contexts(struct bnx2 *bp)
1308 for (i = 0, cid = RX_CID; i < bp->num_rx_rings; i++, cid++) {
1311 bnx2_init_rx_context(bp, cid);
1316 bnx2_set_mac_link(struct bnx2 *bp)
1320 BNX2_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x2620);
1321 if (bp->link_up && (bp->line_speed == SPEED_1000) &&
1322 (bp->duplex == DUPLEX_HALF)) {
1323 BNX2_WR(bp, BNX2_EMAC_TX_LENGTHS, 0x26ff);
1327 val = BNX2_RD(bp, BNX2_EMAC_MODE);
1333 if (bp->link_up) {
1334 switch (bp->line_speed) {
1336 if (BNX2_CHIP(bp) != BNX2_CHIP_5706) {
1357 if (bp->duplex == DUPLEX_HALF)
1359 BNX2_WR(bp, BNX2_EMAC_MODE, val);
1362 bp->rx_mode &= ~BNX2_EMAC_RX_MODE_FLOW_EN;
1364 if (bp->flow_ctrl & FLOW_CTRL_RX)
1365 bp->rx_mode |= BNX2_EMAC_RX_MODE_FLOW_EN;
1366 BNX2_WR(bp, BNX2_EMAC_RX_MODE, bp->rx_mode);
1369 val = BNX2_RD(bp, BNX2_EMAC_TX_MODE);
1372 if (bp->flow_ctrl & FLOW_CTRL_TX)
1374 BNX2_WR(bp, BNX2_EMAC_TX_MODE, val);
1377 BNX2_WR(bp, BNX2_EMAC_STATUS, BNX2_EMAC_STATUS_LINK_CHANGE);
1379 bnx2_init_all_rx_contexts(bp);
1383 bnx2_enable_bmsr1(struct bnx2 *bp)
1385 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1386 (BNX2_CHIP(bp) == BNX2_CHIP_5709))
1387 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1392 bnx2_disable_bmsr1(struct bnx2 *bp)
1394 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1395 (BNX2_CHIP(bp) == BNX2_CHIP_5709))
1396 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1401 bnx2_test_and_enable_2g5(struct bnx2 *bp)
1406 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1409 if (bp->autoneg & AUTONEG_SPEED)
1410 bp->advertising |= ADVERTISED_2500baseX_Full;
1412 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
1413 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1415 bnx2_read_phy(bp, bp->mii_up1, &up1);
1418 bnx2_write_phy(bp, bp->mii_up1, up1);
1422 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
1423 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1430 bnx2_test_and_disable_2g5(struct bnx2 *bp)
1435 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1438 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
1439 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
1441 bnx2_read_phy(bp, bp->mii_up1, &up1);
1444 bnx2_write_phy(bp, bp->mii_up1, up1);
1448 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
1449 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1456 bnx2_enable_forced_2g5(struct bnx2 *bp)
1461 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1464 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
1467 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1469 if (!bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val)) {
1473 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1476 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1478 err = bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1480 } else if (BNX2_CHIP(bp) == BNX2_CHIP_5708) {
1481 err = bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1491 if (bp->autoneg & AUTONEG_SPEED) {
1493 if (bp->req_duplex == DUPLEX_FULL)
1496 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1500 bnx2_disable_forced_2g5(struct bnx2 *bp)
1505 if (!(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
1508 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
1511 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1513 if (!bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_MISC1, &val)) {
1515 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_MISC1, val);
1518 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR,
1520 err = bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1522 } else if (BNX2_CHIP(bp) == BNX2_CHIP_5708) {
1523 err = bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1533 if (bp->autoneg & AUTONEG_SPEED)
1535 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1539 bnx2_5706s_force_link_dn(struct bnx2 *bp, int start)
1543 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_SERDES_CTL);
1544 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
1546 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val & 0xff0f);
1548 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val | 0xc0);
1552 bnx2_set_link(struct bnx2 *bp)
1557 if (bp->loopback == MAC_LOOPBACK || bp->loopback == PHY_LOOPBACK) {
1558 bp->link_up = 1;
1562 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
1565 link_up = bp->link_up;
1567 bnx2_enable_bmsr1(bp);
1568 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1569 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
1570 bnx2_disable_bmsr1(bp);
1572 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1573 (BNX2_CHIP(bp) == BNX2_CHIP_5706)) {
1576 if (bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN) {
1577 bnx2_5706s_force_link_dn(bp, 0);
1578 bp->phy_flags &= ~BNX2_PHY_FLAG_FORCED_DOWN;
1580 val = BNX2_RD(bp, BNX2_EMAC_STATUS);
1582 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
1583 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1584 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
1594 bp->link_up = 1;
1596 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1597 if (BNX2_CHIP(bp) == BNX2_CHIP_5706)
1598 bnx2_5706s_linkup(bp);
1599 else if (BNX2_CHIP(bp) == BNX2_CHIP_5708)
1600 bnx2_5708s_linkup(bp);
1601 else if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
1602 bnx2_5709s_linkup(bp);
1605 bnx2_copper_linkup(bp);
1607 bnx2_resolve_flow_ctrl(bp);
1610 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
1611 (bp->autoneg & AUTONEG_SPEED))
1612 bnx2_disable_forced_2g5(bp);
1614 if (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT) {
1617 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1619 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
1621 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
1623 bp->link_up = 0;
1626 if (bp->link_up != link_up) {
1627 bnx2_report_link(bp);
1630 bnx2_set_mac_link(bp);
1636 bnx2_reset_phy(struct bnx2 *bp)
1641 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_RESET);
1647 bnx2_read_phy(bp, bp->mii_bmcr, ®);
1660 bnx2_phy_get_pause_adv(struct bnx2 *bp)
1664 if ((bp->req_flow_ctrl & (FLOW_CTRL_RX | FLOW_CTRL_TX)) ==
1667 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1674 else if (bp->req_flow_ctrl & FLOW_CTRL_TX) {
1675 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1682 else if (bp->req_flow_ctrl & FLOW_CTRL_RX) {
1683 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1696 bnx2_setup_remote_phy(struct bnx2 *bp, u8 port)
1697 __releases(&bp->phy_lock)
1698 __acquires(&bp->phy_lock)
1702 pause_adv = bnx2_phy_get_pause_adv(bp);
1704 if (bp->autoneg & AUTONEG_SPEED) {
1706 if (bp->advertising & ADVERTISED_10baseT_Half)
1708 if (bp->advertising & ADVERTISED_10baseT_Full)
1710 if (bp->advertising & ADVERTISED_100baseT_Half)
1712 if (bp->advertising & ADVERTISED_100baseT_Full)
1714 if (bp->advertising & ADVERTISED_1000baseT_Full)
1716 if (bp->advertising & ADVERTISED_2500baseX_Full)
1719 if (bp->req_line_speed == SPEED_2500)
1721 else if (bp->req_line_speed == SPEED_1000)
1723 else if (bp->req_line_speed == SPEED_100) {
1724 if (bp->req_duplex == DUPLEX_FULL)
1728 } else if (bp->req_line_speed == SPEED_10) {
1729 if (bp->req_duplex == DUPLEX_FULL)
1745 bnx2_shmem_wr(bp, BNX2_DRV_MB_ARG0, speed_arg);
1747 spin_unlock_bh(&bp->phy_lock);
1748 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_CMD_SET_LINK, 1, 0);
1749 spin_lock_bh(&bp->phy_lock);
1755 bnx2_setup_serdes_phy(struct bnx2 *bp, u8 port)
1756 __releases(&bp->phy_lock)
1757 __acquires(&bp->phy_lock)
1762 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
1763 return bnx2_setup_remote_phy(bp, port);
1765 if (!(bp->autoneg & AUTONEG_SPEED)) {
1769 if (bp->req_line_speed == SPEED_2500) {
1770 if (!bnx2_test_and_enable_2g5(bp))
1772 } else if (bp->req_line_speed == SPEED_1000) {
1773 if (bnx2_test_and_disable_2g5(bp))
1776 bnx2_read_phy(bp, bp->mii_adv, &adv);
1779 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1783 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
1784 if (bp->req_line_speed == SPEED_2500)
1785 bnx2_enable_forced_2g5(bp);
1786 else if (bp->req_line_speed == SPEED_1000) {
1787 bnx2_disable_forced_2g5(bp);
1791 } else if (BNX2_CHIP(bp) == BNX2_CHIP_5708) {
1792 if (bp->req_line_speed == SPEED_2500)
1798 if (bp->req_duplex == DUPLEX_FULL) {
1808 if (bp->link_up) {
1809 bnx2_write_phy(bp, bp->mii_adv, adv &
1812 bnx2_write_phy(bp, bp->mii_bmcr, bmcr |
1815 bp->link_up = 0;
1816 netif_carrier_off(bp->dev);
1817 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
1818 bnx2_report_link(bp);
1820 bnx2_write_phy(bp, bp->mii_adv, adv);
1821 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
1823 bnx2_resolve_flow_ctrl(bp);
1824 bnx2_set_mac_link(bp);
1829 bnx2_test_and_enable_2g5(bp);
1831 if (bp->advertising & ADVERTISED_1000baseT_Full)
1834 new_adv |= bnx2_phy_get_pause_adv(bp);
1836 bnx2_read_phy(bp, bp->mii_adv, &adv);
1837 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
1839 bp->serdes_an_pending = 0;
1842 if (bp->link_up) {
1843 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
1844 spin_unlock_bh(&bp->phy_lock);
1846 spin_lock_bh(&bp->phy_lock);
1849 bnx2_write_phy(bp, bp->mii_adv, new_adv);
1850 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART |
1860 bp->current_interval = BNX2_SERDES_AN_TIMEOUT;
1861 bp->serdes_an_pending = 1;
1862 mod_timer(&bp->timer, jiffies + bp->current_interval);
1864 bnx2_resolve_flow_ctrl(bp);
1865 bnx2_set_mac_link(bp);
1872 (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) ? \
1887 bnx2_set_default_remote_link(struct bnx2 *bp)
1891 if (bp->phy_port == PORT_TP)
1892 link = bnx2_shmem_rd(bp, BNX2_RPHY_COPPER_LINK);
1894 link = bnx2_shmem_rd(bp, BNX2_RPHY_SERDES_LINK);
1897 bp->req_line_speed = 0;
1898 bp->autoneg |= AUTONEG_SPEED;
1899 bp->advertising = ADVERTISED_Autoneg;
1901 bp->advertising |= ADVERTISED_10baseT_Half;
1903 bp->advertising |= ADVERTISED_10baseT_Full;
1905 bp->advertising |= ADVERTISED_100baseT_Half;
1907 bp->advertising |= ADVERTISED_100baseT_Full;
1909 bp->advertising |= ADVERTISED_1000baseT_Full;
1911 bp->advertising |= ADVERTISED_2500baseX_Full;
1913 bp->autoneg = 0;
1914 bp->advertising = 0;
1915 bp->req_duplex = DUPLEX_FULL;
1917 bp->req_line_speed = SPEED_10;
1919 bp->req_duplex = DUPLEX_HALF;
1922 bp->req_line_speed = SPEED_100;
1924 bp->req_duplex = DUPLEX_HALF;
1927 bp->req_line_speed = SPEED_1000;
1929 bp->req_line_speed = SPEED_2500;
1934 bnx2_set_default_link(struct bnx2 *bp)
1936 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
1937 bnx2_set_default_remote_link(bp);
1941 bp->autoneg = AUTONEG_SPEED | AUTONEG_FLOW_CTRL;
1942 bp->req_line_speed = 0;
1943 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
1946 bp->advertising = ETHTOOL_ALL_FIBRE_SPEED | ADVERTISED_Autoneg;
1948 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG);
1951 bp->autoneg = 0;
1952 bp->req_line_speed = bp->line_speed = SPEED_1000;
1953 bp->req_duplex = DUPLEX_FULL;
1956 bp->advertising = ETHTOOL_ALL_COPPER_SPEED | ADVERTISED_Autoneg;
1960 bnx2_send_heart_beat(struct bnx2 *bp)
1965 spin_lock(&bp->indirect_lock);
1966 msg = (u32) (++bp->fw_drv_pulse_wr_seq & BNX2_DRV_PULSE_SEQ_MASK);
1967 addr = bp->shmem_base + BNX2_DRV_PULSE_MB;
1968 BNX2_WR(bp, BNX2_PCICFG_REG_WINDOW_ADDRESS, addr);
1969 BNX2_WR(bp, BNX2_PCICFG_REG_WINDOW, msg);
1970 spin_unlock(&bp->indirect_lock);
1974 bnx2_remote_phy_event(struct bnx2 *bp)
1977 u8 link_up = bp->link_up;
1980 msg = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
1983 bnx2_send_heart_beat(bp);
1988 bp->link_up = 0;
1992 bp->link_up = 1;
1994 bp->duplex = DUPLEX_FULL;
1997 bp->duplex = DUPLEX_HALF;
2000 bp->line_speed = SPEED_10;
2003 bp->duplex = DUPLEX_HALF;
2007 bp->line_speed = SPEED_100;
2010 bp->duplex = DUPLEX_HALF;
2013 bp->line_speed = SPEED_1000;
2016 bp->duplex = DUPLEX_HALF;
2019 bp->line_speed = SPEED_2500;
2022 bp->line_speed = 0;
2026 bp->flow_ctrl = 0;
2027 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) !=
2029 if (bp->duplex == DUPLEX_FULL)
2030 bp->flow_ctrl = bp->req_flow_ctrl;
2033 bp->flow_ctrl |= FLOW_CTRL_TX;
2035 bp->flow_ctrl |= FLOW_CTRL_RX;
2038 old_port = bp->phy_port;
2040 bp->phy_port = PORT_FIBRE;
2042 bp->phy_port = PORT_TP;
2044 if (old_port != bp->phy_port)
2045 bnx2_set_default_link(bp);
2048 if (bp->link_up != link_up)
2049 bnx2_report_link(bp);
2051 bnx2_set_mac_link(bp);
2055 bnx2_set_remote_link(struct bnx2 *bp)
2059 evt_code = bnx2_shmem_rd(bp, BNX2_FW_EVT_CODE_MB);
2062 bnx2_remote_phy_event(bp);
2066 bnx2_send_heart_beat(bp);
2073 bnx2_setup_copper_phy(struct bnx2 *bp)
2074 __releases(&bp->phy_lock)
2075 __acquires(&bp->phy_lock)
2080 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
2082 bnx2_read_phy(bp, bp->mii_adv, &adv_reg);
2086 new_adv = ADVERTISE_CSMA | ethtool_adv_to_mii_adv_t(bp->advertising);
2088 if (bp->autoneg & AUTONEG_SPEED) {
2092 new_adv |= bnx2_phy_get_pause_adv(bp);
2094 bnx2_read_phy(bp, MII_CTRL1000, &adv1000_reg);
2097 new_adv1000 |= ethtool_adv_to_mii_ctrl1000_t(bp->advertising);
2102 bnx2_write_phy(bp, bp->mii_adv, new_adv);
2103 bnx2_write_phy(bp, MII_CTRL1000, new_adv1000);
2104 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_ANRESTART |
2107 else if (bp->link_up) {
2111 bnx2_resolve_flow_ctrl(bp);
2112 bnx2_set_mac_link(bp);
2119 bnx2_write_phy(bp, bp->mii_adv, new_adv);
2122 if (bp->req_line_speed == SPEED_100) {
2125 if (bp->req_duplex == DUPLEX_FULL) {
2131 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
2132 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
2136 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
2137 spin_unlock_bh(&bp->phy_lock);
2139 spin_lock_bh(&bp->phy_lock);
2141 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
2142 bnx2_read_phy(bp, bp->mii_bmsr, &bmsr);
2145 bnx2_write_phy(bp, bp->mii_bmcr, new_bmcr);
2152 bp->line_speed = bp->req_line_speed;
2153 bp->duplex = bp->req_duplex;
2154 bnx2_resolve_flow_ctrl(bp);
2155 bnx2_set_mac_link(bp);
2158 bnx2_resolve_flow_ctrl(bp);
2159 bnx2_set_mac_link(bp);
2165 bnx2_setup_phy(struct bnx2 *bp, u8 port)
2166 __releases(&bp->phy_lock)
2167 __acquires(&bp->phy_lock)
2169 if (bp->loopback == MAC_LOOPBACK)
2172 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
2173 return bnx2_setup_serdes_phy(bp, port);
2176 return bnx2_setup_copper_phy(bp);
2181 bnx2_init_5709s_phy(struct bnx2 *bp, int reset_phy)
2185 bp->mii_bmcr = MII_BMCR + 0x10;
2186 bp->mii_bmsr = MII_BMSR + 0x10;
2187 bp->mii_bmsr1 = MII_BNX2_GP_TOP_AN_STATUS1;
2188 bp->mii_adv = MII_ADVERTISE + 0x10;
2189 bp->mii_lpa = MII_LPA + 0x10;
2190 bp->mii_up1 = MII_BNX2_OVER1G_UP1;
2192 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_AER);
2193 bnx2_write_phy(bp, MII_BNX2_AER_AER, MII_BNX2_AER_AER_AN_MMD);
2195 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
2197 bnx2_reset_phy(bp);
2199 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_SERDES_DIG);
2201 bnx2_read_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, &val);
2204 bnx2_write_phy(bp, MII_BNX2_SERDES_DIG_1000XCTL1, val);
2206 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_OVER1G);
2207 bnx2_read_phy(bp, MII_BNX2_OVER1G_UP1, &val);
2208 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
2212 bnx2_write_phy(bp, MII_BNX2_OVER1G_UP1, val);
2214 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_BAM_NXTPG);
2215 bnx2_read_phy(bp, MII_BNX2_BAM_NXTPG_CTL, &val);
2217 bnx2_write_phy(bp, MII_BNX2_BAM_NXTPG_CTL, val);
2219 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_CL73_USERB0);
2223 bnx2_write_phy(bp, MII_BNX2_CL73_BAM_CTL1, val);
2225 bnx2_write_phy(bp, MII_BNX2_BLK_ADDR, MII_BNX2_BLK_ADDR_COMBO_IEEEB0);
2231 bnx2_init_5708s_phy(struct bnx2 *bp, int reset_phy)
2236 bnx2_reset_phy(bp);
2238 bp->mii_up1 = BCM5708S_UP1;
2240 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG3);
2241 bnx2_write_phy(bp, BCM5708S_DIG_3_0, BCM5708S_DIG_3_0_USE_IEEE);
2242 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2244 bnx2_read_phy(bp, BCM5708S_1000X_CTL1, &val);
2246 bnx2_write_phy(bp, BCM5708S_1000X_CTL1, val);
2248 bnx2_read_phy(bp, BCM5708S_1000X_CTL2, &val);
2250 bnx2_write_phy(bp, BCM5708S_1000X_CTL2, val);
2252 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) {
2253 bnx2_read_phy(bp, BCM5708S_UP1, &val);
2255 bnx2_write_phy(bp, BCM5708S_UP1, val);
2258 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_A0) ||
2259 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_B0) ||
2260 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_B1)) {
2262 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2264 bnx2_read_phy(bp, BCM5708S_TX_ACTL1, &val);
2266 bnx2_write_phy(bp, BCM5708S_TX_ACTL1, val);
2267 bnx2_write_phy(bp, BCM5708S_BLK_ADDR, BCM5708S_BLK_ADDR_DIG);
2270 val = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_CONFIG) &
2276 is_backplane = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
2278 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2280 bnx2_write_phy(bp, BCM5708S_TX_ACTL3, val);
2281 bnx2_write_phy(bp, BCM5708S_BLK_ADDR,
2289 bnx2_init_5706s_phy(struct bnx2 *bp, int reset_phy)
2292 bnx2_reset_phy(bp);
2294 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
2296 if (BNX2_CHIP(bp) == BNX2_CHIP_5706)
2297 BNX2_WR(bp, BNX2_MISC_GP_HW_CTL0, 0x300);
2299 if (bp->dev->mtu > ETH_DATA_LEN) {
2303 bnx2_write_phy(bp, 0x18, 0x7);
2304 bnx2_read_phy(bp, 0x18, &val);
2305 bnx2_write_phy(bp, 0x18, (val & 0xfff8) | 0x4000);
2307 bnx2_write_phy(bp, 0x1c, 0x6c00);
2308 bnx2_read_phy(bp, 0x1c, &val);
2309 bnx2_write_phy(bp, 0x1c, (val & 0x3ff) | 0xec02);
2314 bnx2_write_phy(bp, 0x18, 0x7);
2315 bnx2_read_phy(bp, 0x18, &val);
2316 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2318 bnx2_write_phy(bp, 0x1c, 0x6c00);
2319 bnx2_read_phy(bp, 0x1c, &val);
2320 bnx2_write_phy(bp, 0x1c, (val & 0x3fd) | 0xec00);
2327 bnx2_init_copper_phy(struct bnx2 *bp, int reset_phy)
2332 bnx2_reset_phy(bp);
2334 if (bp->phy_flags & BNX2_PHY_FLAG_CRC_FIX) {
2335 bnx2_write_phy(bp, 0x18, 0x0c00);
2336 bnx2_write_phy(bp, 0x17, 0x000a);
2337 bnx2_write_phy(bp, 0x15, 0x310b);
2338 bnx2_write_phy(bp, 0x17, 0x201f);
2339 bnx2_write_phy(bp, 0x15, 0x9506);
2340 bnx2_write_phy(bp, 0x17, 0x401f);
2341 bnx2_write_phy(bp, 0x15, 0x14e2);
2342 bnx2_write_phy(bp, 0x18, 0x0400);
2345 if (bp->phy_flags & BNX2_PHY_FLAG_DIS_EARLY_DAC) {
2346 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS,
2348 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &val);
2350 bnx2_write_phy(bp, MII_BNX2_DSP_RW_PORT, val);
2353 if (bp->dev->mtu > ETH_DATA_LEN) {
2355 bnx2_write_phy(bp, 0x18, 0x7);
2356 bnx2_read_phy(bp, 0x18, &val);
2357 bnx2_write_phy(bp, 0x18, val | 0x4000);
2359 bnx2_read_phy(bp, 0x10, &val);
2360 bnx2_write_phy(bp, 0x10, val | 0x1);
2363 bnx2_write_phy(bp, 0x18, 0x7);
2364 bnx2_read_phy(bp, 0x18, &val);
2365 bnx2_write_phy(bp, 0x18, val & ~0x4007);
2367 bnx2_read_phy(bp, 0x10, &val);
2368 bnx2_write_phy(bp, 0x10, val & ~0x1);
2372 bnx2_write_phy(bp, MII_BNX2_AUX_CTL, AUX_CTL_MISC_CTL);
2373 bnx2_read_phy(bp, MII_BNX2_AUX_CTL, &val);
2377 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
2380 bnx2_write_phy(bp, MII_BNX2_AUX_CTL, val);
2386 bnx2_init_phy(struct bnx2 *bp, int reset_phy)
2387 __releases(&bp->phy_lock)
2388 __acquires(&bp->phy_lock)
2393 bp->phy_flags &= ~BNX2_PHY_FLAG_INT_MODE_MASK;
2394 bp->phy_flags |= BNX2_PHY_FLAG_INT_MODE_LINK_READY;
2396 bp->mii_bmcr = MII_BMCR;
2397 bp->mii_bmsr = MII_BMSR;
2398 bp->mii_bmsr1 = MII_BMSR;
2399 bp->mii_adv = MII_ADVERTISE;
2400 bp->mii_lpa = MII_LPA;
2402 BNX2_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
2404 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
2407 bnx2_read_phy(bp, MII_PHYSID1, &val);
2408 bp->phy_id = val << 16;
2409 bnx2_read_phy(bp, MII_PHYSID2, &val);
2410 bp->phy_id |= val & 0xffff;
2412 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
2413 if (BNX2_CHIP(bp) == BNX2_CHIP_5706)
2414 rc = bnx2_init_5706s_phy(bp, reset_phy);
2415 else if (BNX2_CHIP(bp) == BNX2_CHIP_5708)
2416 rc = bnx2_init_5708s_phy(bp, reset_phy);
2417 else if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
2418 rc = bnx2_init_5709s_phy(bp, reset_phy);
2421 rc = bnx2_init_copper_phy(bp, reset_phy);
2426 rc = bnx2_setup_phy(bp, bp->phy_port);
2432 bnx2_set_mac_loopback(struct bnx2 *bp)
2436 mac_mode = BNX2_RD(bp, BNX2_EMAC_MODE);
2439 BNX2_WR(bp, BNX2_EMAC_MODE, mac_mode);
2440 bp->link_up = 1;
2447 bnx2_set_phy_loopback(struct bnx2 *bp)
2452 spin_lock_bh(&bp->phy_lock);
2453 rc = bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK | BMCR_FULLDPLX |
2455 spin_unlock_bh(&bp->phy_lock);
2460 if (bnx2_test_link(bp) == 0)
2465 mac_mode = BNX2_RD(bp, BNX2_EMAC_MODE);
2471 BNX2_WR(bp, BNX2_EMAC_MODE, mac_mode);
2472 bp->link_up = 1;
2477 bnx2_dump_mcp_state(struct bnx2 *bp)
2479 struct net_device *dev = bp->dev;
2483 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
2491 bnx2_reg_rd_ind(bp, mcp_p0), bnx2_reg_rd_ind(bp, mcp_p1));
2493 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_MODE),
2494 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_STATE),
2495 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_EVENT_MASK));
2497 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_PROGRAM_COUNTER),
2498 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_PROGRAM_COUNTER),
2499 bnx2_reg_rd_ind(bp, BNX2_MCP_CPU_INSTRUCTION));
2502 bnx2_shmem_rd(bp, BNX2_DRV_MB),
2503 bnx2_shmem_rd(bp, BNX2_FW_MB),
2504 bnx2_shmem_rd(bp, BNX2_LINK_STATUS));
2505 pr_cont(" drv_pulse_mb[%08x]\n", bnx2_shmem_rd(bp, BNX2_DRV_PULSE_MB));
2507 bnx2_shmem_rd(bp, BNX2_DEV_INFO_SIGNATURE),
2508 bnx2_shmem_rd(bp, BNX2_BC_STATE_RESET_TYPE));
2510 bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION));
2511 DP_SHMEM_LINE(bp, BNX2_BC_RESET_TYPE);
2512 DP_SHMEM_LINE(bp, 0x3cc);
2513 DP_SHMEM_LINE(bp, 0x3dc);
2514 DP_SHMEM_LINE(bp, 0x3ec);
2515 netdev_err(dev, "DEBUG: 0x3fc[%08x]\n", bnx2_shmem_rd(bp, 0x3fc));
2520 bnx2_fw_sync(struct bnx2 *bp, u32 msg_data, int ack, int silent)
2525 bp->fw_wr_seq++;
2526 msg_data |= bp->fw_wr_seq;
2527 bp->fw_last_msg = msg_data;
2529 bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
2538 val = bnx2_shmem_rd(bp, BNX2_FW_MB);
2551 bnx2_shmem_wr(bp, BNX2_DRV_MB, msg_data);
2554 bnx2_dump_mcp_state(bp);
2567 bnx2_init_5709_context(struct bnx2 *bp)
2574 BNX2_WR(bp, BNX2_CTX_COMMAND, val);
2576 val = BNX2_RD(bp, BNX2_CTX_COMMAND);
2584 for (i = 0; i < bp->ctx_pages; i++) {
2587 if (bp->ctx_blk[i])
2588 memset(bp->ctx_blk[i], 0, BNX2_PAGE_SIZE);
2592 BNX2_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA0,
2593 (bp->ctx_blk_mapping[i] & 0xffffffff) |
2595 BNX2_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA1,
2596 (u64) bp->ctx_blk_mapping[i] >> 32);
2597 BNX2_WR(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL, i |
2601 val = BNX2_RD(bp, BNX2_CTX_HOST_PAGE_TBL_CTRL);
2615 bnx2_init_context(struct bnx2 *bp)
2626 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) {
2647 BNX2_WR(bp, BNX2_CTX_VIRT_ADDR, vcid_addr);
2648 BNX2_WR(bp, BNX2_CTX_PAGE_TBL, pcid_addr);
2652 bnx2_ctx_wr(bp, vcid_addr, offset, 0);
2658 bnx2_alloc_bad_rbuf(struct bnx2 *bp)
2668 BNX2_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
2674 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
2676 bnx2_reg_wr_ind(bp, BNX2_RBUF_COMMAND,
2679 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_FW_BUF_ALLOC);
2689 val = bnx2_reg_rd_ind(bp, BNX2_RBUF_STATUS1);
2700 bnx2_reg_wr_ind(bp, BNX2_RBUF_FW_BUF_FREE, val);
2707 bnx2_set_mac_addr(struct bnx2 *bp, u8 *mac_addr, u32 pos)
2713 BNX2_WR(bp, BNX2_EMAC_MAC_MATCH0 + (pos * 8), val);
2718 BNX2_WR(bp, BNX2_EMAC_MAC_MATCH1 + (pos * 8), val);
2722 bnx2_alloc_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index, gfp_t gfp)
2732 mapping = dma_map_page(&bp->pdev->dev, page, 0, PAGE_SIZE,
2734 if (dma_mapping_error(&bp->pdev->dev, mapping)) {
2747 bnx2_free_rx_page(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index)
2755 dma_unmap_page(&bp->pdev->dev, dma_unmap_addr(rx_pg, mapping),
2763 bnx2_alloc_rx_data(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u16 index, gfp_t gfp)
2771 data = kmalloc(bp->rx_buf_size, gfp);
2775 mapping = dma_map_single(&bp->pdev->dev,
2777 bp->rx_buf_use_size,
2779 if (dma_mapping_error(&bp->pdev->dev, mapping)) {
2790 rxr->rx_prod_bseq += bp->rx_buf_use_size;
2796 bnx2_phy_event_is_set(struct bnx2 *bp, struct bnx2_napi *bnapi, u32 event)
2806 BNX2_WR(bp, BNX2_PCICFG_STATUS_BIT_SET_CMD, event);
2808 BNX2_WR(bp, BNX2_PCICFG_STATUS_BIT_CLEAR_CMD, event);
2816 bnx2_phy_int(struct bnx2 *bp, struct bnx2_napi *bnapi)
2818 spin_lock(&bp->phy_lock);
2820 if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_LINK_STATE))
2821 bnx2_set_link(bp);
2822 if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_TIMER_ABORT))
2823 bnx2_set_remote_link(bp);
2825 spin_unlock(&bp->phy_lock);
2842 bnx2_tx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
2850 index = (bnapi - bp->bnx2_napi);
2851 txq = netdev_get_tx_queue(bp->dev, index);
2883 dma_unmap_single(&bp->pdev->dev, dma_unmap_addr(tx_buf, mapping),
2895 dma_unmap_page(&bp->pdev->dev,
2925 (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)) {
2928 (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh))
2937 bnx2_reuse_rx_skb_pages(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
2995 bnx2_reuse_rx_data(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr,
3004 dma_sync_single_for_device(&bp->pdev->dev,
3008 rxr->rx_prod_bseq += bp->rx_buf_use_size;
3025 bnx2_rx_skb(struct bnx2 *bp, struct bnx2_rx_ring_info *rxr, u8 *data,
3033 err = bnx2_alloc_rx_data(bp, rxr, prod, GFP_ATOMIC);
3035 bnx2_reuse_rx_data(bp, rxr, data, (u16) (ring_idx >> 16), prod);
3041 bnx2_reuse_rx_skb_pages(bp, rxr, NULL, pages);
3046 dma_unmap_single(&bp->pdev->dev, dma_addr, bp->rx_buf_use_size,
3076 bnx2_reuse_rx_skb_pages(bp, rxr, NULL,
3101 err = bnx2_alloc_rx_page(bp, rxr,
3107 bnx2_reuse_rx_skb_pages(bp, rxr, skb,
3112 dma_unmap_page(&bp->pdev->dev, mapping_old,
3142 bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
3181 dma_sync_single_for_cpu(&bp->pdev->dev, dma_addr,
3196 } else if (len > bp->rx_jumbo_thresh) {
3197 hdr_len = bp->rx_jumbo_thresh;
3207 bnx2_reuse_rx_data(bp, rxr, data, sw_ring_cons,
3214 bnx2_reuse_rx_skb_pages(bp, rxr, NULL, pages);
3221 if (len <= bp->rx_copy_thresh) {
3222 skb = netdev_alloc_skb(bp->dev, len + 6);
3224 bnx2_reuse_rx_data(bp, rxr, data, sw_ring_cons,
3236 bnx2_reuse_rx_data(bp, rxr, data,
3240 skb = bnx2_rx_skb(bp, rxr, data, len, hdr_len, dma_addr,
3246 !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG))
3249 skb->protocol = eth_type_trans(skb, bp->dev);
3251 if (len > (bp->dev->mtu + ETH_HLEN) &&
3261 if ((bp->dev->features & NETIF_F_RXCSUM) &&
3269 if ((bp->dev->features & NETIF_F_RXHASH) &&
3275 skb_record_rx_queue(skb, bnapi - &bp->bnx2_napi[0]);
3296 BNX2_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
3298 BNX2_WR16(bp, rxr->rx_bidx_addr, sw_prod);
3300 BNX2_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
3313 struct bnx2 *bp = bnapi->bp;
3316 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3321 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3333 struct bnx2 *bp = bnapi->bp;
3338 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3350 struct bnx2 *bp = bnapi->bp;
3360 (BNX2_RD(bp, BNX2_PCICFG_MISC_STATUS) &
3364 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3371 BNX2_RD(bp, BNX2_PCICFG_INT_ACK_CMD);
3374 if (unlikely(atomic_read(&bp->intr_sem) != 0))
3421 bnx2_chk_missed_msi(struct bnx2 *bp)
3423 struct bnx2_napi *bnapi = &bp->bnx2_napi[0];
3427 msi_ctrl = BNX2_RD(bp, BNX2_PCICFG_MSI_CONTROL);
3431 if (bnapi->last_status_idx == bp->idle_chk_status_idx) {
3432 BNX2_WR(bp, BNX2_PCICFG_MSI_CONTROL, msi_ctrl &
3434 BNX2_WR(bp, BNX2_PCICFG_MSI_CONTROL, msi_ctrl);
3435 bnx2_msi(bp->irq_tbl[0].vector, bnapi);
3439 bp->idle_chk_status_idx = bnapi->last_status_idx;
3443 static void bnx2_poll_cnic(struct bnx2 *bp, struct bnx2_napi *bnapi)
3451 c_ops = rcu_dereference(bp->cnic_ops);
3453 bnapi->cnic_tag = c_ops->cnic_handler(bp->cnic_data,
3459 static void bnx2_poll_link(struct bnx2 *bp, struct bnx2_napi *bnapi)
3468 bnx2_phy_int(bp, bnapi);
3473 BNX2_WR(bp, BNX2_HC_COMMAND,
3474 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
3475 BNX2_RD(bp, BNX2_HC_COMMAND);
3479 static int bnx2_poll_work(struct bnx2 *bp, struct bnx2_napi *bnapi,
3486 bnx2_tx_int(bp, bnapi, 0);
3489 work_done += bnx2_rx_int(bp, bnapi, budget - work_done);
3497 struct bnx2 *bp = bnapi->bp;
3502 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
3512 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD, bnapi->int_num |
3524 struct bnx2 *bp = bnapi->bp;
3529 bnx2_poll_link(bp, bnapi);
3531 work_done = bnx2_poll_work(bp, bnapi, work_done, budget);
3534 bnx2_poll_cnic(bp, bnapi);
3549 if (likely(bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)) {
3550 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3555 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3560 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
3576 struct bnx2 *bp = netdev_priv(dev);
3584 spin_lock_bh(&bp->phy_lock);
3586 rx_mode = bp->rx_mode & ~(BNX2_EMAC_RX_MODE_PROMISCUOUS |
3590 (bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
3600 BNX2_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3623 BNX2_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3638 bnx2_set_mac_addr(bp, ha->addr,
3647 if (rx_mode != bp->rx_mode) {
3648 bp->rx_mode = rx_mode;
3649 BNX2_WR(bp, BNX2_EMAC_RX_MODE, rx_mode);
3652 BNX2_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
3653 BNX2_WR(bp, BNX2_RPM_SORT_USER0, sort_mode);
3654 BNX2_WR(bp, BNX2_RPM_SORT_USER0, sort_mode | BNX2_RPM_SORT_USER0_ENA);
3656 spin_unlock_bh(&bp->phy_lock);
3686 static void bnx2_release_firmware(struct bnx2 *bp)
3688 if (bp->rv2p_firmware) {
3689 release_firmware(bp->mips_firmware);
3690 release_firmware(bp->rv2p_firmware);
3691 bp->rv2p_firmware = NULL;
3695 static int bnx2_request_uncached_firmware(struct bnx2 *bp)
3702 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
3704 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5709_A0) ||
3705 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5709_A1))
3714 rc = request_firmware(&bp->mips_firmware, mips_fw_file, &bp->pdev->dev);
3720 rc = request_firmware(&bp->rv2p_firmware, rv2p_fw_file, &bp->pdev->dev);
3725 mips_fw = (const struct bnx2_mips_fw_file *) bp->mips_firmware->data;
3726 rv2p_fw = (const struct bnx2_rv2p_fw_file *) bp->rv2p_firmware->data;
3727 if (bp->mips_firmware->size < sizeof(*mips_fw) ||
3728 check_mips_fw_entry(bp->mips_firmware, &mips_fw->com) ||
3729 check_mips_fw_entry(bp->mips_firmware, &mips_fw->cp) ||
3730 check_mips_fw_entry(bp->mips_firmware, &mips_fw->rxp) ||
3731 check_mips_fw_entry(bp->mips_firmware, &mips_fw->tpat) ||
3732 check_mips_fw_entry(bp->mips_firmware, &mips_fw->txp)) {
3737 if (bp->rv2p_firmware->size < sizeof(*rv2p_fw) ||
3738 check_fw_section(bp->rv2p_firmware, &rv2p_fw->proc1.rv2p, 8, true) ||
3739 check_fw_section(bp->rv2p_firmware, &rv2p_fw->proc2.rv2p, 8, true)) {
3748 release_firmware(bp->rv2p_firmware);
3749 bp->rv2p_firmware = NULL;
3751 release_firmware(bp->mips_firmware);
3755 static int bnx2_request_firmware(struct bnx2 *bp)
3757 return bp->rv2p_firmware ? 0 : bnx2_request_uncached_firmware(bp);
3773 load_rv2p_fw(struct bnx2 *bp, u32 rv2p_proc,
3784 rv2p_code = (__be32 *)(bp->rv2p_firmware->data + file_offset);
3795 BNX2_WR(bp, BNX2_RV2P_INSTR_HIGH, be32_to_cpu(*rv2p_code));
3797 BNX2_WR(bp, BNX2_RV2P_INSTR_LOW, be32_to_cpu(*rv2p_code));
3801 BNX2_WR(bp, addr, val);
3804 rv2p_code = (__be32 *)(bp->rv2p_firmware->data + file_offset);
3811 BNX2_WR(bp, BNX2_RV2P_INSTR_HIGH, code);
3814 BNX2_WR(bp, BNX2_RV2P_INSTR_LOW, code);
3817 BNX2_WR(bp, addr, val);
3823 BNX2_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC1_RESET);
3826 BNX2_WR(bp, BNX2_RV2P_COMMAND, BNX2_RV2P_COMMAND_PROC2_RESET);
3833 load_cpu_fw(struct bnx2 *bp, const struct cpu_reg *cpu_reg,
3842 val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
3844 bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
3845 bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
3851 data = (__be32 *)(bp->mips_firmware->data + file_offset);
3858 bnx2_reg_wr_ind(bp, offset, be32_to_cpu(data[j]));
3865 data = (__be32 *)(bp->mips_firmware->data + file_offset);
3872 bnx2_reg_wr_ind(bp, offset, be32_to_cpu(data[j]));
3879 data = (__be32 *)(bp->mips_firmware->data + file_offset);
3886 bnx2_reg_wr_ind(bp, offset, be32_to_cpu(data[j]));
3890 bnx2_reg_wr_ind(bp, cpu_reg->inst, 0);
3893 bnx2_reg_wr_ind(bp, cpu_reg->pc, val);
3896 val = bnx2_reg_rd_ind(bp, cpu_reg->mode);
3898 bnx2_reg_wr_ind(bp, cpu_reg->state, cpu_reg->state_value_clear);
3899 bnx2_reg_wr_ind(bp, cpu_reg->mode, val);
3905 bnx2_init_cpus(struct bnx2 *bp)
3908 (const struct bnx2_mips_fw_file *) bp->mips_firmware->data;
3910 (const struct bnx2_rv2p_fw_file *) bp->rv2p_firmware->data;
3914 load_rv2p_fw(bp, RV2P_PROC1, &rv2p_fw->proc1);
3915 load_rv2p_fw(bp, RV2P_PROC2, &rv2p_fw->proc2);
3918 rc = load_cpu_fw(bp, &cpu_reg_rxp, &mips_fw->rxp);
3923 rc = load_cpu_fw(bp, &cpu_reg_txp, &mips_fw->txp);
3928 rc = load_cpu_fw(bp, &cpu_reg_tpat, &mips_fw->tpat);
3933 rc = load_cpu_fw(bp, &cpu_reg_com, &mips_fw->com);
3938 rc = load_cpu_fw(bp, &cpu_reg_cp, &mips_fw->cp);
3945 bnx2_setup_wol(struct bnx2 *bp)
3950 if (bp->wol) {
3954 autoneg = bp->autoneg;
3955 advertising = bp->advertising;
3957 if (bp->phy_port == PORT_TP) {
3958 bp->autoneg = AUTONEG_SPEED;
3959 bp->advertising = ADVERTISED_10baseT_Half |
3966 spin_lock_bh(&bp->phy_lock);
3967 bnx2_setup_phy(bp, bp->phy_port);
3968 spin_unlock_bh(&bp->phy_lock);
3970 bp->autoneg = autoneg;
3971 bp->advertising = advertising;
3973 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
3975 val = BNX2_RD(bp, BNX2_EMAC_MODE);
3982 if (bp->phy_port == PORT_TP) {
3986 if (bp->line_speed == SPEED_2500)
3990 BNX2_WR(bp, BNX2_EMAC_MODE, val);
3994 BNX2_WR(bp, BNX2_EMAC_MULTICAST_HASH0 + (i * 4),
3997 BNX2_WR(bp, BNX2_EMAC_RX_MODE, BNX2_EMAC_RX_MODE_SORT_MODE);
4000 BNX2_WR(bp, BNX2_RPM_SORT_USER0, 0x0);
4001 BNX2_WR(bp, BNX2_RPM_SORT_USER0, val);
4002 BNX2_WR(bp, BNX2_RPM_SORT_USER0, val | BNX2_RPM_SORT_USER0_ENA);
4005 BNX2_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
4010 val = BNX2_RD(bp, BNX2_RPM_CONFIG);
4012 BNX2_WR(bp, BNX2_RPM_CONFIG, val);
4019 if (!(bp->flags & BNX2_FLAG_NO_WOL)) {
4023 if (bp->fw_last_msg || BNX2_CHIP(bp) != BNX2_CHIP_5709) {
4024 bnx2_fw_sync(bp, wol_msg, 1, 0);
4030 val = bnx2_shmem_rd(bp, BNX2_PORT_FEATURE);
4031 bnx2_shmem_wr(bp, BNX2_PORT_FEATURE,
4033 bnx2_fw_sync(bp, wol_msg, 1, 0);
4034 bnx2_shmem_wr(bp, BNX2_PORT_FEATURE, val);
4040 bnx2_set_power_state(struct bnx2 *bp, pci_power_t state)
4046 pci_enable_wake(bp->pdev, PCI_D0, false);
4047 pci_set_power_state(bp->pdev, PCI_D0);
4049 val = BNX2_RD(bp, BNX2_EMAC_MODE);
4052 BNX2_WR(bp, BNX2_EMAC_MODE, val);
4054 val = BNX2_RD(bp, BNX2_RPM_CONFIG);
4056 BNX2_WR(bp, BNX2_RPM_CONFIG, val);
4060 bnx2_setup_wol(bp);
4061 pci_wake_from_d3(bp->pdev, bp->wol);
4062 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) ||
4063 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A1)) {
4065 if (bp->wol)
4066 pci_set_power_state(bp->pdev, PCI_D3hot);
4070 if (!bp->fw_last_msg && BNX2_CHIP(bp) == BNX2_CHIP_5709) {
4077 val = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
4080 bnx2_shmem_wr(bp, BNX2_BC_STATE_CONDITION, val);
4082 pci_set_power_state(bp->pdev, PCI_D3hot);
4096 bnx2_acquire_nvram_lock(struct bnx2 *bp)
4102 BNX2_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_SET2);
4104 val = BNX2_RD(bp, BNX2_NVM_SW_ARB);
4118 bnx2_release_nvram_lock(struct bnx2 *bp)
4124 BNX2_WR(bp, BNX2_NVM_SW_ARB, BNX2_NVM_SW_ARB_ARB_REQ_CLR2);
4127 val = BNX2_RD(bp, BNX2_NVM_SW_ARB);
4142 bnx2_enable_nvram_write(struct bnx2 *bp)
4146 val = BNX2_RD(bp, BNX2_MISC_CFG);
4147 BNX2_WR(bp, BNX2_MISC_CFG, val | BNX2_MISC_CFG_NVM_WR_EN_PCI);
4149 if (bp->flash_info->flags & BNX2_NV_WREN) {
4152 BNX2_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
4153 BNX2_WR(bp, BNX2_NVM_COMMAND,
4159 val = BNX2_RD(bp, BNX2_NVM_COMMAND);
4171 bnx2_disable_nvram_write(struct bnx2 *bp)
4175 val = BNX2_RD(bp, BNX2_MISC_CFG);
4176 BNX2_WR(bp, BNX2_MISC_CFG, val & ~BNX2_MISC_CFG_NVM_WR_EN);
4181 bnx2_enable_nvram_access(struct bnx2 *bp)
4185 val = BNX2_RD(bp, BNX2_NVM_ACCESS_ENABLE);
4187 BNX2_WR(bp, BNX2_NVM_ACCESS_ENABLE,
4192 bnx2_disable_nvram_access(struct bnx2 *bp)
4196 val = BNX2_RD(bp, BNX2_NVM_ACCESS_ENABLE);
4198 BNX2_WR(bp, BNX2_NVM_ACCESS_ENABLE,
4204 bnx2_nvram_erase_page(struct bnx2 *bp, u32 offset)
4209 if (bp->flash_info->flags & BNX2_NV_BUFFERED)
4218 BNX2_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
4221 BNX2_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
4224 BNX2_WR(bp, BNX2_NVM_COMMAND, cmd);
4232 val = BNX2_RD(bp, BNX2_NVM_COMMAND);
4244 bnx2_nvram_read_dword(struct bnx2 *bp, u32 offset, u8 *ret_val, u32 cmd_flags)
4253 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
4254 offset = ((offset / bp->flash_info->page_size) <<
4255 bp->flash_info->page_bits) +
4256 (offset % bp->flash_info->page_size);
4260 BNX2_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
4263 BNX2_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
4266 BNX2_WR(bp, BNX2_NVM_COMMAND, cmd);
4274 val = BNX2_RD(bp, BNX2_NVM_COMMAND);
4276 __be32 v = cpu_to_be32(BNX2_RD(bp, BNX2_NVM_READ));
4289 bnx2_nvram_write_dword(struct bnx2 *bp, u32 offset, u8 *val, u32 cmd_flags)
4299 if (bp->flash_info->flags & BNX2_NV_TRANSLATE) {
4300 offset = ((offset / bp->flash_info->page_size) <<
4301 bp->flash_info->page_bits) +
4302 (offset % bp->flash_info->page_size);
4306 BNX2_WR(bp, BNX2_NVM_COMMAND, BNX2_NVM_COMMAND_DONE);
4311 BNX2_WR(bp, BNX2_NVM_WRITE, be32_to_cpu(val32));
4314 BNX2_WR(bp, BNX2_NVM_ADDR, offset & BNX2_NVM_ADDR_NVM_ADDR_VALUE);
4317 BNX2_WR(bp, BNX2_NVM_COMMAND, cmd);
4323 if (BNX2_RD(bp, BNX2_NVM_COMMAND) & BNX2_NVM_COMMAND_DONE)
4333 bnx2_init_nvram(struct bnx2 *bp)
4339 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
4340 bp->flash_info = &flash_5709;
4345 val = BNX2_RD(bp, BNX2_NVM_CFG1);
4356 bp->flash_info = flash;
4374 bp->flash_info = flash;
4377 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4381 bnx2_enable_nvram_access(bp);
4384 BNX2_WR(bp, BNX2_NVM_CFG1, flash->config1);
4385 BNX2_WR(bp, BNX2_NVM_CFG2, flash->config2);
4386 BNX2_WR(bp, BNX2_NVM_CFG3, flash->config3);
4387 BNX2_WR(bp, BNX2_NVM_WRITE1, flash->write1);
4390 bnx2_disable_nvram_access(bp);
4391 bnx2_release_nvram_lock(bp);
4399 bp->flash_info = NULL;
4405 val = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG2);
4408 bp->flash_size = val;
4410 bp->flash_size = bp->flash_info->total_size;
4416 bnx2_nvram_read(struct bnx2 *bp, u32 offset, u8 *ret_buf,
4426 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4430 bnx2_enable_nvram_access(bp);
4454 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4479 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4492 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, cmd_flags);
4500 rc = bnx2_nvram_read_dword(bp, offset32, ret_buf, 0);
4512 rc = bnx2_nvram_read_dword(bp, offset32, buf, cmd_flags);
4518 bnx2_disable_nvram_access(bp);
4520 bnx2_release_nvram_lock(bp);
4526 bnx2_nvram_write(struct bnx2 *bp, u32 offset, u8 *data_buf,
4544 if ((rc = bnx2_nvram_read(bp, offset32, start, 4)))
4551 if ((rc = bnx2_nvram_read(bp, offset32 + len32 - 4, end, 4)))
4569 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4585 page_start -= (page_start % bp->flash_info->page_size);
4587 page_end = page_start + bp->flash_info->page_size;
4595 if ((rc = bnx2_acquire_nvram_lock(bp)) != 0)
4599 bnx2_enable_nvram_access(bp);
4602 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4607 for (j = 0; j < bp->flash_info->page_size; j += 4) {
4608 if (j == (bp->flash_info->page_size - 4)) {
4611 rc = bnx2_nvram_read_dword(bp,
4624 if ((rc = bnx2_enable_nvram_write(bp)) != 0)
4630 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4632 if ((rc = bnx2_nvram_erase_page(bp, page_start)) != 0)
4636 bnx2_enable_nvram_write(bp);
4641 rc = bnx2_nvram_write_dword(bp, addr,
4654 ((bp->flash_info->flags & BNX2_NV_BUFFERED) &&
4659 rc = bnx2_nvram_write_dword(bp, addr, buf,
4671 if (!(bp->flash_info->flags & BNX2_NV_BUFFERED)) {
4678 rc = bnx2_nvram_write_dword(bp, addr,
4689 bnx2_disable_nvram_write(bp);
4692 bnx2_disable_nvram_access(bp);
4693 bnx2_release_nvram_lock(bp);
4706 bnx2_init_fw_cap(struct bnx2 *bp)
4710 bp->phy_flags &= ~BNX2_PHY_FLAG_REMOTE_PHY_CAP;
4711 bp->flags &= ~BNX2_FLAG_CAN_KEEP_VLAN;
4713 if (!(bp->flags & BNX2_FLAG_ASF_ENABLE))
4714 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
4716 val = bnx2_shmem_rd(bp, BNX2_FW_CAP_MB);
4721 bp->flags |= BNX2_FLAG_CAN_KEEP_VLAN;
4725 if ((bp->phy_flags & BNX2_PHY_FLAG_SERDES) &&
4729 bp->phy_flags |= BNX2_PHY_FLAG_REMOTE_PHY_CAP;
4731 link = bnx2_shmem_rd(bp, BNX2_LINK_STATUS);
4733 bp->phy_port = PORT_FIBRE;
4735 bp->phy_port = PORT_TP;
4741 if (netif_running(bp->dev) && sig)
4742 bnx2_shmem_wr(bp, BNX2_DRV_ACK_CAP_MB, sig);
4746 bnx2_setup_msix_tbl(struct bnx2 *bp)
4748 BNX2_WR(bp, BNX2_PCI_GRC_WINDOW_ADDR, BNX2_PCI_GRC_WINDOW_ADDR_SEP_WIN);
4750 BNX2_WR(bp, BNX2_PCI_GRC_WINDOW2_ADDR, BNX2_MSIX_TABLE_ADDR);
4751 BNX2_WR(bp, BNX2_PCI_GRC_WINDOW3_ADDR, BNX2_MSIX_PBA_ADDR);
4755 bnx2_wait_dma_complete(struct bnx2 *bp)
4764 if ((BNX2_CHIP(bp) == BNX2_CHIP_5706) ||
4765 (BNX2_CHIP(bp) == BNX2_CHIP_5708)) {
4766 BNX2_WR(bp, BNX2_MISC_ENABLE_CLR_BITS,
4771 val = BNX2_RD(bp, BNX2_MISC_ENABLE_CLR_BITS);
4774 val = BNX2_RD(bp, BNX2_MISC_NEW_CORE_CTL);
4776 BNX2_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
4777 val = BNX2_RD(bp, BNX2_MISC_NEW_CORE_CTL);
4781 val = BNX2_RD(bp, BNX2_PCICFG_DEVICE_CONTROL);
4792 bnx2_reset_chip(struct bnx2 *bp, u32 reset_code)
4800 bnx2_wait_dma_complete(bp);
4803 bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT0 | reset_code, 1, 1);
4807 bnx2_shmem_wr(bp, BNX2_DRV_RESET_SIGNATURE,
4812 val = BNX2_RD(bp, BNX2_MISC_ID);
4814 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
4815 BNX2_WR(bp, BNX2_MISC_COMMAND, BNX2_MISC_COMMAND_SW_RESET);
4816 BNX2_RD(bp, BNX2_MISC_COMMAND);
4822 BNX2_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
4830 BNX2_WR(bp, BNX2_PCICFG_MISC_CONFIG, val);
4836 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) ||
4837 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A1))
4842 val = BNX2_RD(bp, BNX2_PCICFG_MISC_CONFIG);
4857 val = BNX2_RD(bp, BNX2_PCI_SWAP_DIAG0);
4864 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT1 | reset_code, 1, 0);
4868 spin_lock_bh(&bp->phy_lock);
4869 old_port = bp->phy_port;
4870 bnx2_init_fw_cap(bp);
4871 if ((bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) &&
4872 old_port != bp->phy_port)
4873 bnx2_set_default_remote_link(bp);
4874 spin_unlock_bh(&bp->phy_lock);
4876 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) {
4879 BNX2_WR(bp, BNX2_MISC_VREG_CONTROL, 0x000000fa);
4882 rc = bnx2_alloc_bad_rbuf(bp);
4885 if (bp->flags & BNX2_FLAG_USING_MSIX) {
4886 bnx2_setup_msix_tbl(bp);
4888 BNX2_WR(bp, BNX2_MISC_ECO_HW_CTL,
4896 bnx2_init_chip(struct bnx2 *bp)
4902 BNX2_WR(bp, BNX2_PCICFG_INT_ACK_CMD, BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
4915 if ((bp->flags & BNX2_FLAG_PCIX) && (bp->bus_speed_mhz == 133))
4918 if ((BNX2_CHIP(bp) == BNX2_CHIP_5706) &&
4919 (BNX2_CHIP_ID(bp) != BNX2_CHIP_ID_5706_A0) &&
4920 !(bp->flags & BNX2_FLAG_PCIX))
4923 BNX2_WR(bp, BNX2_DMA_CONFIG, val);
4925 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) {
4926 val = BNX2_RD(bp, BNX2_TDMA_CONFIG);
4928 BNX2_WR(bp, BNX2_TDMA_CONFIG, val);
4931 if (bp->flags & BNX2_FLAG_PCIX) {
4934 pci_read_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4936 pci_write_config_word(bp->pdev, bp->pcix_cap + PCI_X_CMD,
4940 BNX2_WR(bp, BNX2_MISC_ENABLE_SET_BITS,
4947 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
4948 rc = bnx2_init_5709_context(bp);
4952 bnx2_init_context(bp);
4954 if ((rc = bnx2_init_cpus(bp)) != 0)
4957 bnx2_init_nvram(bp);
4959 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
4961 val = BNX2_RD(bp, BNX2_MQ_CONFIG);
4964 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
4966 if (BNX2_CHIP_REV(bp) == BNX2_CHIP_REV_Ax)
4970 BNX2_WR(bp, BNX2_MQ_CONFIG, val);
4973 BNX2_WR(bp, BNX2_MQ_KNL_BYP_WIND_START, val);
4974 BNX2_WR(bp, BNX2_MQ_KNL_WIND_END, val);
4977 BNX2_WR(bp, BNX2_RV2P_CONFIG, val);
4980 val = BNX2_RD(bp, BNX2_TBDR_CONFIG);
4983 BNX2_WR(bp, BNX2_TBDR_CONFIG, val);
4985 val = bp->mac_addr[0] +
4986 (bp->mac_addr[1] << 8) +
4987 (bp->mac_addr[2] << 16) +
4988 bp->mac_addr[3] +
4989 (bp->mac_addr[4] << 8) +
4990 (bp->mac_addr[5] << 16);
4991 BNX2_WR(bp, BNX2_EMAC_BACKOFF_SEED, val);
4994 mtu = bp->dev->mtu;
4998 BNX2_WR(bp, BNX2_EMAC_RX_MTU_SIZE, val);
5003 bnx2_reg_wr_ind(bp, BNX2_RBUF_CONFIG, BNX2_RBUF_CONFIG_VAL(mtu));
5004 bnx2_reg_wr_ind(bp, BNX2_RBUF_CONFIG2, BNX2_RBUF_CONFIG2_VAL(mtu));
5005 bnx2_reg_wr_ind(bp, BNX2_RBUF_CONFIG3, BNX2_RBUF_CONFIG3_VAL(mtu));
5007 memset(bp->bnx2_napi[0].status_blk.msi, 0, bp->status_stats_size);
5009 bp->bnx2_napi[i].last_status_idx = 0;
5011 bp->idle_chk_status_idx = 0xffff;
5014 BNX2_WR(bp, BNX2_EMAC_ATTENTION_ENA, BNX2_EMAC_ATTENTION_ENA_LINK);
5016 BNX2_WR(bp, BNX2_HC_STATUS_ADDR_L,
5017 (u64) bp->status_blk_mapping & 0xffffffff);
5018 BNX2_WR(bp, BNX2_HC_STATUS_ADDR_H, (u64) bp->status_blk_mapping >> 32);
5020 BNX2_WR(bp, BNX2_HC_STATISTICS_ADDR_L,
5021 (u64) bp->stats_blk_mapping & 0xffffffff);
5022 BNX2_WR(bp, BNX2_HC_STATISTICS_ADDR_H,
5023 (u64) bp->stats_blk_mapping >> 32);
5025 BNX2_WR(bp, BNX2_HC_TX_QUICK_CONS_TRIP,
5026 (bp->tx_quick_cons_trip_int << 16) | bp->tx_quick_cons_trip);
5028 BNX2_WR(bp, BNX2_HC_RX_QUICK_CONS_TRIP,
5029 (bp->rx_quick_cons_trip_int << 16) | bp->rx_quick_cons_trip);
5031 BNX2_WR(bp, BNX2_HC_COMP_PROD_TRIP,
5032 (bp->comp_prod_trip_int << 16) | bp->comp_prod_trip);
5034 BNX2_WR(bp, BNX2_HC_TX_TICKS, (bp->tx_ticks_int << 16) | bp->tx_ticks);
5036 BNX2_WR(bp, BNX2_HC_RX_TICKS, (bp->rx_ticks_int << 16) | bp->rx_ticks);
5038 BNX2_WR(bp, BNX2_HC_COM_TICKS,
5039 (bp->com_ticks_int << 16) | bp->com_ticks);
5041 BNX2_WR(bp, BNX2_HC_CMD_TICKS,
5042 (bp->cmd_ticks_int << 16) | bp->cmd_ticks);
5044 if (bp->flags & BNX2_FLAG_BROKEN_STATS)
5045 BNX2_WR(bp, BNX2_HC_STATS_TICKS, 0);
5047 BNX2_WR(bp, BNX2_HC_STATS_TICKS, bp->stats_ticks);
5048 BNX2_WR(bp, BNX2_HC_STAT_COLLECT_TICKS, 0xbb8); /* 3ms */
5050 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A1)
5057 if (bp->flags & BNX2_FLAG_USING_MSIX) {
5058 BNX2_WR(bp, BNX2_HC_MSIX_BIT_VECTOR,
5064 if (bp->flags & BNX2_FLAG_ONE_SHOT_MSI)
5067 BNX2_WR(bp, BNX2_HC_CONFIG, val);
5069 if (bp->rx_ticks < 25)
5070 bnx2_reg_wr_ind(bp, BNX2_FW_RX_LOW_LATENCY, 1);
5072 bnx2_reg_wr_ind(bp, BNX2_FW_RX_LOW_LATENCY, 0);
5074 for (i = 1; i < bp->irq_nvecs; i++) {
5078 BNX2_WR(bp, base,
5083 BNX2_WR(bp, base + BNX2_HC_TX_QUICK_CONS_TRIP_OFF,
5084 (bp->tx_quick_cons_trip_int << 16) |
5085 bp->tx_quick_cons_trip);
5087 BNX2_WR(bp, base + BNX2_HC_TX_TICKS_OFF,
5088 (bp->tx_ticks_int << 16) | bp->tx_ticks);
5090 BNX2_WR(bp, base + BNX2_HC_RX_QUICK_CONS_TRIP_OFF,
5091 (bp->rx_quick_cons_trip_int << 16) |
5092 bp->rx_quick_cons_trip);
5094 BNX2_WR(bp, base + BNX2_HC_RX_TICKS_OFF,
5095 (bp->rx_ticks_int << 16) | bp->rx_ticks);
5099 BNX2_WR(bp, BNX2_HC_COMMAND, BNX2_HC_COMMAND_CLR_STAT_NOW);
5101 BNX2_WR(bp, BNX2_HC_ATTN_BITS_ENABLE, STATUS_ATTN_EVENTS);
5104 bnx2_set_rx_mode(bp->dev);
5106 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
5107 val = BNX2_RD(bp, BNX2_MISC_NEW_CORE_CTL);
5109 BNX2_WR(bp, BNX2_MISC_NEW_CORE_CTL, val);
5111 rc = bnx2_fw_sync(bp, BNX2_DRV_MSG_DATA_WAIT2 | BNX2_DRV_MSG_CODE_RESET,
5114 BNX2_WR(bp, BNX2_MISC_ENABLE_SET_BITS, BNX2_MISC_ENABLE_DEFAULT);
5115 BNX2_RD(bp, BNX2_MISC_ENABLE_SET_BITS);
5119 bp->hc_cmd = BNX2_RD(bp, BNX2_HC_COMMAND);
5125 bnx2_clear_ring_states(struct bnx2 *bp)
5133 bnapi = &bp->bnx2_napi[i];
5148 bnx2_init_tx_context(struct bnx2 *bp, u32 cid, struct bnx2_tx_ring_info *txr)
5153 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
5165 bnx2_ctx_wr(bp, cid_addr, offset0, val);
5168 bnx2_ctx_wr(bp, cid_addr, offset1, val);
5171 bnx2_ctx_wr(bp, cid_addr, offset2, val);
5174 bnx2_ctx_wr(bp, cid_addr, offset3, val);
5178 bnx2_init_tx_ring(struct bnx2 *bp, int ring_num)
5185 bnapi = &bp->bnx2_napi[ring_num];
5193 bp->tx_wake_thresh = bp->tx_ring_size / 2;
5206 bnx2_init_tx_context(bp, cid, txr);
5234 bnx2_init_rx_ring(struct bnx2 *bp, int ring_num)
5239 struct bnx2_napi *bnapi = &bp->bnx2_napi[ring_num];
5250 bp->rx_buf_use_size, bp->rx_max_ring);
5252 bnx2_init_rx_context(bp, cid);
5254 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
5255 val = BNX2_RD(bp, BNX2_MQ_MAP_L2_5);
5256 BNX2_WR(bp, BNX2_MQ_MAP_L2_5, val | BNX2_MQ_MAP_L2_5_ARM);
5259 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, 0);
5260 if (bp->rx_pg_ring_size) {
5263 PAGE_SIZE, bp->rx_max_pg_ring);
5264 val = (bp->rx_buf_use_size << 16) | PAGE_SIZE;
5265 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_PG_BUF_SIZE, val);
5266 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_RBDC_KEY,
5270 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_HI, val);
5273 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_PG_BDHADDR_LO, val);
5275 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
5276 BNX2_WR(bp, BNX2_MQ_MAP_L2_3, BNX2_MQ_MAP_L2_3_DEFAULT);
5280 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_HI, val);
5283 bnx2_ctx_wr(bp, rx_cid_addr, BNX2_L2CTX_NX_BDHADDR_LO, val);
5286 for (i = 0; i < bp->rx_pg_ring_size; i++) {
5287 if (bnx2_alloc_rx_page(bp, rxr, ring_prod, GFP_KERNEL) < 0) {
5288 netdev_warn(bp->dev, "init'ed rx page ring %d with %d/%d pages only\n",
5289 ring_num, i, bp->rx_pg_ring_size);
5298 for (i = 0; i < bp->rx_ring_size; i++) {
5299 if (bnx2_alloc_rx_data(bp, rxr, ring_prod, GFP_KERNEL) < 0) {
5300 netdev_warn(bp->dev, "init'ed rx ring %d with %d/%d skbs only\n",
5301 ring_num, i, bp->rx_ring_size);
5313 BNX2_WR16(bp, rxr->rx_pg_bidx_addr, rxr->rx_pg_prod);
5314 BNX2_WR16(bp, rxr->rx_bidx_addr, prod);
5316 BNX2_WR(bp, rxr->rx_bseq_addr, rxr->rx_prod_bseq);
5320 bnx2_init_all_rings(struct bnx2 *bp)
5325 bnx2_clear_ring_states(bp);
5327 BNX2_WR(bp, BNX2_TSCH_TSS_CFG, 0);
5328 for (i = 0; i < bp->num_tx_rings; i++)
5329 bnx2_init_tx_ring(bp, i);
5331 if (bp->num_tx_rings > 1)
5332 BNX2_WR(bp, BNX2_TSCH_TSS_CFG, ((bp->num_tx_rings - 1) << 24) |
5335 BNX2_WR(bp, BNX2_RLUP_RSS_CONFIG, 0);
5336 bnx2_reg_wr_ind(bp, BNX2_RXP_SCRATCH_RSS_TBL_SZ, 0);
5338 for (i = 0; i < bp->num_rx_rings; i++)
5339 bnx2_init_rx_ring(bp, i);
5341 if (bp->num_rx_rings > 1) {
5347 tbl_32 |= (i % (bp->num_rx_rings - 1)) << shift;
5349 BNX2_WR(bp, BNX2_RLUP_RSS_DATA, tbl_32);
5350 BNX2_WR(bp, BNX2_RLUP_RSS_COMMAND, (i >> 3) |
5361 BNX2_WR(bp, BNX2_RLUP_RSS_CONFIG, val);
5386 bnx2_set_rx_ring_size(struct bnx2 *bp, u32 size)
5391 rx_size = bp->dev->mtu + ETH_HLEN + BNX2_RX_OFFSET + 8;
5396 bp->rx_copy_thresh = BNX2_RX_COPY_THRESH;
5397 bp->rx_pg_ring_size = 0;
5398 bp->rx_max_pg_ring = 0;
5399 bp->rx_max_pg_ring_idx = 0;
5400 if ((rx_space > PAGE_SIZE) && !(bp->flags & BNX2_FLAG_JUMBO_BROKEN)) {
5401 int pages = PAGE_ALIGN(bp->dev->mtu - 40) >> PAGE_SHIFT;
5407 bp->rx_pg_ring_size = jumbo_size;
5408 bp->rx_max_pg_ring = bnx2_find_max_ring(jumbo_size,
5410 bp->rx_max_pg_ring_idx =
5411 (bp->rx_max_pg_ring * BNX2_RX_DESC_CNT) - 1;
5413 bp->rx_copy_thresh = 0;
5416 bp->rx_buf_use_size = rx_size;
5418 bp->rx_buf_size = SKB_DATA_ALIGN(bp->rx_buf_use_size + BNX2_RX_ALIGN) +
5420 bp->rx_jumbo_thresh = rx_size - BNX2_RX_OFFSET;
5421 bp->rx_ring_size = size;
5422 bp->rx_max_ring = bnx2_find_max_ring(size, BNX2_MAX_RX_RINGS);
5423 bp->rx_max_ring_idx = (bp->rx_max_ring * BNX2_RX_DESC_CNT) - 1;
5427 bnx2_free_tx_skbs(struct bnx2 *bp)
5431 for (i = 0; i < bp->num_tx_rings; i++) {
5432 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
5449 dma_unmap_single(&bp->pdev->dev,
5460 dma_unmap_page(&bp->pdev->dev,
5467 netdev_tx_reset_queue(netdev_get_tx_queue(bp->dev, i));
5472 bnx2_free_rx_skbs(struct bnx2 *bp)
5476 for (i = 0; i < bp->num_rx_rings; i++) {
5477 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
5484 for (j = 0; j < bp->rx_max_ring_idx; j++) {
5491 dma_unmap_single(&bp->pdev->dev,
5493 bp->rx_buf_use_size,
5500 for (j = 0; j < bp->rx_max_pg_ring_idx; j++)
5501 bnx2_free_rx_page(bp, rxr, j);
5506 bnx2_free_skbs(struct bnx2 *bp)
5508 bnx2_free_tx_skbs(bp);
5509 bnx2_free_rx_skbs(bp);
5513 bnx2_reset_nic(struct bnx2 *bp, u32 reset_code)
5517 rc = bnx2_reset_chip(bp, reset_code);
5518 bnx2_free_skbs(bp);
5522 if ((rc = bnx2_init_chip(bp)) != 0)
5525 bnx2_init_all_rings(bp);
5530 bnx2_init_nic(struct bnx2 *bp, int reset_phy)
5534 if ((rc = bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET)) != 0)
5537 spin_lock_bh(&bp->phy_lock);
5538 bnx2_init_phy(bp, reset_phy);
5539 bnx2_set_link(bp);
5540 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5541 bnx2_remote_phy_event(bp);
5542 spin_unlock_bh(&bp->phy_lock);
5547 bnx2_shutdown_chip(struct bnx2 *bp)
5551 if (bp->flags & BNX2_FLAG_NO_WOL)
5553 else if (bp->wol)
5558 return bnx2_reset_chip(bp, reset_code);
5562 bnx2_test_registers(struct bnx2 *bp)
5683 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
5697 save_val = readl(bp->regview + offset);
5699 writel(0, bp->regview + offset);
5701 val = readl(bp->regview + offset);
5710 writel(0xffffffff, bp->regview + offset);
5712 val = readl(bp->regview + offset);
5721 writel(save_val, bp->regview + offset);
5725 writel(save_val, bp->regview + offset);
5733 bnx2_do_mem_test(struct bnx2 *bp, u32 start, u32 size)
5744 bnx2_reg_wr_ind(bp, start + offset, test_pattern[i]);
5746 if (bnx2_reg_rd_ind(bp, start + offset) !=
5756 bnx2_test_memory(struct bnx2 *bp)
5782 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
5788 if ((ret = bnx2_do_mem_test(bp, mem_tbl[i].offset,
5801 bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
5813 struct bnx2_napi *bnapi = &bp->bnx2_napi[0], *tx_napi;
5822 bp->loopback = MAC_LOOPBACK;
5823 bnx2_set_mac_loopback(bp);
5826 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
5829 bp->loopback = PHY_LOOPBACK;
5830 bnx2_set_phy_loopback(bp);
5835 pkt_size = min(bp->dev->mtu + ETH_HLEN, bp->rx_jumbo_thresh - 4);
5836 skb = netdev_alloc_skb(bp->dev, pkt_size);
5840 memcpy(packet, bp->dev->dev_addr, ETH_ALEN);
5845 map = dma_map_single(&bp->pdev->dev, skb->data, pkt_size,
5847 if (dma_mapping_error(&bp->pdev->dev, map)) {
5852 BNX2_WR(bp, BNX2_HC_COMMAND,
5853 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5855 BNX2_RD(bp, BNX2_HC_COMMAND);
5873 BNX2_WR16(bp, txr->tx_bidx_addr, txr->tx_prod);
5874 BNX2_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
5878 BNX2_WR(bp, BNX2_HC_COMMAND,
5879 bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
5881 BNX2_RD(bp, BNX2_HC_COMMAND);
5885 dma_unmap_single(&bp->pdev->dev, map, pkt_size, PCI_DMA_TODEVICE);
5902 dma_sync_single_for_cpu(&bp->pdev->dev,
5904 bp->rx_buf_use_size, PCI_DMA_FROMDEVICE);
5929 bp->loopback = 0;
5939 bnx2_test_loopback(struct bnx2 *bp)
5943 if (!netif_running(bp->dev))
5946 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
5947 spin_lock_bh(&bp->phy_lock);
5948 bnx2_init_phy(bp, 1);
5949 spin_unlock_bh(&bp->phy_lock);
5950 if (bnx2_run_loopback(bp, BNX2_MAC_LOOPBACK))
5952 if (bnx2_run_loopback(bp, BNX2_PHY_LOOPBACK))
5961 bnx2_test_nvram(struct bnx2 *bp)
5968 if ((rc = bnx2_nvram_read(bp, 0, data, 4)) != 0)
5977 if ((rc = bnx2_nvram_read(bp, 0x100, data, NVRAM_SIZE)) != 0)
5996 bnx2_test_link(struct bnx2 *bp)
6000 if (!netif_running(bp->dev))
6003 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
6004 if (bp->link_up)
6008 spin_lock_bh(&bp->phy_lock);
6009 bnx2_enable_bmsr1(bp);
6010 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
6011 bnx2_read_phy(bp, bp->mii_bmsr1, &bmsr);
6012 bnx2_disable_bmsr1(bp);
6013 spin_unlock_bh(&bp->phy_lock);
6022 bnx2_test_intr(struct bnx2 *bp)
6027 if (!netif_running(bp->dev))
6030 status_idx = BNX2_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff;
6033 BNX2_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
6034 BNX2_RD(bp, BNX2_HC_COMMAND);
6037 if ((BNX2_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff) !=
6053 bnx2_5706_serdes_has_link(struct bnx2 *bp)
6057 if (bp->phy_flags & BNX2_PHY_FLAG_NO_PARALLEL)
6060 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_MODE_CTL);
6061 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &mode_ctl);
6066 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
6067 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
6068 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &an_dbg);
6073 bnx2_write_phy(bp, MII_BNX2_DSP_ADDRESS, MII_EXPAND_REG1);
6074 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
6075 bnx2_read_phy(bp, MII_BNX2_DSP_RW_PORT, &exp);
6084 bnx2_5706_serdes_timer(struct bnx2 *bp)
6088 spin_lock(&bp->phy_lock);
6089 if (bp->serdes_an_pending) {
6090 bp->serdes_an_pending--;
6092 } else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
6095 bp->current_interval = BNX2_TIMER_INTERVAL;
6097 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
6100 if (bnx2_5706_serdes_has_link(bp)) {
6103 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
6104 bp->phy_flags |= BNX2_PHY_FLAG_PARALLEL_DETECT;
6108 else if ((bp->link_up) && (bp->autoneg & AUTONEG_SPEED) &&
6109 (bp->phy_flags & BNX2_PHY_FLAG_PARALLEL_DETECT)) {
6112 bnx2_write_phy(bp, 0x17, 0x0f01);
6113 bnx2_read_phy(bp, 0x15, &phy2);
6117 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
6119 bnx2_write_phy(bp, bp->mii_bmcr, bmcr);
6121 bp->phy_flags &= ~BNX2_PHY_FLAG_PARALLEL_DETECT;
6124 bp->current_interval = BNX2_TIMER_INTERVAL;
6129 bnx2_write_phy(bp, MII_BNX2_MISC_SHADOW, MISC_SHDW_AN_DBG);
6130 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
6131 bnx2_read_phy(bp, MII_BNX2_MISC_SHADOW, &val);
6133 if (bp->link_up && (val & MISC_SHDW_AN_DBG_NOSYNC)) {
6134 if (!(bp->phy_flags & BNX2_PHY_FLAG_FORCED_DOWN)) {
6135 bnx2_5706s_force_link_dn(bp, 1);
6136 bp->phy_flags |= BNX2_PHY_FLAG_FORCED_DOWN;
6138 bnx2_set_link(bp);
6139 } else if (!bp->link_up && !(val & MISC_SHDW_AN_DBG_NOSYNC))
6140 bnx2_set_link(bp);
6142 spin_unlock(&bp->phy_lock);
6146 bnx2_5708_serdes_timer(struct bnx2 *bp)
6148 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
6151 if ((bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE) == 0) {
6152 bp->serdes_an_pending = 0;
6156 spin_lock(&bp->phy_lock);
6157 if (bp->serdes_an_pending)
6158 bp->serdes_an_pending--;
6159 else if ((bp->link_up == 0) && (bp->autoneg & AUTONEG_SPEED)) {
6162 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
6164 bnx2_enable_forced_2g5(bp);
6165 bp->current_interval = BNX2_SERDES_FORCED_TIMEOUT;
6167 bnx2_disable_forced_2g5(bp);
6168 bp->serdes_an_pending = 2;
6169 bp->current_interval = BNX2_TIMER_INTERVAL;
6173 bp->current_interval = BNX2_TIMER_INTERVAL;
6175 spin_unlock(&bp->phy_lock);
6181 struct bnx2 *bp = from_timer(bp, t, timer);
6183 if (!netif_running(bp->dev))
6186 if (atomic_read(&bp->intr_sem) != 0)
6189 if ((bp->flags & (BNX2_FLAG_USING_MSI | BNX2_FLAG_ONE_SHOT_MSI)) ==
6191 bnx2_chk_missed_msi(bp);
6193 bnx2_send_heart_beat(bp);
6195 bp->stats_blk->stat_FwRxDrop =
6196 bnx2_reg_rd_ind(bp, BNX2_FW_RX_DROP_COUNT);
6199 if ((bp->flags & BNX2_FLAG_BROKEN_STATS) && bp->stats_ticks)
6200 BNX2_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd |
6203 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
6204 if (BNX2_CHIP(bp) == BNX2_CHIP_5706)
6205 bnx2_5706_serdes_timer(bp);
6207 bnx2_5708_serdes_timer(bp);
6211 mod_timer(&bp->timer, jiffies + bp->current_interval);
6215 bnx2_request_irq(struct bnx2 *bp)
6221 if (bp->flags & BNX2_FLAG_USING_MSI_OR_MSIX)
6226 for (i = 0; i < bp->irq_nvecs; i++) {
6227 irq = &bp->irq_tbl[i];
6229 &bp->bnx2_napi[i]);
6238 __bnx2_free_irq(struct bnx2 *bp)
6243 for (i = 0; i < bp->irq_nvecs; i++) {
6244 irq = &bp->irq_tbl[i];
6246 free_irq(irq->vector, &bp->bnx2_napi[i]);
6252 bnx2_free_irq(struct bnx2 *bp)
6255 __bnx2_free_irq(bp);
6256 if (bp->flags & BNX2_FLAG_USING_MSI)
6257 pci_disable_msi(bp->pdev);
6258 else if (bp->flags & BNX2_FLAG_USING_MSIX)
6259 pci_disable_msix(bp->pdev);
6261 bp->flags &= ~(BNX2_FLAG_USING_MSI_OR_MSIX | BNX2_FLAG_ONE_SHOT_MSI);
6265 bnx2_enable_msix(struct bnx2 *bp, int msix_vecs)
6269 struct net_device *dev = bp->dev;
6270 const int len = sizeof(bp->irq_tbl[0].name);
6272 bnx2_setup_msix_tbl(bp);
6273 BNX2_WR(bp, BNX2_PCI_MSIX_CONTROL, BNX2_MAX_MSIX_HW_VEC - 1);
6274 BNX2_WR(bp, BNX2_PCI_MSIX_TBL_OFF_BIR, BNX2_PCI_GRC_WINDOW2_BASE);
6275 BNX2_WR(bp, BNX2_PCI_MSIX_PBA_OFF_BIT, BNX2_PCI_GRC_WINDOW3_BASE);
6279 BNX2_RD(bp, BNX2_PCI_MSIX_CONTROL);
6290 total_vecs = pci_enable_msix_range(bp->pdev, msix_ent,
6299 bp->irq_nvecs = msix_vecs;
6300 bp->flags |= BNX2_FLAG_USING_MSIX | BNX2_FLAG_ONE_SHOT_MSI;
6302 bp->irq_tbl[i].vector = msix_ent[i].vector;
6303 snprintf(bp->irq_tbl[i].name, len, "%s-%d", dev->name, i);
6304 bp->irq_tbl[i].handler = bnx2_msi_1shot;
6309 bnx2_setup_int_mode(struct bnx2 *bp, int dis_msi)
6314 if (!bp->num_req_rx_rings)
6315 msix_vecs = max(cpus + 1, bp->num_req_tx_rings);
6316 else if (!bp->num_req_tx_rings)
6317 msix_vecs = max(cpus, bp->num_req_rx_rings);
6319 msix_vecs = max(bp->num_req_rx_rings, bp->num_req_tx_rings);
6323 bp->irq_tbl[0].handler = bnx2_interrupt;
6324 strcpy(bp->irq_tbl[0].name, bp->dev->name);
6325 bp->irq_nvecs = 1;
6326 bp->irq_tbl[0].vector = bp->pdev->irq;
6328 if ((bp->flags & BNX2_FLAG_MSIX_CAP) && !dis_msi)
6329 bnx2_enable_msix(bp, msix_vecs);
6331 if ((bp->flags & BNX2_FLAG_MSI_CAP) && !dis_msi &&
6332 !(bp->flags & BNX2_FLAG_USING_MSIX)) {
6333 if (pci_enable_msi(bp->pdev) == 0) {
6334 bp->flags |= BNX2_FLAG_USING_MSI;
6335 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
6336 bp->flags |= BNX2_FLAG_ONE_SHOT_MSI;
6337 bp->irq_tbl[0].handler = bnx2_msi_1shot;
6339 bp->irq_tbl[0].handler = bnx2_msi;
6341 bp->irq_tbl[0].vector = bp->pdev->irq;
6345 if (!bp->num_req_tx_rings)
6346 bp->num_tx_rings = rounddown_pow_of_two(bp->irq_nvecs);
6348 bp->num_tx_rings = min(bp->irq_nvecs, bp->num_req_tx_rings);
6350 if (!bp->num_req_rx_rings)
6351 bp->num_rx_rings = bp->irq_nvecs;
6353 bp->num_rx_rings = min(bp->irq_nvecs, bp->num_req_rx_rings);
6355 netif_set_real_num_tx_queues(bp->dev, bp->num_tx_rings);
6357 return netif_set_real_num_rx_queues(bp->dev, bp->num_rx_rings);
6364 struct bnx2 *bp = netdev_priv(dev);
6367 rc = bnx2_request_firmware(bp);
6373 bnx2_disable_int(bp);
6375 rc = bnx2_setup_int_mode(bp, disable_msi);
6378 bnx2_init_napi(bp);
6379 bnx2_napi_enable(bp);
6380 rc = bnx2_alloc_mem(bp);
6384 rc = bnx2_request_irq(bp);
6388 rc = bnx2_init_nic(bp, 1);
6392 mod_timer(&bp->timer, jiffies + bp->current_interval);
6394 atomic_set(&bp->intr_sem, 0);
6396 memset(bp->temp_stats_blk, 0, sizeof(struct statistics_block));
6398 bnx2_enable_int(bp);
6400 if (bp->flags & BNX2_FLAG_USING_MSI) {
6404 if (bnx2_test_intr(bp) != 0) {
6405 netdev_warn(bp->dev, "No interrupt was generated using MSI, switching to INTx mode. Please report this failure to the PCI maintainer and include system chipset information.\n");
6407 bnx2_disable_int(bp);
6408 bnx2_free_irq(bp);
6410 bnx2_setup_int_mode(bp, 1);
6412 rc = bnx2_init_nic(bp, 0);
6415 rc = bnx2_request_irq(bp);
6418 del_timer_sync(&bp->timer);
6421 bnx2_enable_int(bp);
6424 if (bp->flags & BNX2_FLAG_USING_MSI)
6426 else if (bp->flags & BNX2_FLAG_USING_MSIX)
6434 bnx2_napi_disable(bp);
6435 bnx2_free_skbs(bp);
6436 bnx2_free_irq(bp);
6437 bnx2_free_mem(bp);
6438 bnx2_del_napi(bp);
6439 bnx2_release_firmware(bp);
6446 struct bnx2 *bp = container_of(work, struct bnx2, reset_task);
6451 if (!netif_running(bp->dev)) {
6456 bnx2_netif_stop(bp, true);
6458 pci_read_config_word(bp->pdev, PCI_COMMAND, &pcicmd);
6461 pci_restore_state(bp->pdev);
6462 pci_save_state(bp->pdev);
6464 rc = bnx2_init_nic(bp, 1);
6466 netdev_err(bp->dev, "failed to reset NIC, closing\n");
6467 bnx2_napi_enable(bp);
6468 dev_close(bp->dev);
6473 atomic_set(&bp->intr_sem, 1);
6474 bnx2_netif_start(bp, true);
6481 bnx2_dump_ftq(struct bnx2 *bp)
6485 struct net_device *dev = bp->dev;
6509 bnx2_reg_rd_ind(bp, ftq_arr[i].off));
6514 reg, bnx2_reg_rd_ind(bp, reg),
6515 bnx2_reg_rd_ind(bp, reg + 4),
6516 bnx2_reg_rd_ind(bp, reg + 8),
6517 bnx2_reg_rd_ind(bp, reg + 0x1c),
6518 bnx2_reg_rd_ind(bp, reg + 0x1c),
6519 bnx2_reg_rd_ind(bp, reg + 0x20));
6524 BNX2_RD(bp, BNX2_TBDC_STATUS) & BNX2_TBDC_STATUS_FREE_CNT);
6529 BNX2_WR(bp, BNX2_TBDC_BD_ADDR, i);
6530 BNX2_WR(bp, BNX2_TBDC_CAM_OPCODE,
6532 BNX2_WR(bp, BNX2_TBDC_COMMAND, BNX2_TBDC_COMMAND_CMD_REG_ARB);
6533 while ((BNX2_RD(bp, BNX2_TBDC_COMMAND) &
6537 cid = BNX2_RD(bp, BNX2_TBDC_CID);
6538 bdidx = BNX2_RD(bp, BNX2_TBDC_BIDX);
6539 valid = BNX2_RD(bp, BNX2_TBDC_CAM_OPCODE);
6548 bnx2_dump_state(struct bnx2 *bp)
6550 struct net_device *dev = bp->dev;
6553 pci_read_config_dword(bp->pdev, PCI_COMMAND, &val1);
6555 atomic_read(&bp->intr_sem), val1);
6556 pci_read_config_dword(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &val1);
6557 pci_read_config_dword(bp->pdev, BNX2_PCICFG_MISC_CONFIG, &val2);
6560 BNX2_RD(bp, BNX2_EMAC_TX_STATUS),
6561 BNX2_RD(bp, BNX2_EMAC_RX_STATUS));
6563 BNX2_RD(bp, BNX2_RPM_MGMT_PKT_CTRL));
6565 BNX2_RD(bp, BNX2_HC_STATS_INTERRUPT_STATUS));
6566 if (bp->flags & BNX2_FLAG_USING_MSIX)
6568 BNX2_RD(bp, BNX2_PCI_GRC_WINDOW3_BASE));
6574 struct bnx2 *bp = netdev_priv(dev);
6576 bnx2_dump_ftq(bp);
6577 bnx2_dump_state(bp);
6578 bnx2_dump_mcp_state(bp);
6581 schedule_work(&bp->reset_task);
6591 struct bnx2 *bp = netdev_priv(dev);
6604 bnapi = &bp->bnx2_napi[i];
6608 if (unlikely(bnx2_tx_avail(bp, txr) <
6663 mapping = dma_map_single(&bp->pdev->dev, skb->data, len, PCI_DMA_TODEVICE);
6664 if (dma_mapping_error(&bp->pdev->dev, mapping)) {
6692 mapping = skb_frag_dma_map(&bp->pdev->dev, frag, 0, len,
6694 if (dma_mapping_error(&bp->pdev->dev, mapping))
6715 BNX2_WR16(bp, txr->tx_bidx_addr, prod);
6716 BNX2_WR(bp, txr->tx_bseq_addr, txr->tx_prod_bseq);
6720 if (unlikely(bnx2_tx_avail(bp, txr) <= MAX_SKB_FRAGS)) {
6729 if (bnx2_tx_avail(bp, txr) > bp->tx_wake_thresh)
6743 dma_unmap_single(&bp->pdev->dev, dma_unmap_addr(tx_buf, mapping),
6751 dma_unmap_page(&bp->pdev->dev, dma_unmap_addr(tx_buf, mapping),
6764 struct bnx2 *bp = netdev_priv(dev);
6766 bnx2_disable_int_sync(bp);
6767 bnx2_napi_disable(bp);
6769 del_timer_sync(&bp->timer);
6770 bnx2_shutdown_chip(bp);
6771 bnx2_free_irq(bp);
6772 bnx2_free_skbs(bp);
6773 bnx2_free_mem(bp);
6774 bnx2_del_napi(bp);
6775 bp->link_up = 0;
6776 netif_carrier_off(bp->dev);
6781 bnx2_save_stats(struct bnx2 *bp)
6783 u32 *hw_stats = (u32 *) bp->stats_blk;
6784 u32 *temp_stats = (u32 *) bp->temp_stats_blk;
6808 GET_64BIT_NET_STATS64(bp->stats_blk->ctr) + \
6809 GET_64BIT_NET_STATS64(bp->temp_stats_blk->ctr)
6812 (unsigned long) (bp->stats_blk->ctr + \
6813 bp->temp_stats_blk->ctr)
6818 struct bnx2 *bp = netdev_priv(dev);
6820 if (!bp->stats_blk)
6867 if ((BNX2_CHIP(bp) == BNX2_CHIP_5706) ||
6868 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_A0))
6893 struct bnx2 *bp = netdev_priv(dev);
6898 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
6901 } else if (bp->phy_port == PORT_FIBRE)
6909 if (bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE)
6921 spin_lock_bh(&bp->phy_lock);
6922 cmd->base.port = bp->phy_port;
6923 advertising = bp->advertising;
6925 if (bp->autoneg & AUTONEG_SPEED) {
6932 cmd->base.speed = bp->line_speed;
6933 cmd->base.duplex = bp->duplex;
6934 if (!(bp->phy_flags & BNX2_PHY_FLAG_SERDES)) {
6935 if (bp->phy_flags & BNX2_PHY_FLAG_MDIX)
6945 spin_unlock_bh(&bp->phy_lock);
6947 cmd->base.phy_address = bp->phy_addr;
6961 struct bnx2 *bp = netdev_priv(dev);
6962 u8 autoneg = bp->autoneg;
6963 u8 req_duplex = bp->req_duplex;
6964 u16 req_line_speed = bp->req_line_speed;
6965 u32 advertising = bp->advertising;
6968 spin_lock_bh(&bp->phy_lock);
6973 if (cmd->base.port != bp->phy_port &&
6974 !(bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP))
6980 if (!netif_running(dev) && cmd->base.port != bp->phy_port)
7010 !(bp->phy_flags & BNX2_PHY_FLAG_2_5G_CAPABLE))
7021 bp->autoneg = autoneg;
7022 bp->advertising = advertising;
7023 bp->req_line_speed = req_line_speed;
7024 bp->req_duplex = req_duplex;
7031 err = bnx2_setup_phy(bp, cmd->base.port);
7034 spin_unlock_bh(&bp->phy_lock);
7042 struct bnx2 *bp = netdev_priv(dev);
7045 strlcpy(info->bus_info, pci_name(bp->pdev), sizeof(info->bus_info));
7046 strlcpy(info->fw_version, bp->fw_version, sizeof(info->fw_version));
7062 struct bnx2 *bp = netdev_priv(dev);
7092 if (!netif_running(bp->dev))
7099 *p++ = BNX2_RD(bp, offset);
7112 struct bnx2 *bp = netdev_priv(dev);
7114 if (bp->flags & BNX2_FLAG_NO_WOL) {
7120 if (bp->wol)
7131 struct bnx2 *bp = netdev_priv(dev);
7137 if (bp->flags & BNX2_FLAG_NO_WOL)
7140 bp->wol = 1;
7143 bp->wol = 0;
7146 device_set_wakeup_enable(&bp->pdev->dev, bp->wol);
7154 struct bnx2 *bp = netdev_priv(dev);
7160 if (!(bp->autoneg & AUTONEG_SPEED)) {
7164 spin_lock_bh(&bp->phy_lock);
7166 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) {
7169 rc = bnx2_setup_remote_phy(bp, bp->phy_port);
7170 spin_unlock_bh(&bp->phy_lock);
7175 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
7176 bnx2_write_phy(bp, bp->mii_bmcr, BMCR_LOOPBACK);
7177 spin_unlock_bh(&bp->phy_lock);
7181 spin_lock_bh(&bp->phy_lock);
7183 bp->current_interval = BNX2_SERDES_AN_TIMEOUT;
7184 bp->serdes_an_pending = 1;
7185 mod_timer(&bp->timer, jiffies + bp->current_interval);
7188 bnx2_read_phy(bp, bp->mii_bmcr, &bmcr);
7190 bnx2_write_phy(bp, bp->mii_bmcr, bmcr | BMCR_ANRESTART | BMCR_ANENABLE);
7192 spin_unlock_bh(&bp->phy_lock);
7200 struct bnx2 *bp = netdev_priv(dev);
7202 return bp->link_up;
7208 struct bnx2 *bp = netdev_priv(dev);
7210 if (!bp->flash_info)
7213 return (int) bp->flash_size;
7220 struct bnx2 *bp = netdev_priv(dev);
7225 rc = bnx2_nvram_read(bp, eeprom->offset, eebuf, eeprom->len);
7234 struct bnx2 *bp = netdev_priv(dev);
7239 rc = bnx2_nvram_write(bp, eeprom->offset, eebuf, eeprom->len);
7247 struct bnx2 *bp = netdev_priv(dev);
7251 coal->rx_coalesce_usecs = bp->rx_ticks;
7252 coal->rx_max_coalesced_frames = bp->rx_quick_cons_trip;
7253 coal->rx_coalesce_usecs_irq = bp->rx_ticks_int;
7254 coal->rx_max_coalesced_frames_irq = bp->rx_quick_cons_trip_int;
7256 coal->tx_coalesce_usecs = bp->tx_ticks;
7257 coal->tx_max_coalesced_frames = bp->tx_quick_cons_trip;
7258 coal->tx_coalesce_usecs_irq = bp->tx_ticks_int;
7259 coal->tx_max_coalesced_frames_irq = bp->tx_quick_cons_trip_int;
7261 coal->stats_block_coalesce_usecs = bp->stats_ticks;
7269 struct bnx2 *bp = netdev_priv(dev);
7271 bp->rx_ticks = (u16) coal->rx_coalesce_usecs;
7272 if (bp->rx_ticks > 0x3ff) bp->rx_ticks = 0x3ff;
7274 bp->rx_quick_cons_trip = (u16) coal->rx_max_coalesced_frames;
7275 if (bp->rx_quick_cons_trip > 0xff) bp->rx_quick_cons_trip = 0xff;
7277 bp->rx_ticks_int = (u16) coal->rx_coalesce_usecs_irq;
7278 if (bp->rx_ticks_int > 0x3ff) bp->rx_ticks_int = 0x3ff;
7280 bp->rx_quick_cons_trip_int = (u16) coal->rx_max_coalesced_frames_irq;
7281 if (bp->rx_quick_cons_trip_int > 0xff)
7282 bp->rx_quick_cons_trip_int = 0xff;
7284 bp->tx_ticks = (u16) coal->tx_coalesce_usecs;
7285 if (bp->tx_ticks > 0x3ff) bp->tx_ticks = 0x3ff;
7287 bp->tx_quick_cons_trip = (u16) coal->tx_max_coalesced_frames;
7288 if (bp->tx_quick_cons_trip > 0xff) bp->tx_quick_cons_trip = 0xff;
7290 bp->tx_ticks_int = (u16) coal->tx_coalesce_usecs_irq;
7291 if (bp->tx_ticks_int > 0x3ff) bp->tx_ticks_int = 0x3ff;
7293 bp->tx_quick_cons_trip_int = (u16) coal->tx_max_coalesced_frames_irq;
7294 if (bp->tx_quick_cons_trip_int > 0xff) bp->tx_quick_cons_trip_int =
7297 bp->stats_ticks = coal->stats_block_coalesce_usecs;
7298 if (bp->flags & BNX2_FLAG_BROKEN_STATS) {
7299 if (bp->stats_ticks != 0 && bp->stats_ticks != USEC_PER_SEC)
7300 bp->stats_ticks = USEC_PER_SEC;
7302 if (bp->stats_ticks > BNX2_HC_STATS_TICKS_HC_STAT_TICKS)
7303 bp->stats_ticks = BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
7304 bp->stats_ticks &= BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
7306 if (netif_running(bp->dev)) {
7307 bnx2_netif_stop(bp, true);
7308 bnx2_init_nic(bp, 0);
7309 bnx2_netif_start(bp, true);
7318 struct bnx2 *bp = netdev_priv(dev);
7323 ering->rx_pending = bp->rx_ring_size;
7324 ering->rx_jumbo_pending = bp->rx_pg_ring_size;
7327 ering->tx_pending = bp->tx_ring_size;
7331 bnx2_change_ring_size(struct bnx2 *bp, u32 rx, u32 tx, bool reset_irq)
7333 if (netif_running(bp->dev)) {
7335 bnx2_save_stats(bp);
7337 bnx2_netif_stop(bp, true);
7338 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_RESET);
7340 bnx2_free_irq(bp);
7341 bnx2_del_napi(bp);
7343 __bnx2_free_irq(bp);
7345 bnx2_free_skbs(bp);
7346 bnx2_free_mem(bp);
7349 bnx2_set_rx_ring_size(bp, rx);
7350 bp->tx_ring_size = tx;
7352 if (netif_running(bp->dev)) {
7356 rc = bnx2_setup_int_mode(bp, disable_msi);
7357 bnx2_init_napi(bp);
7361 rc = bnx2_alloc_mem(bp);
7364 rc = bnx2_request_irq(bp);
7367 rc = bnx2_init_nic(bp, 0);
7370 bnx2_napi_enable(bp);
7371 dev_close(bp->dev);
7375 mutex_lock(&bp->cnic_lock);
7377 if (bp->cnic_eth_dev.drv_state & CNIC_DRV_STATE_REGD)
7378 bnx2_setup_cnic_irq_info(bp);
7379 mutex_unlock(&bp->cnic_lock);
7381 bnx2_netif_start(bp, true);
7389 struct bnx2 *bp = netdev_priv(dev);
7398 rc = bnx2_change_ring_size(bp, ering->rx_pending, ering->tx_pending,
7406 struct bnx2 *bp = netdev_priv(dev);
7408 epause->autoneg = ((bp->autoneg & AUTONEG_FLOW_CTRL) != 0);
7409 epause->rx_pause = ((bp->flow_ctrl & FLOW_CTRL_RX) != 0);
7410 epause->tx_pause = ((bp->flow_ctrl & FLOW_CTRL_TX) != 0);
7416 struct bnx2 *bp = netdev_priv(dev);
7418 bp->req_flow_ctrl = 0;
7420 bp->req_flow_ctrl |= FLOW_CTRL_RX;
7422 bp->req_flow_ctrl |= FLOW_CTRL_TX;
7425 bp->autoneg |= AUTONEG_FLOW_CTRL;
7428 bp->autoneg &= ~AUTONEG_FLOW_CTRL;
7432 spin_lock_bh(&bp->phy_lock);
7433 bnx2_setup_phy(bp, bp->phy_port);
7434 spin_unlock_bh(&bp->phy_lock);
7594 struct bnx2 *bp = netdev_priv(dev);
7600 bnx2_netif_stop(bp, true);
7601 bnx2_reset_chip(bp, BNX2_DRV_MSG_CODE_DIAG);
7602 bnx2_free_skbs(bp);
7604 if (bnx2_test_registers(bp) != 0) {
7608 if (bnx2_test_memory(bp) != 0) {
7612 if ((buf[2] = bnx2_test_loopback(bp)) != 0)
7615 if (!netif_running(bp->dev))
7616 bnx2_shutdown_chip(bp);
7618 bnx2_init_nic(bp, 1);
7619 bnx2_netif_start(bp, true);
7624 if (bp->link_up)
7630 if (bnx2_test_nvram(bp) != 0) {
7634 if (bnx2_test_intr(bp) != 0) {
7639 if (bnx2_test_link(bp) != 0) {
7665 struct bnx2 *bp = netdev_priv(dev);
7667 u32 *hw_stats = (u32 *) bp->stats_blk;
7668 u32 *temp_stats = (u32 *) bp->temp_stats_blk;
7676 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) ||
7677 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A1) ||
7678 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A2) ||
7679 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_A0))
7711 struct bnx2 *bp = netdev_priv(dev);
7715 bp->leds_save = BNX2_RD(bp, BNX2_MISC_CFG);
7716 BNX2_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
7720 BNX2_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
7729 BNX2_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
7733 BNX2_WR(bp, BNX2_EMAC_LED, 0);
7734 BNX2_WR(bp, BNX2_MISC_CFG, bp->leds_save);
7744 struct bnx2 *bp = netdev_priv(dev);
7753 !!(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) &&
7755 bnx2_netif_stop(bp, false);
7758 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
7759 bnx2_netif_start(bp, false);
7769 struct bnx2 *bp = netdev_priv(dev);
7773 if ((bp->flags & BNX2_FLAG_MSIX_CAP) && !disable_msi) {
7782 channels->rx_count = bp->num_rx_rings;
7783 channels->tx_count = bp->num_tx_rings;
7791 struct bnx2 *bp = netdev_priv(dev);
7796 if ((bp->flags & BNX2_FLAG_MSIX_CAP) && !disable_msi) {
7804 bp->num_req_rx_rings = channels->rx_count;
7805 bp->num_req_tx_rings = channels->tx_count;
7808 rc = bnx2_change_ring_size(bp, bp->rx_ring_size,
7809 bp->tx_ring_size, true);
7852 struct bnx2 *bp = netdev_priv(dev);
7857 data->phy_id = bp->phy_addr;
7863 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7869 spin_lock_bh(&bp->phy_lock);
7870 err = bnx2_read_phy(bp, data->reg_num & 0x1f, &mii_regval);
7871 spin_unlock_bh(&bp->phy_lock);
7879 if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP)
7885 spin_lock_bh(&bp->phy_lock);
7886 err = bnx2_write_phy(bp, data->reg_num & 0x1f, data->val_in);
7887 spin_unlock_bh(&bp->phy_lock);
7903 struct bnx2 *bp = netdev_priv(dev);
7910 bnx2_set_mac_addr(bp, bp->dev->dev_addr, 0);
7919 struct bnx2 *bp = netdev_priv(dev);
7922 return bnx2_change_ring_size(bp, bp->rx_ring_size, bp->tx_ring_size,
7930 struct bnx2 *bp = netdev_priv(dev);
7933 for (i = 0; i < bp->irq_nvecs; i++) {
7934 struct bnx2_irq *irq = &bp->irq_tbl[i];
7937 irq->handler(irq->vector, &bp->bnx2_napi[i]);
7944 bnx2_get_5709_media(struct bnx2 *bp)
7946 u32 val = BNX2_RD(bp, BNX2_MISC_DUAL_MEDIA_CTRL);
7953 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7962 if (bp->func == 0) {
7967 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7975 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
7982 bnx2_get_pci_speed(struct bnx2 *bp)
7986 reg = BNX2_RD(bp, BNX2_PCICFG_MISC_STATUS);
7990 bp->flags |= BNX2_FLAG_PCIX;
7992 clkreg = BNX2_RD(bp, BNX2_PCICFG_PCI_CLOCK_CONTROL_BITS);
7997 bp->bus_speed_mhz = 133;
8001 bp->bus_speed_mhz = 100;
8006 bp->bus_speed_mhz = 66;
8011 bp->bus_speed_mhz = 50;
8017 bp->bus_speed_mhz = 33;
8023 bp->bus_speed_mhz = 66;
8025 bp->bus_speed_mhz = 33;
8029 bp->flags |= BNX2_FLAG_PCI_32BIT;
8034 bnx2_read_vpd_fw_ver(struct bnx2 *bp)
8048 rc = bnx2_nvram_read(bp, BNX2_VPD_NVRAM_OFFSET, data + BNX2_VPD_LEN,
8094 memcpy(bp->fw_version, &data[j], len);
8095 bp->fw_version[len] = ' ';
8104 struct bnx2 *bp;
8111 bp = netdev_priv(dev);
8113 bp->flags = 0;
8114 bp->phy_flags = 0;
8116 bp->temp_stats_blk =
8119 if (!bp->temp_stats_blk) {
8146 bp->pm_cap = pdev->pm_cap;
8147 if (bp->pm_cap == 0) {
8154 bp->dev = dev;
8155 bp->pdev = pdev;
8157 spin_lock_init(&bp->phy_lock);
8158 spin_lock_init(&bp->indirect_lock);
8160 mutex_init(&bp->cnic_lock);
8162 INIT_WORK(&bp->reset_task, bnx2_reset_task);
8164 bp->regview = pci_iomap(pdev, 0, MB_GET_CID_ADDR(TX_TSS_CID +
8166 if (!bp->regview) {
8176 BNX2_WR(bp, BNX2_PCICFG_MISC_CONFIG,
8180 bp->chip_id = BNX2_RD(bp, BNX2_MISC_ID);
8182 if (BNX2_CHIP(bp) == BNX2_CHIP_5709) {
8188 bp->flags |= BNX2_FLAG_PCIE;
8189 if (BNX2_CHIP_REV(bp) == BNX2_CHIP_REV_Ax)
8190 bp->flags |= BNX2_FLAG_JUMBO_BROKEN;
8195 bp->flags |= BNX2_FLAG_AER_ENABLED;
8198 bp->pcix_cap = pci_find_capability(pdev, PCI_CAP_ID_PCIX);
8199 if (bp->pcix_cap == 0) {
8205 bp->flags |= BNX2_FLAG_BROKEN_STATS;
8208 if (BNX2_CHIP(bp) == BNX2_CHIP_5709 &&
8209 BNX2_CHIP_REV(bp) != BNX2_CHIP_REV_Ax) {
8211 bp->flags |= BNX2_FLAG_MSIX_CAP;
8214 if (BNX2_CHIP_ID(bp) != BNX2_CHIP_ID_5706_A0 &&
8215 BNX2_CHIP_ID(bp) != BNX2_CHIP_ID_5706_A1) {
8217 bp->flags |= BNX2_FLAG_MSI_CAP;
8221 if (BNX2_CHIP(bp) == BNX2_CHIP_5708)
8240 if (!(bp->flags & BNX2_FLAG_PCIE))
8241 bnx2_get_pci_speed(bp);
8244 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) {
8245 reg = BNX2_RD(bp, PCI_COMMAND);
8247 BNX2_WR(bp, PCI_COMMAND, reg);
8248 } else if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A1) &&
8249 !(bp->flags & BNX2_FLAG_PCIX)) {
8256 bnx2_init_nvram(bp);
8258 reg = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_SIGNATURE);
8260 if (bnx2_reg_rd_ind(bp, BNX2_MCP_TOE_ID) & BNX2_MCP_TOE_ID_FUNCTION_ID)
8261 bp->func = 1;
8265 u32 off = bp->func << 2;
8267 bp->shmem_base = bnx2_reg_rd_ind(bp, BNX2_SHM_HDR_ADDR_0 + off);
8269 bp->shmem_base = HOST_VIEW_SHMEM_BASE;
8274 reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_SIGNATURE);
8283 bnx2_read_vpd_fw_ver(bp);
8285 j = strlen(bp->fw_version);
8286 reg = bnx2_shmem_rd(bp, BNX2_DEV_INFO_BC_REV);
8291 bp->fw_version[j++] = 'b';
8292 bp->fw_version[j++] = 'c';
8293 bp->fw_version[j++] = ' ';
8298 bp->fw_version[j++] = (num / k) + '0';
8303 bp->fw_version[j++] = '.';
8305 reg = bnx2_shmem_rd(bp, BNX2_PORT_FEATURE);
8307 bp->wol = 1;
8310 bp->flags |= BNX2_FLAG_ASF_ENABLE;
8313 reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
8319 reg = bnx2_shmem_rd(bp, BNX2_BC_STATE_CONDITION);
8323 u32 addr = bnx2_shmem_rd(bp, BNX2_MFW_VER_PTR);
8326 bp->fw_version[j++] = ' ';
8328 reg = bnx2_reg_rd_ind(bp, addr + i * 4);
8330 memcpy(&bp->fw_version[j], ®, 4);
8335 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_UPPER);
8336 bp->mac_addr[0] = (u8) (reg >> 8);
8337 bp->mac_addr[1] = (u8) reg;
8339 reg = bnx2_shmem_rd(bp, BNX2_PORT_HW_CFG_MAC_LOWER);
8340 bp->mac_addr[2] = (u8) (reg >> 24);
8341 bp->mac_addr[3] = (u8) (reg >> 16);
8342 bp->mac_addr[4] = (u8) (reg >> 8);
8343 bp->mac_addr[5] = (u8) reg;
8345 bp->tx_ring_size = BNX2_MAX_TX_DESC_CNT;
8346 bnx2_set_rx_ring_size(bp, 255);
8348 bp->tx_quick_cons_trip_int = 2;
8349 bp->tx_quick_cons_trip = 20;
8350 bp->tx_ticks_int = 18;
8351 bp->tx_ticks = 80;
8353 bp->rx_quick_cons_trip_int = 2;
8354 bp->rx_quick_cons_trip = 12;
8355 bp->rx_ticks_int = 18;
8356 bp->rx_ticks = 18;
8358 bp->stats_ticks = USEC_PER_SEC & BNX2_HC_STATS_TICKS_HC_STAT_TICKS;
8360 bp->current_interval = BNX2_TIMER_INTERVAL;
8362 bp->phy_addr = 1;
8370 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
8371 bnx2_get_5709_media(bp);
8372 else if (BNX2_CHIP_BOND(bp) & BNX2_CHIP_BOND_SERDES_BIT)
8373 bp->phy_flags |= BNX2_PHY_FLAG_SERDES;
8375 bp->phy_port = PORT_TP;
8376 if (bp->phy_flags & BNX2_PHY_FLAG_SERDES) {
8377 bp->phy_port = PORT_FIBRE;
8378 reg = bnx2_shmem_rd(bp, BNX2_SHARED_HW_CFG_CONFIG);
8380 bp->flags |= BNX2_FLAG_NO_WOL;
8381 bp->wol = 0;
8383 if (BNX2_CHIP(bp) == BNX2_CHIP_5706) {
8390 bp->phy_flags |= BNX2_PHY_FLAG_NO_PARALLEL;
8392 bp->phy_addr = 2;
8394 bp->phy_flags |= BNX2_PHY_FLAG_2_5G_CAPABLE;
8396 } else if (BNX2_CHIP(bp) == BNX2_CHIP_5706 ||
8397 BNX2_CHIP(bp) == BNX2_CHIP_5708)
8398 bp->phy_flags |= BNX2_PHY_FLAG_CRC_FIX;
8399 else if (BNX2_CHIP(bp) == BNX2_CHIP_5709 &&
8400 (BNX2_CHIP_REV(bp) == BNX2_CHIP_REV_Ax ||
8401 BNX2_CHIP_REV(bp) == BNX2_CHIP_REV_Bx))
8402 bp->phy_flags |= BNX2_PHY_FLAG_DIS_EARLY_DAC;
8404 bnx2_init_fw_cap(bp);
8406 if ((BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_A0) ||
8407 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_B0) ||
8408 (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5708_B1) ||
8409 !(BNX2_RD(bp, BNX2_PCI_CONFIG_3) & BNX2_PCI_CONFIG_3_VAUX_PRESET)) {
8410 bp->flags |= BNX2_FLAG_NO_WOL;
8411 bp->wol = 0;
8414 if (bp->flags & BNX2_FLAG_NO_WOL)
8415 device_set_wakeup_capable(&bp->pdev->dev, false);
8417 device_set_wakeup_enable(&bp->pdev->dev, bp->wol);
8419 if (BNX2_CHIP_ID(bp) == BNX2_CHIP_ID_5706_A0) {
8420 bp->tx_quick_cons_trip_int =
8421 bp->tx_quick_cons_trip;
8422 bp->tx_ticks_int = bp->tx_ticks;
8423 bp->rx_quick_cons_trip_int =
8424 bp->rx_quick_cons_trip;
8425 bp->rx_ticks_int = bp->rx_ticks;
8426 bp->comp_prod_trip_int = bp->comp_prod_trip;
8427 bp->com_ticks_int = bp->com_ticks;
8428 bp->cmd_ticks_int = bp->cmd_ticks;
8441 if (BNX2_CHIP(bp) == BNX2_CHIP_5706 && disable_msi == 0) {
8457 bnx2_set_default_link(bp);
8458 bp->req_flow_ctrl = FLOW_CTRL_RX | FLOW_CTRL_TX;
8460 timer_setup(&bp->timer, bnx2_timer, 0);
8461 bp->timer.expires = RUN_AT(BNX2_TIMER_INTERVAL);
8464 if (bnx2_shmem_rd(bp, BNX2_ISCSI_INITIATOR) & BNX2_ISCSI_INITIATOR_EN)
8465 bp->cnic_eth_dev.max_iscsi_conn =
8466 (bnx2_shmem_rd(bp, BNX2_ISCSI_MAX_CONN) &
8468 bp->cnic_probe = bnx2_cnic_probe;
8475 if (bp->flags & BNX2_FLAG_AER_ENABLED) {
8477 bp->flags &= ~BNX2_FLAG_AER_ENABLED;
8480 pci_iounmap(pdev, bp->regview);
8481 bp->regview = NULL;
8490 kfree(bp->temp_stats_blk);
8496 bnx2_bus_string(struct bnx2 *bp, char *str)
8500 if (bp->flags & BNX2_FLAG_PCIE) {
8504 if (bp->flags & BNX2_FLAG_PCIX)
8506 if (bp->flags & BNX2_FLAG_PCI_32BIT)
8510 s += sprintf(s, " %dMHz", bp->bus_speed_mhz);
8516 bnx2_del_napi(struct bnx2 *bp)
8520 for (i = 0; i < bp->irq_nvecs; i++)
8521 netif_napi_del(&bp->bnx2_napi[i].napi);
8525 bnx2_init_napi(struct bnx2 *bp)
8529 for (i = 0; i < bp->irq_nvecs; i++) {
8530 struct bnx2_napi *bnapi = &bp->bnx2_napi[i];
8538 netif_napi_add(bp->dev, &bp->bnx2_napi[i].napi, poll, 64);
8539 bnapi->bp = bp;
8564 struct bnx2 *bp;
8569 dev = alloc_etherdev_mq(sizeof(*bp), TX_MAX_RINGS);
8581 bp = netdev_priv(dev);
8592 bnx2_wait_dma_complete(bp);
8594 memcpy(dev->dev_addr, bp->mac_addr, ETH_ALEN);
8600 if (BNX2_CHIP(bp) == BNX2_CHIP_5709)
8610 if (!(bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
8620 ((BNX2_CHIP_ID(bp) & 0xf000) >> 12) + 'A',
8621 ((BNX2_CHIP_ID(bp) & 0x0ff0) >> 4),
8622 bnx2_bus_string(bp, str), (long)pci_resource_start(pdev, 0),
8628 pci_iounmap(pdev, bp->regview);
8641 struct bnx2 *bp = netdev_priv(dev);
8645 del_timer_sync(&bp->timer);
8646 cancel_work_sync(&bp->reset_task);
8648 pci_iounmap(bp->pdev, bp->regview);
8651 kfree(bp->temp_stats_blk);
8653 if (bp->flags & BNX2_FLAG_AER_ENABLED) {
8655 bp->flags &= ~BNX2_FLAG_AER_ENABLED;
8658 bnx2_release_firmware(bp);
8671 struct bnx2 *bp = netdev_priv(dev);
8674 cancel_work_sync(&bp->reset_task);
8675 bnx2_netif_stop(bp, true);
8677 del_timer_sync(&bp->timer);
8678 bnx2_shutdown_chip(bp);
8679 __bnx2_free_irq(bp);
8680 bnx2_free_skbs(bp);
8682 bnx2_setup_wol(bp);
8690 struct bnx2 *bp = netdev_priv(dev);
8695 bnx2_set_power_state(bp, PCI_D0);
8697 bnx2_request_irq(bp);
8698 bnx2_init_nic(bp, 1);
8699 bnx2_netif_start(bp, true);
8723 struct bnx2 *bp = netdev_priv(dev);
8734 bnx2_netif_stop(bp, true);
8735 del_timer_sync(&bp->timer);
8736 bnx2_reset_nic(bp, BNX2_DRV_MSG_CODE_RESET);
8755 struct bnx2 *bp = netdev_priv(dev);
8769 err = bnx2_init_nic(bp, 1);
8776 bnx2_napi_enable(bp);
8781 if (!(bp->flags & BNX2_FLAG_AER_ENABLED))
8797 struct bnx2 *bp = netdev_priv(dev);
8801 bnx2_netif_start(bp, true);
8810 struct bnx2 *bp;
8815 bp = netdev_priv(dev);
8816 if (!bp)
8821 dev_close(bp->dev);
8824 bnx2_set_power_state(bp, PCI_D3hot);