← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/net/pch_gbe/pch_gbe_main.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/pch_gbe/pch_gbe_main.c
20
20
 
21
21
#include "pch_gbe.h"
22
22
#include "pch_gbe_api.h"
 
23
#include <linux/prefetch.h>
23
24
 
24
25
#define DRV_VERSION     "1.00"
25
26
const char pch_driver_version[] = DRV_VERSION;
34
35
#define PCH_GBE_COPYBREAK_DEFAULT       256
35
36
#define PCH_GBE_PCI_BAR                 1
36
37
 
 
38
/* Macros for ML7223 */
 
39
#define PCI_VENDOR_ID_ROHM                      0x10db
 
40
#define PCI_DEVICE_ID_ROHM_ML7223_GBE           0x8013
 
41
 
37
42
#define PCH_GBE_TX_WEIGHT         64
38
43
#define PCH_GBE_RX_WEIGHT         64
39
44
#define PCH_GBE_RX_BUFFER_WRITE   16
43
48
 
44
49
#define PCH_GBE_MAC_RGMII_CTRL_SETTING ( \
45
50
        PCH_GBE_CHIP_TYPE_INTERNAL | \
46
 
        PCH_GBE_RGMII_MODE_RGMII   | \
47
 
        PCH_GBE_CRS_SEL              \
 
51
        PCH_GBE_RGMII_MODE_RGMII     \
48
52
        )
49
53
 
50
54
/* Ethertype field values */
656
660
 */
