← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/net/skge.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/skge.c
44
44
#include <linux/mii.h>
45
45
#include <linux/slab.h>
46
46
#include <linux/dmi.h>
 
47
#include <linux/prefetch.h>
47
48
#include <asm/irq.h>
48
49
 
49
50
#include "skge.h"
303
304
 
304
305
        ecmd->advertising = skge->advertising;
305
306
        ecmd->autoneg = skge->autoneg;
306
 
        ecmd->speed = skge->speed;
 
307
        ethtool_cmd_speed_set(ecmd, skge->speed);
307
308
        ecmd->duplex = skge->duplex;
308
309
        return 0;
309
310
}
321
322
                skge->speed = -1;
322
323
        } else {
323
324
                u32 setting;
 
325
                u32 speed = ethtool_cmd_speed(ecmd);
324
326
 
325
 
                switch (ecmd->speed) {
 
327
                switch (speed) {
326
328
                case SPEED_1000:
327
329
                        if (ecmd->duplex == DUPLEX_FULL)
328
330
                                setting = SUPPORTED_1000baseT_Full;
355
357
                if ((setting & supported) == 0)
356
358
                        return -EINVAL;
357
359
 
358
 
                skge->speed = ecmd->speed;
 
360
                skge->speed = speed;
359
361
                skge->duplex = ecmd->duplex;
360
362
        }
361
363
 
537
539
        return 0;
538
540
}
539
541
 
540
 
static int skge_set_sg(struct net_device *dev, u32 data)
541
 
{
542
 
        struct skge_port *skge = netdev_priv(dev);
543
 
        struct skge_hw *hw = skge->hw;
544
 
 
545
 
        if (hw->chip_id == CHIP_ID_GENESIS && data)
546
 
                return -EOPNOTSUPP;
547
 
        return ethtool_op_set_sg(dev, data);
548
 
}
549
 
 
550
 
static int skge_set_tx_csum(struct net_device *dev, u32 data)
551
 
{
552
 
        struct skge_port *skge = netdev_priv(dev);
553
 
        struct skge_hw *hw = skge->hw;
554
 
 
555
 
        if (hw->chip_id == CHIP_ID_GENESIS && data)
556
 
                return -EOPNOTSUPP;
557
 
 
558
 
        return ethtool_op_set_tx_csum(dev, data);
559
 
}
560
 
 
561
 
static u32 skge_get_rx_csum(struct net_device *dev)
562
 
{
563
 
        struct skge_port *skge = netdev_priv(dev);
564
 
 
565
 
        return skge->rx_csum;
566
 
}
567
 
 
568
 
/* Only Yukon supports checksum offload. */
569
 
static int skge_set_rx_csum(struct net_device *dev, u32 data)
570
 
{
571
 
        struct skge_port *skge = netdev_priv(dev);
572
 
 
573
 
        if (skge->hw->chip_id == CHIP_ID_GENESIS && data)
574
 
                return -EOPNOTSUPP;
575
 
 
576
 
        skge->rx_csum = data;
577
 
        return 0;
578
 
}
579
 
 
580
542
static void skge_get_pauseparam(struct net_device *dev,
581
543
                                struct ethtool_pauseparam *ecmd)
582
544
{
786
748
}
787
749
 
788
750
/* blink LED's for finding board */
789
 
static int skge_phys_id(struct net_device *dev, u32 data)
 
751
static int skge_set_phys_id(struct net_device *dev,
 
752
                            enum ethtool_phys_id_state state)
790
753
{
791
754
        struct skge_port *skge = netdev_priv(dev);
792
 
        unsigned long ms;
793
 
        enum led_mode mode = LED_MODE_TST;
794
 
 
795
 
        if (!data || data > (u32)(MAX_SCHEDULE_TIMEOUT / HZ))
796
 
                ms = jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT / HZ) * 1000;
797
 
        else
798
 
                ms = data * 1000;
799
 
 
800
 
        while (ms > 0) {
801
 
                skge_led(skge, mode);
802
 
                mode ^= LED_MODE_TST;
803
 
 
804
 
                if (msleep_interruptible(BLINK_MS))
805
 
                        break;
806
 
                ms -= BLINK_MS;
 
755
 
 
756
        switch (state) {
 
757
        case ETHTOOL_ID_ACTIVE:
 
758
                return 2;       /* cycle on/off twice per second */
 
759
 
 
760
        case ETHTOOL_ID_ON:
 
761
                skge_led(skge, LED_MODE_TST);
 
762
                break;
 
763
 
 
764
        case ETHTOOL_ID_OFF:
 
765
                skge_led(skge, LED_MODE_OFF);
 
766
                break;
 
767
 
 
768
        case ETHTOOL_ID_INACTIVE:
 
769
                /* back to regular LED state */
 
770
                skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
807
771
        }
808
772
 
809
 
        /* back to regular LED state */
810
 
        skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
811
 
 
812
773
        return 0;
813
774
}
814
775
 
925
886
        .set_pauseparam = skge_set_pauseparam,
926
887
        .get_coalesce   = skge_get_coalesce,
927
888
        .set_coalesce   = skge_set_coalesce,
928
 
        .set_sg         = skge_set_sg,
929
 
        .set_tx_csum    = skge_set_tx_csum,
930
 
        .get_rx_csum    = skge_get_rx_csum,
931
 
        .set_rx_csum    = skge_set_rx_csum,
932
889
        .get_strings    = skge_get_strings,
933
 
        .phys_id        = skge_phys_id,
 
890
        .set_phys_id    = skge_set_phys_id,
934
891
        .get_sset_count = skge_get_sset_count,
935
892
        .get_ethtool_stats = skge_get_ethtool_stats,
936
893
};
3085
3042
        }
3086
3043
 
3087
3044
        skb_put(skb, len);
3088
 
        if (skge->rx_csum) {
 
3045
 
 
3046
        if (dev->features & NETIF_F_RXCSUM) {
3089
3047
                skb->csum = csum;
3090
3048
                skb->ip_summed = CHECKSUM_COMPLETE;
3091
3049
        }
3847
3805
        setup_timer(&skge->link_timer, xm_link_timer, (unsigned long) skge);
3848
3806
 
3849
3807
        if (hw->chip_id != CHIP_ID_GENESIS) {
3850
 
                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
3851
 
                skge->rx_csum = 1;
 
3808
                dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
 
3809
                                   NETIF_F_RXCSUM;
 
3810
                dev->features |= dev->hw_features;
3852
3811
        }
3853
 
        dev->features |= NETIF_F_GRO;
3854
3812
 
3855
3813
        /* read the mac address */
3856
3814
        memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port*8, ETH_ALEN);