← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/net/atl1e/atl1e_main.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/atl1e/atl1e_main.c
35
35
 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
36
36
 *   Class, Class Mask, private data (not used) }
37
37
 */
38
 
static struct pci_device_id atl1e_pci_tbl[] = {
 
38
static DEFINE_PCI_DEVICE_TABLE(atl1e_pci_tbl) = {
39
39
        {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L1E)},
40
40
        {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, 0x1066)},
41
41
        /* required last entry */
164
164
{
165
165
        struct atl1e_hw *hw = &adapter->hw;
166
166
        struct net_device *netdev = adapter->netdev;
167
 
        struct pci_dev    *pdev   = adapter->pdev;
168
167
        int err = 0;
169
168
        u16 speed, duplex, phy_data;
170
169
 
171
 
        /* MII_BMSR must read twise */
 
170
        /* MII_BMSR must read twice */
172
171
        atl1e_read_phy_reg(hw, MII_BMSR, &phy_data);
173
172
        atl1e_read_phy_reg(hw, MII_BMSR, &phy_data);
174
173
        if ((phy_data & BMSR_LSTATUS) == 0) {
195
194
                        adapter->link_speed  = speed;
196
195
                        adapter->link_duplex = duplex;
197
196
                        atl1e_setup_mac_ctrl(adapter);
198
 
                        dev_info(&pdev->dev,
199
 
                                "%s: %s NIC Link is Up<%d Mbps %s>\n",
200
 
                                atl1e_driver_name, netdev->name,
201
 
                                adapter->link_speed,
202
 
                                adapter->link_duplex == FULL_DUPLEX ?
203
 
                                "Full Duplex" : "Half Duplex");
 
197
                        netdev_info(netdev,
 
198
                                    "NIC Link is Up <%d Mbps %s Duplex>\n",
 
199
                                    adapter->link_speed,
 
200
                                    adapter->link_duplex == FULL_DUPLEX ?
 
201
                                    "Full" : "Half");
204
202
                }
205
203
 
206
204
                if (!netif_carrier_ok(netdev)) {
230
228
static void atl1e_link_chg_event(struct atl1e_adapter *adapter)
231
229
{
232
230
        struct net_device *netdev = adapter->netdev;
233
 
        struct pci_dev    *pdev   = adapter->pdev;
234
231
        u16 phy_data = 0;
235
232
        u16 link_up = 0;
236
233
 
243
240
        if (!link_up) {
244
241
                if (netif_carrier_ok(netdev)) {
245
242
                        /* old link state: Up */
246
 
                        dev_info(&pdev->dev, "%s: %s NIC Link is Down\n",
247
 
                                        atl1e_driver_name, netdev->name);
 
243
                        netdev_info(netdev, "NIC Link is Down\n");
248
244
                        adapter->link_speed = SPEED_0;
249
245
                        netif_stop_queue(netdev);
250
246
                }
288
284
{
289
285
        struct atl1e_adapter *adapter = netdev_priv(netdev);
290
286
        struct atl1e_hw *hw = &adapter->hw;
291
 
        struct dev_mc_list *mc_ptr;
 
287
        struct netdev_hw_addr *ha;
292
288
        u32 mac_ctrl_data = 0;
293
289
        u32 hash_value;
294
290
 
311
307
        AT_WRITE_REG_ARRAY(hw, REG_RX_HASH_TABLE, 1, 0);
312
308
 
313
309
        /* comoute mc addresses' hash value ,and put it into hash table */
314
 
        for (mc_ptr = netdev->mc_list; mc_ptr; mc_ptr = mc_ptr->next) {
315
 
                hash_value = atl1e_hash_mc_addr(hw, mc_ptr->dmi_addr);
 
310
        netdev_for_each_mc_addr(ha, netdev) {
 
311
                hash_value = atl1e_hash_mc_addr(hw, ha->addr);
316
312
                atl1e_hash_set(hw, hash_value);
317
313
        }
318
314
}
321
317
                                   struct vlan_group *grp)
322
318
{
323
319
        struct atl1e_adapter *adapter = netdev_priv(netdev);
324
 
        struct pci_dev *pdev = adapter->pdev;
325
320
        u32 mac_ctrl_data = 0;
326
321
 
327
 
        dev_dbg(&pdev->dev, "atl1e_vlan_rx_register\n");
 
322
        netdev_dbg(adapter->netdev, "%s\n", __func__);
328
323
 
329
324
        atl1e_irq_disable(adapter);
330
325
 
345
340
 
346
341
static void atl1e_restore_vlan(struct atl1e_adapter *adapter)
347
342
{
348
 
        struct pci_dev *pdev = adapter->pdev;
349
 
 
350
 
        dev_dbg(&pdev->dev, "atl1e_restore_vlan !");
 
343
        netdev_dbg(adapter->netdev, "%s\n", __func__);
351
344
        atl1e_vlan_rx_register(adapter->netdev, adapter->vlgrp);
352
345
}
353
346
/*
391
384
 
392
385
        if ((max_frame < ETH_ZLEN + ETH_FCS_LEN) ||
393
386
                        (max_frame > MAX_JUMBO_FRAME_SIZE)) {
394
 
                dev_warn(&adapter->pdev->dev, "invalid MTU setting\n");
 
387
                netdev_warn(adapter->netdev, "invalid MTU setting\n");
395
388
                return -EINVAL;
396
389
        }
397
390
        /* set MTU */
438
431
                           struct ifreq *ifr, int cmd)
439
432
{
440
433
        struct atl1e_adapter *adapter = netdev_priv(netdev);
441
 
        struct pci_dev *pdev = adapter->pdev;
442
434
        struct mii_ioctl_data *data = if_mii(ifr);
443
435
        unsigned long flags;
444
436
        int retval = 0;
466
458
                        goto out;
467
459
                }
468
460
 
469
 
                dev_dbg(&pdev->dev, "<atl1e_mii_ioctl> write %x %x",
470
 
                                data->reg_num, data->val_in);
 
461
                netdev_dbg(adapter->netdev, "<atl1e_mii_ioctl> write %x %x\n",
 
462
                           data->reg_num, data->val_in);
471
463
                if (atl1e_write_phy_reg(&adapter->hw,
472
464
                                     data->reg_num, data->val_in)) {
473
465
                        retval = -EIO;
602
594
        hw->dmaw_dly_cnt = 4;
603
595
 
604
596
        if (atl1e_alloc_queues(adapter)) {
605
 
                dev_err(&pdev->dev, "Unable to allocate memory for queues\n");
 
597
                netdev_err(adapter->netdev, "Unable to allocate memory for queues\n");
606
598
                return -ENOMEM;
607
599
        }
608
600
 
715
707
        adapter->ring_vir_addr = NULL;
716
708
        adapter->rx_ring.desc = NULL;
717
709
        rwlock_init(&adapter->tx_ring.tx_lock);
718
 
 
719
 
        return;
720
710
}
721
711
 
722
712
/*
800
790
                        adapter->ring_size, &adapter->ring_dma);
801
791
 
802
792
        if (adapter->ring_vir_addr == NULL) {
803
 
                dev_err(&pdev->dev, "pci_alloc_consistent failed, "
804
 
                                    "size = D%d", size);
 
793
                netdev_err(adapter->netdev,
 
794
                           "pci_alloc_consistent failed, size = D%d\n", size);
805
795
                return -ENOMEM;
806
796
        }
807
797
 
817
807
        size = sizeof(struct atl1e_tx_buffer) * (tx_ring->count);
818
808
        tx_ring->tx_buffer = kzalloc(size, GFP_KERNEL);
819
809
        if (tx_ring->tx_buffer == NULL) {
820
 
                dev_err(&pdev->dev, "kzalloc failed , size = D%d", size);
 
810
                netdev_err(adapter->netdev, "kzalloc failed, size = D%d\n",
 
811
                           size);
821
812
                err = -ENOMEM;
822
813
                goto failed;
823
814
        }
852
843
        }
853
844
 
854
845
        if (unlikely(offset > adapter->ring_size)) {
855
 
                dev_err(&pdev->dev, "offset(%d) > ring size(%d) !!\n",
856
 
                                offset, adapter->ring_size);
 
846
                netdev_err(adapter->netdev, "offset(%d) > ring size(%d) !!\n",
 
847
                           offset, adapter->ring_size);
857
848
                err = -1;
858
849
                goto failed;
859
850
        }
912
903
        AT_WRITE_REG(hw, REG_HOST_RXFPAGE_SIZE, rx_ring->page_size);
913
904
        /* Load all of base address above */
914
905
        AT_WRITE_REG(hw, REG_LOAD_PTR, 1);
915
 
 
916
 
        return;
917
906
}
918
907
 
919
908
static inline void atl1e_configure_tx(struct atl1e_adapter *adapter)
957
946
                        (((u16)hw->tpd_burst & TXQ_CTRL_NUM_TPD_BURST_MASK)
958
947
                         << TXQ_CTRL_NUM_TPD_BURST_SHIFT)
959
948
                        | TXQ_CTRL_ENH_MODE | TXQ_CTRL_EN);
960
 
        return;
961
949
}
962
950
 
963
951
static inline void atl1e_configure_rx(struct atl1e_adapter *adapter)
1011
999
                         RXQ_CTRL_CUT_THRU_EN | RXQ_CTRL_EN;
1012
1000
 
1013
1001
        AT_WRITE_REG(hw, REG_RXQ_CTRL, rxq_ctrl_data);
1014
 
        return;
1015
1002
}
1016
1003
 