657
661
static void pch_gbe_setup_rctl(struct pch_gbe_adapter *adapter)
658
662
{
 
663
        struct net_device *netdev = adapter->netdev;
659
664
        struct pch_gbe_hw *hw = &adapter->hw;
660
665
        u32 rx_mode, tcpip;
661
666
 
666
671
 
667
672
        tcpip = ioread32(&hw->reg->TCPIP_ACC);
668
673
 
669
 
        if (adapter->rx_csum) {
 
674
        if (netdev->features & NETIF_F_RXCSUM) {
670
675
                tcpip &= ~PCH_GBE_RX_TCPIPACC_OFF;
671
676
                tcpip |= PCH_GBE_RX_TCPIPACC_EN;
672
677
        } else {
887
892
        struct pch_gbe_adapter *adapter = (struct pch_gbe_adapter *)data;
888
893
        struct net_device *netdev = adapter->netdev;
889
894
        struct pch_gbe_hw *hw = &adapter->hw;
890
 
        struct ethtool_cmd cmd;
891
895
 
892
896
        pr_debug("right now = %ld\n", jiffies);
893
897
 
894
898
        pch_gbe_update_stats(adapter);
895
899
        if ((mii_link_ok(&adapter->mii)) && (!netif_carrier_ok(netdev))) {
 
900
                struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
896
901
                netdev->tx_queue_len = adapter->tx_queue_len;
897
902
                /* mii library handles link maintenance tasks */
898
903
                if (mii_ethtool_gset(&adapter->mii, &cmd)) {
902
907
                                                PCH_GBE_WATCHDOG_PERIOD));
903
908
                        return;
904
909
                }
905
 
                hw->mac.link_speed = cmd.speed;
 
910
                hw->mac.link_speed = ethtool_cmd_speed(&cmd);
906
911
                hw->mac.link_duplex = cmd.duplex;
907
912
                /* Set the RGMII control. */
908
913
                pch_gbe_set_rgmii_ctrl(adapter, hw->mac.link_speed,
912
917
                                 hw->mac.link_duplex);
913
918
                netdev_dbg(netdev,
914
919
                           "Link is Up %d Mbps %s-Duplex\n",
915
 
                           cmd.speed,
 
920
                           hw->mac.link_speed,
916
921
                           cmd.duplex == DUPLEX_FULL ? "Full" : "Half");
917
922
                netif_carrier_on(netdev);
918
923
                netif_wake_queue(netdev);
950
955
        frame_ctrl = 0;
951
956
        if (unlikely(skb->len < PCH_GBE_SHORT_PKT))
952
957
                frame_ctrl |= PCH_GBE_TXD_CTRL_APAD;
953
 
        if (unlikely(!adapter->tx_csum))
 
958
        if (skb->ip_summed == CHECKSUM_NONE)
954
959
                frame_ctrl |= PCH_GBE_TXD_CTRL_TCPIP_ACC_OFF;
955
960
 
956
961
        /* Performs checksum processing */
958
963
         * It is because the hardware accelerator does not support a checksum,
959
964
         * when the received data size is less than 64 bytes.
960
965
         */
961
 
        if ((skb->len < PCH_GBE_SHORT_PKT) && (adapter->tx_csum)) {
 
966
        if (skb->len < PCH_GBE_SHORT_PKT && skb->ip_summed != CHECKSUM_NONE) {
962
967
                frame_ctrl |= PCH_GBE_TXD_CTRL_APAD |
963
968
                              PCH_GBE_TXD_CTRL_TCPIP_ACC_OFF;
964
969
                if (skb->protocol == htons(ETH_P_IP)) {
1011
1016
        tmp_skb->len = skb->len;
1012
1017
        memcpy(&tmp_skb->data[ETH_HLEN + 2], &skb->data[ETH_HLEN],
1013
1018
               (skb->len - ETH_HLEN));
1014
 
        /*-- Set Buffer infomation --*/
 
1019
        /*-- Set Buffer information --*/
1015
1020
        buffer_info->length = tmp_skb->len;
1016
1021
        buffer_info->dma = dma_map_single(&adapter->pdev->dev, tmp_skb->data,
1017
1022
                                          buffer_info->length,
1426
1431
                        length = (rx_desc->rx_words_eob) - 3;
1427
1432
 
1428
1433
                        /* Decide the data conversion method */
1429
 
                        if (!adapter->rx_csum) {
 
1434
                        if (!(netdev->features & NETIF_F_RXCSUM)) {
1430
1435
                                /* [Header:14][payload] */
1431
1436
                                if (NET_IP_ALIGN) {
1432
1437
                                        /* Because alignment differs,
1494
1499
                        /* Write meta date of skb */
1495
1500
                        skb_put(skb, length);
1496
1501
                        skb->protocol = eth_type_trans(skb, netdev);
1497
 
                        if ((tcp_ip_status & PCH_GBE_RXD_ACC_STAT_TCPIPOK) ==
1498
 
                            PCH_GBE_RXD_ACC_STAT_TCPIPOK) {
 
1502
                        if (tcp_ip_status & PCH_GBE_RXD_ACC_STAT_TCPIPOK)
 
1503
                                skb->ip_summed = CHECKSUM_NONE;
 
1504
                        else
1499
1505
                                skb->ip_summed = CHECKSUM_UNNECESSARY;
1500
 
                        } else {
1501
 
                                skb->ip_summed = CHECKSUM_NONE;
1502
 
                        }
 
1506
 
1503
1507
                        napi_gro_receive(&adapter->napi, skb);
1504
1508
                        (*work_done)++;
1505
1509
                        pr_debug("Receive skb->ip_summed: %d length: %d\n",
1540
1544
        size = (int)sizeof(struct pch_gbe_buffer) * tx_ring->count;
1541
1545
        tx_ring->buffer_info = vzalloc(size);
1542
1546
        if (!tx_ring->buffer_info) {
1543
 
                pr_err("Unable to allocate memory for the buffer infomation\n");
 
1547
                pr_err("Unable to allocate memory for the buffer information\n");
1544
1548
                return -ENOMEM;
1545
1549
        }
1546
1550
 
2030
2034
}
2031
2035
 
2032
2036
/**
 
2037
 * pch_gbe_set_features - Reset device after features changed
 
2038
 * @netdev:   Network interface device structure
 
2039
 * @features:  New features
 
2040
 * Returns
 
2041
 *      0:              HW state updated successfully
 
2042
 */
 
2043
static int pch_gbe_set_features(struct net_device *netdev, u32 features)
 
2044
{
 
2045
        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 
2046
        u32 changed = features ^ netdev->features;
 
2047
 
 
2048
        if (!(changed & NETIF_F_RXCSUM))
 
2049
                return 0;
 
2050
 
 
2051
        if (netif_running(netdev))
 
2052
                pch_gbe_reinit_locked(adapter);
 
2053
        else
 
2054
                pch_gbe_reset(adapter);
 
2055
 
 
2056
        return 0;
 
2057
}
 
2058
 
 
2059
/**
2033
2060
 * pch_gbe_ioctl - Controls register through a MII interface
2034
2061
 * @netdev:   Network interface device structure
2035
2062
 * @ifr:      Pointer to ifr structure
2129
2156
        .ndo_set_mac_address = pch_gbe_set_mac,
2130
2157
        .ndo_tx_timeout = pch_gbe_tx_timeout,
2131
2158
        .ndo_change_mtu = pch_gbe_change_mtu,
 
2159
        .ndo_set_features = pch_gbe_set_features,
2132
2160
        .ndo_do_ioctl = pch_gbe_ioctl,
2133
2161
        .ndo_set_multicast_list = &pch_gbe_set_multi,
2134
2162
#ifdef CONFIG_NET_POLL_CONTROLLER
2334
2362
        netdev->watchdog_timeo = PCH_GBE_WATCHDOG_PERIOD;
2335
2363
        netif_napi_add(netdev, &adapter->napi,
2336
2364
                       pch_gbe_napi_poll, PCH_GBE_RX_WEIGHT);
2337
 
        netdev->features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_GRO;
 
2365
        netdev->hw_features = NETIF_F_RXCSUM |
 
2366
                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
 
2367
        netdev->features = netdev->hw_features;
2338
2368
        pch_gbe_set_ethtool_ops(netdev);
2339
2369
 
2340
2370
        pch_gbe_mac_load_mac_addr(&adapter->hw);
2373
2403
 
2374
2404
        pch_gbe_check_options(adapter);
2375
2405
 
2376
 
        if (adapter->tx_csum)
2377
 
                netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
2378
 
        else
2379
 
                netdev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
2380
 
 
2381
2406
        /* initialize the wol settings based on the eeprom settings */
2382
2407
        adapter->wake_up_evt = PCH_GBE_WL_INIT_SETTING;
2383
2408
        dev_info(&pdev->dev, "MAC address : %pM\n", netdev->dev_addr);
2420
2445
         .class = (PCI_CLASS_NETWORK_ETHERNET << 8),
2421
2446
         .class_mask = (0xFFFF00)
2422
2447
         },
 
2448
        {.vendor = PCI_VENDOR_ID_ROHM,
 
2449
         .device = PCI_DEVICE_ID_ROHM_ML7223_GBE,
 
2450
         .subvendor = PCI_ANY_ID,
 
2451
         .subdevice = PCI_ANY_ID,
 
2452
         .class = (PCI_CLASS_NETWORK_ETHERNET << 8),
 
2453
         .class_mask = (0xFFFF00)
 
2454
         },
2423
2455
        /* required last entry */
2424
2456
        {0}
2425
2457
};
2441
2473
        .resume = pch_gbe_io_resume
2442
2474
};
2443
2475
 
2444
 
static struct pci_driver pch_gbe_pcidev = {
 
2476
static struct pci_driver pch_gbe_driver = {
2445
2477
        .name = KBUILD_MODNAME,
2446
2478
        .id_table = pch_gbe_pcidev_id,
2447
2479
        .probe = pch_gbe_probe,
2448
2480
        .remove = pch_gbe_remove,
2449
 
#ifdef CONFIG_PM_OPS
 
2481
#ifdef CONFIG_PM
2450
2482
        .driver.pm = &pch_gbe_pm_ops,
2451
2483
#endif
2452
2484
        .shutdown = pch_gbe_shutdown,
2458
2490
{
2459
2491
        int ret;
2460
2492
 
2461
 
        ret = pci_register_driver(&pch_gbe_pcidev);
 
2493
        ret = pci_register_driver(&pch_gbe_driver);
2462
2494
        if (copybreak != PCH_GBE_COPYBREAK_DEFAULT) {
2463
2495
                if (copybreak == 0) {
2464
2496
                        pr_info("copybreak disabled\n");
2472
2504
 
2473
2505
static void __exit pch_gbe_exit_module(void)
2474
2506
{
2475
 
        pci_unregister_driver(&pch_gbe_pcidev);
 
2507
        pci_unregister_driver(&pch_gbe_driver);
2476
2508
}
2477
2509
 
2478
2510
module_init(pch_gbe_init_module);