1017
1004
static inline void atl1e_configure_dma(struct atl1e_adapter *adapter)
1031
1018
                << DMA_CTRL_DMAW_DLY_CNT_SHIFT;
1032
1019
 
1033
1020
        AT_WRITE_REG(hw, REG_DMA_CTRL, dma_ctrl_data);
1034
 
        return;
1035
1021
}
1036
1022
 
1037
1023
static void atl1e_setup_mac_ctrl(struct atl1e_adapter *adapter)
1077
1063
static int atl1e_configure(struct atl1e_adapter *adapter)
1078
1064
{
1079
1065
        struct atl1e_hw *hw = &adapter->hw;
1080
 
        struct pci_dev *pdev = adapter->pdev;
1081
1066
 
1082
1067
        u32 intr_status_data = 0;
1083
1068
 
1130
1115
 
1131
1116
        intr_status_data = AT_READ_REG(hw, REG_ISR);
1132
1117
        if (unlikely((intr_status_data & ISR_PHY_LINKDOWN) != 0)) {
1133
 
                dev_err(&pdev->dev, "atl1e_configure failed,"
1134
 
                                "PCIE phy link down\n");
 
1118
                netdev_err(adapter->netdev,
 
1119
                           "atl1e_configure failed, PCIE phy link down\n");
1135
1120
                return -1;
1136
1121
        }
1137
1122
 
1262
1247
{
1263
1248
        struct net_device *netdev  = data;
1264
1249
        struct atl1e_adapter *adapter = netdev_priv(netdev);
1265
 
        struct pci_dev *pdev = adapter->pdev;
1266
1250
        struct atl1e_hw *hw = &adapter->hw;
1267
1251
        int max_ints = AT_MAX_INT_WORK;
1268
1252
        int handled = IRQ_NONE;
1285
1269
                handled = IRQ_HANDLED;
1286
1270
                /* check if PCIE PHY Link down */
1287
1271
                if (status & ISR_PHY_LINKDOWN) {
1288
 
                        dev_err(&pdev->dev,
1289
 
                                "pcie phy linkdown %x\n", status);
 
1272
                        netdev_err(adapter->netdev,
 
1273
                                   "pcie phy linkdown %x\n", status);
1290
1274
                        if (netif_running(adapter->netdev)) {
1291
1275
                                /* reset MAC */
1292
1276
                                atl1e_irq_reset(adapter);
1297
1281
 
1298
1282
                /* check if DMA read/write error */
1299
1283
                if (status & (ISR_DMAR_TO_RST | ISR_DMAW_TO_RST)) {
1300
 
                        dev_err(&pdev->dev,
1301
 
                                "PCIE DMA RW error (status = 0x%x)\n",
1302
 
                                status);
 
1284
                        netdev_err(adapter->netdev,
 
1285
                                   "PCIE DMA RW error (status = 0x%x)\n",
 
1286
                                   status);
1303
1287
                        atl1e_irq_reset(adapter);
1304
1288
                        schedule_work(&adapter->reset_task);
1305
1289
                        break;
1347
1331
        u16 pkt_flags;
1348
1332
        u16 err_flags;
1349
1333
 
1350
 
        skb->ip_summed = CHECKSUM_NONE;
 
1334
        skb_checksum_none_assert(skb);
1351
1335
        pkt_flags = prrs->pkt_flag;
1352
1336
        err_flags = prrs->err_flag;
1353
1337
        if (((pkt_flags & RRS_IS_IPV4) || (pkt_flags & RRS_IS_IPV6)) &&
1382
1366
static void atl1e_clean_rx_irq(struct atl1e_adapter *adapter, u8 que,
1383
1367
                   int *work_done, int work_to_do)
1384
1368
{
1385
 
        struct pci_dev *pdev = adapter->pdev;
1386
1369
        struct net_device *netdev  = adapter->netdev;
1387
1370
        struct atl1e_rx_ring *rx_ring = (struct atl1e_rx_ring *)
1388
1371
                                         &adapter->rx_ring;
1404
1387
                                                 rx_page->read_offset);
1405
1388
                        /* check sequence number */
1406
1389
                        if (prrs->seq_num != rx_page_desc[que].rx_nxseq) {
1407
 
                                dev_err(&pdev->dev,
1408
 
                                        "rx sequence number"
1409
 
                                        " error (rx=%d) (expect=%d)\n",
1410
 
                                        prrs->seq_num,
1411
 
                                        rx_page_desc[que].rx_nxseq);
 
1390
                                netdev_err(netdev,
 
1391
                                           "rx sequence number error (rx=%d) (expect=%d)\n",
 
1392
                                           prrs->seq_num,
 
1393
                                           rx_page_desc[que].rx_nxseq);
1412
1394
                                rx_page_desc[que].rx_nxseq++;
1413
1395
                                /* just for debug use */
1414
1396
                                AT_WRITE_REG(&adapter->hw, REG_DEBUG_DATA0,
1424
1406
                                        RRS_ERR_DRIBBLE | RRS_ERR_CODE |
1425
1407
                                        RRS_ERR_TRUNC)) {
1426
1408
                                /* hardware error, discard this packet*/
1427
 
                                        dev_err(&pdev->dev,
1428
 
                                                "rx packet desc error %x\n",
1429
 
                                                *((u32 *)prrs + 1));
 
1409
                                        netdev_err(netdev,
 
1410
                                                   "rx packet desc error %x\n",
 
1411
                                                   *((u32 *)prrs + 1));
1430
1412
                                        goto skip_pkt;
1431
1413
                                }
1432
1414
                        }
1433
1415
 
1434
1416
                        packet_size = ((prrs->word1 >> RRS_PKT_SIZE_SHIFT) &
1435
1417
                                        RRS_PKT_SIZE_MASK) - 4; /* CRC */
1436
 
                        skb = netdev_alloc_skb(netdev,
1437
 
                                               packet_size + NET_IP_ALIGN);
 
1418
                        skb = netdev_alloc_skb_ip_align(netdev, packet_size);
1438
1419
                        if (skb == NULL) {
1439
 
                                dev_warn(&pdev->dev, "%s: Memory squeeze,"
1440
 
                                        "deferring packet.\n", netdev->name);
 
1420
                                netdev_warn(netdev,
 
1421
                                            "Memory squeeze, deferring packet\n");
1441
1422
                                goto skip_pkt;
1442
1423
                        }
1443
 
                        skb_reserve(skb, NET_IP_ALIGN);
1444
 
                        skb->dev = netdev;
1445
1424
                        memcpy(skb->data, (u8 *)(prrs + 1), packet_size);
1446
1425
                        skb_put(skb, packet_size);
1447
1426
                        skb->protocol = eth_type_trans(skb, netdev);
1452
1431
                                u16 vlan_tag = (prrs->vtag >> 4) |
1453
1432
                                               ((prrs->vtag & 7) << 13) |
1454
1433
                                               ((prrs->vtag & 8) << 9);
1455
 
                                dev_dbg(&pdev->dev,
1456
 
                                        "RXD VLAN TAG<RRD>=0x%04x\n",
1457
 
                                        prrs->vtag);
 
1434
                                netdev_dbg(netdev,
 
1435
                                           "RXD VLAN TAG<RRD>=0x%04x\n",
 
1436
                                           prrs->vtag);
1458
1437
                                vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
1459
1438
                                                         vlan_tag);
1460
1439
                        } else {
1502
1481
{
1503
1482
        struct atl1e_adapter *adapter =
1504
1483
                        container_of(napi, struct atl1e_adapter, napi);
1505
 
        struct pci_dev    *pdev    = adapter->pdev;
1506
1484
        u32 imr_data;
1507
1485
        int work_done = 0;
1508
1486
 
1521
1499
                /* test debug */
1522
1500
                if (test_bit(__AT_DOWN, &adapter->flags)) {
1523
1501
                        atomic_dec(&adapter->irq_sem);
1524
 
                        dev_err(&pdev->dev,
1525
 
                                "atl1e_clean is called when AT_DOWN\n");
 
1502
                        netdev_err(adapter->netdev,
 
1503
                                   "atl1e_clean is called when AT_DOWN\n");
1526
1504
                }
1527
1505
                /* reenable RX intr */
1528
1506
                /*atl1e_irq_enable(adapter); */
1620
1598
static int atl1e_tso_csum(struct atl1e_adapter *adapter,
1621
1599
                       struct sk_buff *skb, struct atl1e_tpd_desc *tpd)
1622
1600
{
1623
 
        struct pci_dev *pdev = adapter->pdev;
1624
1601
        u8 hdr_len;
1625
1602
        u32 real_len;
1626
1603
        unsigned short offload_type;
1644
1621
                        hdr_len = (skb_transport_offset(skb) + tcp_hdrlen(skb));
1645
1622
                        if (unlikely(skb->len == hdr_len)) {
1646
1623
                                /* only xsum need */
1647
 
                                dev_warn(&pdev->dev,
1648
 
                                      "IPV4 tso with zero data??\n");
 
1624
                                netdev_warn(adapter->netdev,
 
1625
                                            "IPV4 tso with zero data??\n");
1649
1626
                                goto check_sum;
1650
1627
                        } else {
1651
1628
                                ip_hdr(skb)->check = 0;
1666
1643
                        }
1667
1644
                        return 0;
1668
1645
                }
1669
 
 
1670
 
                if (offload_type & SKB_GSO_TCPV6) {
1671
 
                        real_len = (((unsigned char *)ipv6_hdr(skb) - skb->data)
1672
 
                                        + ntohs(ipv6_hdr(skb)->payload_len));
1673
 
                        if (real_len < skb->len)
1674
 
                                pskb_trim(skb, real_len);
1675
 
 
1676
 
                        /* check payload == 0 byte ? */
1677
 
                        hdr_len = (skb_transport_offset(skb) + tcp_hdrlen(skb));
1678
 
                        if (unlikely(skb->len == hdr_len)) {
1679
 
                                /* only xsum need */
1680
 
                                dev_warn(&pdev->dev,
1681
 
                                        "IPV6 tso with zero data??\n");
1682
 
                                goto check_sum;
1683
 
                        } else {
1684
 
                                tcp_hdr(skb)->check = ~csum_ipv6_magic(
1685
 
                                                &ipv6_hdr(skb)->saddr,
1686
 
                                                &ipv6_hdr(skb)->daddr,
1687
 
                                                0, IPPROTO_TCP, 0);
1688
 
                                tpd->word3 |= 1 << TPD_IP_VERSION_SHIFT;
1689
 
                                hdr_len >>= 1;
1690
 
                                tpd->word3 |= (hdr_len & TPD_V6_IPHLLO_MASK) <<
1691
 
                                        TPD_V6_IPHLLO_SHIFT;
1692
 
                                tpd->word3 |= ((hdr_len >> 3) &
1693
 
                                        TPD_V6_IPHLHI_MASK) <<
1694
 
                                        TPD_V6_IPHLHI_SHIFT;
1695
 
                                tpd->word3 |= (tcp_hdrlen(skb) >> 2 &
1696
 
                                        TPD_TCPHDRLEN_MASK) <<
1697
 
                                        TPD_TCPHDRLEN_SHIFT;
1698
 
                                tpd->word3 |= ((skb_shinfo(skb)->gso_size) &
1699
 
                                        TPD_MSS_MASK) << TPD_MSS_SHIFT;
1700
 
                                        tpd->word3 |= 1 << TPD_SEGMENT_EN_SHIFT;
1701
 
                        }
1702
 
                }
1703
 
                return 0;
1704
1646
        }
1705
1647
 
1706
1648
check_sum:
1707
1649
        if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
1708
1650
                u8 css, cso;
1709
1651
 
1710
 
                cso = skb_transport_offset(skb);
 
1652
                cso = skb_checksum_start_offset(skb);
1711
1653
                if (unlikely(cso & 0x1)) {
1712
 
                        dev_err(&adapter->pdev->dev,
1713
 
                           "pay load offset should not ant event number\n");
 
1654
                        netdev_err(adapter->netdev,
 
1655
                                   "payload offset should not ant event number\n");
1714
1656
                        return -1;
1715
1657
                } else {
1716
1658
                        css = cso + skb->csum_offset;
1730
1672
{
1731
1673
        struct atl1e_tpd_desc *use_tpd = NULL;
1732
1674
        struct atl1e_tx_buffer *tx_buffer = NULL;
1733
 
        u16 buf_len = skb->len - skb->data_len;
 
1675
        u16 buf_len = skb_headlen(skb);
1734
1676
        u16 map_len = 0;
1735
1677
        u16 mapped_len = 0;
1736
1678
        u16 hdr_len = 0;
1872
1814
 
1873
1815
        tpd = atl1e_get_tpd(adapter);
1874
1816
 
1875
 
        if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) {
 
1817
        if (unlikely(vlan_tx_tag_present(skb))) {
1876
1818
                u16 vlan_tag = vlan_tx_tag_get(skb);
1877
1819
                u16 atl1e_vlan_tag;
1878
1820
 
1923
1865
        adapter->have_msi = true;
1924
1866
        err = pci_enable_msi(adapter->pdev);
1925
1867
        if (err) {
1926
 
                dev_dbg(&pdev->dev,
1927
 
                        "Unable to allocate MSI interrupt Error: %d\n", err);
 
1868
                netdev_dbg(adapter->netdev,
 
1869
                           "Unable to allocate MSI interrupt Error: %d\n", err);
1928
1870
                adapter->have_msi = false;
1929
1871
        } else
1930
1872
                netdev->irq = pdev->irq;
1932
1874
 
1933
1875
        if (!adapter->have_msi)
1934
1876
                flags |= IRQF_SHARED;
1935
 
        err = request_irq(adapter->pdev->irq, &atl1e_intr, flags,
 
1877
        err = request_irq(adapter->pdev->irq, atl1e_intr, flags,
1936
1878
                        netdev->name, netdev);
1937
1879
        if (err) {
1938
 
                dev_dbg(&pdev->dev,
1939
 
                        "Unable to allocate interrupt Error: %d\n", err);
 
1880
                netdev_dbg(adapter->netdev,
 
1881
                           "Unable to allocate interrupt Error: %d\n", err);
1940
1882
                if (adapter->have_msi)
1941
1883
                        pci_disable_msi(adapter->pdev);
1942
1884
                return err;
1943
1885
        }
1944
 
        dev_dbg(&pdev->dev, "atl1e_request_irq OK\n");
 
1886
        netdev_dbg(adapter->netdev, "atl1e_request_irq OK\n");
1945
1887
        return err;
1946
1888
}
1947
1889
 
2115
2057
                    (atl1e_write_phy_reg(hw,
2116
2058
                           MII_ADVERTISE, mii_advertise_data) != 0) ||
2117
2059
                    (atl1e_phy_commit(hw)) != 0) {
2118
 
                        dev_dbg(&pdev->dev, "set phy register failed\n");
 
2060
                        netdev_dbg(adapter->netdev, "set phy register failed\n");
2119
2061
                        goto wol_dis;
2120
2062
                }
2121
2063
 
2137
2079
                                }
2138
2080
 
2139
2081
                                if ((mii_bmsr_data & BMSR_LSTATUS) == 0)
2140
 
                                        dev_dbg(&pdev->dev,
2141
 
                                                "%s: Link may change"
2142
 
                                                "when suspend\n",
2143
 
                                                atl1e_driver_name);
 
2082
                                        netdev_dbg(adapter->netdev,
 
2083
                                                   "Link may change when suspend\n");
2144
2084
                        }
2145
2085
                        wol_ctrl_data |=  WOL_LINK_CHG_EN | WOL_LINK_CHG_PME_EN;
2146
2086
                        /* only link up can wake up */
2147
2087
                        if (atl1e_write_phy_reg(hw, MII_INT_CTRL, 0x400) != 0) {
2148
 
                                dev_dbg(&pdev->dev, "%s: read write phy "
2149
 
                                                  "register failed.\n",
2150
 
                                                  atl1e_driver_name);
 
2088
                                netdev_dbg(adapter->netdev,
 
2089
                                           "read write phy register failed\n");
2151
2090
                                goto wol_dis;
2152
2091
                        }
2153
2092
                }
2168
2107
                if (wufc & AT_WUFC_MAG)
2169
2108
                        mac_ctrl_data |= MAC_CTRL_BC_EN;
2170
2109
 
2171
 
                dev_dbg(&pdev->dev,
2172
 
                        "%s: suspend MAC=0x%x\n",
2173
 
                        atl1e_driver_name, mac_ctrl_data);
 
2110
                netdev_dbg(adapter->netdev, "suspend MAC=0x%x\n",
 
2111
                           mac_ctrl_data);
2174
2112
 
2175
2113
                AT_WRITE_REG(hw, REG_WOL_CTRL, wol_ctrl_data);
2176
2114
                AT_WRITE_REG(hw, REG_MAC_CTRL, mac_ctrl_data);
2220
2158
 
2221
2159
        err = pci_enable_device(pdev);
2222
2160
        if (err) {
2223
 
                dev_err(&pdev->dev, "ATL1e: Cannot enable PCI"
2224
 
                                " device from suspend\n");
 
2161
                netdev_err(adapter->netdev,
 
2162
                           "Cannot enable PCI device from suspend\n");
2225
2163
                return err;
2226
2164
        }
2227
2165
 
2289
2227
                NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
2290
2228
        netdev->features |= NETIF_F_LLTX;
2291
2229
        netdev->features |= NETIF_F_TSO;
2292
 
        netdev->features |= NETIF_F_TSO6;
2293
2230
 
2294
2231
        return 0;
2295
2232
}
2353
2290
 
2354
2291
        err = atl1e_init_netdev(netdev, pdev);
2355
2292
        if (err) {
2356
 
                dev_err(&pdev->dev, "init netdevice failed\n");
 
2293
                netdev_err(netdev, "init netdevice failed\n");
2357
2294
                goto err_init_netdev;
2358
2295
        }
2359
2296
        adapter = netdev_priv(netdev);
2364
2301
        adapter->hw.hw_addr = pci_iomap(pdev, BAR_0, 0);
2365
2302
        if (!adapter->hw.hw_addr) {
2366
2303
                err = -EIO;
2367
 
                dev_err(&pdev->dev, "cannot map device registers\n");
 
2304
                netdev_err(netdev, "cannot map device registers\n");
2368
2305
                goto err_ioremap;
2369
2306
        }
2370
2307
        netdev->base_addr = (unsigned long)adapter->hw.hw_addr;
2379
2316
        netif_napi_add(netdev, &adapter->napi, atl1e_clean, 64);
2380
2317
 
2381
2318
        init_timer(&adapter->phy_config_timer);
2382
 
        adapter->phy_config_timer.function = &atl1e_phy_config;
 
2319
        adapter->phy_config_timer.function = atl1e_phy_config;
2383
2320
        adapter->phy_config_timer.data = (unsigned long) adapter;
2384
2321
 
2385
2322
        /* get user settings */
2394
2331
        /* setup the private structure */
2395
2332
        err = atl1e_sw_init(adapter);
2396
2333
        if (err) {
2397
 
                dev_err(&pdev->dev, "net device private data init failed\n");
 
2334
                netdev_err(netdev, "net device private data init failed\n");
2398
2335
                goto err_sw_init;
2399
2336
        }
2400
2337
 
2410
2347
 
2411
2348
        if (atl1e_read_mac_addr(&adapter->hw) != 0) {
2412
2349
                err = -EIO;
2413
 
                dev_err(&pdev->dev, "get mac address failed\n");
 
2350
                netdev_err(netdev, "get mac address failed\n");
2414
2351
                goto err_eeprom;
2415
2352
        }
2416
2353
 
2417
2354
        memcpy(netdev->dev_addr, adapter->hw.mac_addr, netdev->addr_len);
2418
2355
        memcpy(netdev->perm_addr, adapter->hw.mac_addr, netdev->addr_len);
2419
 
        dev_dbg(&pdev->dev, "mac address : %02x-%02x-%02x-%02x-%02x-%02x\n",
2420
 
                        adapter->hw.mac_addr[0], adapter->hw.mac_addr[1],
2421
 
                        adapter->hw.mac_addr[2], adapter->hw.mac_addr[3],
2422
 
                        adapter->hw.mac_addr[4], adapter->hw.mac_addr[5]);
 
2356
        netdev_dbg(netdev, "mac address : %pM\n", adapter->hw.mac_addr);
2423
2357
 
2424
2358
        INIT_WORK(&adapter->reset_task, atl1e_reset_task);
2425
2359
        INIT_WORK(&adapter->link_chg_task, atl1e_link_chg_task);
2426
2360
        err = register_netdev(netdev);
2427
2361
        if (err) {
2428
 
                dev_err(&pdev->dev, "register netdevice failed\n");
 
2362
                netdev_err(netdev, "register netdevice failed\n");
2429
2363
                goto err_register;
2430
2364
        }
2431
2365
 
2526
2460
        struct atl1e_adapter *adapter = netdev_priv(netdev);
2527
2461
 
2528
2462
        if (pci_enable_device(pdev)) {
2529
 
                dev_err(&pdev->dev,
2530
 
                       "ATL1e: Cannot re-enable PCI device after reset.\n");
 
2463
                netdev_err(adapter->netdev,
 
2464
                           "Cannot re-enable PCI device after reset\n");
2531
2465
                return PCI_ERS_RESULT_DISCONNECT;
2532
2466
        }
2533
2467
        pci_set_master(pdev);
2555
2489
 
2556
2490
        if (netif_running(netdev)) {
2557
2491
                if (atl1e_up(adapter)) {
2558
 
                        dev_err(&pdev->dev,
2559
 
                          "ATL1e: can't bring device back up after reset\n");
 
2492
                        netdev_err(adapter->netdev,
 
2493
                                   "can't bring device back up after reset\n");
2560
2494
                        return;
2561
2495
                }
2562
2496
        }