← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-ti-omap4/saucy-proposed

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/natsemi/natsemi.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Stefan Bader, Upstream Kernel Changes
  • Date: 2012-08-15 17:17:43 UTC
  • Revision ID: package-import@ubuntu.com-20120815171743-h5wnuf51xe7pvdid
Tags: 3.5.0-207.13
[ Paolo Pisati ]

* Start new release

[ Stefan Bader ]

* (config) Enable getabis to use local package copies

[ Upstream Kernel Changes ]

* fixup: gargabe collect iva_seq[0|1] init
* [Config] enable all SND_OMAP_SOC_*s
* fixup: cm2xxx_3xxx.o is needed for omap2_cm_read|write_reg
* fixup: add some snd_soc_dai* helper functions
* fixup: s/snd_soc_dpcm_params/snd_soc_dpcm/g
* fixup: typo, no_host_mode and useless SDP4430 init
* fixup: enable again aess hwmod

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/ethernet/natsemi/natsemi.c
547
547
        struct sk_buff *tx_skbuff[TX_RING_SIZE];
548
548
        dma_addr_t tx_dma[TX_RING_SIZE];
549
549
        struct net_device *dev;
 
550
        void __iomem *ioaddr;
550
551
        struct napi_struct napi;
551
552
        /* Media monitoring timer */
552
553
        struct timer_list timer;
699
700
 
700
701
static inline void __iomem *ns_ioaddr(struct net_device *dev)
701
702
{
702
 
        return (void __iomem *) dev->base_addr;
 
703
        struct netdev_private *np = netdev_priv(dev);
 
704
 
 
705
        return np->ioaddr;
703
706
}
704
707
 
705
708
static inline void natsemi_irq_enable(struct net_device *dev)
863
866
        /* Store MAC Address in perm_addr */
864
867
        memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
865
868
 
866
 
        dev->base_addr = (unsigned long __force) ioaddr;
867
 
        dev->irq = irq;
868
 
 
869
869
        np = netdev_priv(dev);
 
870
        np->ioaddr = ioaddr;
 
871
 
870
872
        netif_napi_add(dev, &np->napi, natsemi_poll, 64);
871
873
        np->dev = dev;
872
874
 
914
916
        }
915
917
 
916
918
        option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
917
 
        if (dev->mem_start)
918
 
                option = dev->mem_start;
919
 
 
920
919
        /* The lower four bits are the media type. */
921
920
        if (option) {
922
921
                if (option & 0x200)
1532
1531
{
1533
1532
        struct netdev_private *np = netdev_priv(dev);
1534
1533
        void __iomem * ioaddr = ns_ioaddr(dev);
 
1534
        const int irq = np->pci_dev->irq;
1535
1535
        int i;
1536
1536
 
1537
1537
        /* Reset the chip, just in case. */
1538
1538
        natsemi_reset(dev);
1539
1539
 
1540
 
        i = request_irq(dev->irq, intr_handler, IRQF_SHARED, dev->name, dev);
 
1540
        i = request_irq(irq, intr_handler, IRQF_SHARED, dev->name, dev);
1541
1541
        if (i) return i;
1542
1542
 
1543
1543
        if (netif_msg_ifup(np))
1544
1544
                printk(KERN_DEBUG "%s: netdev_open() irq %d.\n",
1545
 
                        dev->name, dev->irq);
 
1545
                        dev->name, irq);
1546
1546
        i = alloc_ring(dev);
1547
1547
        if (i < 0) {
1548
 
                free_irq(dev->irq, dev);
 
1548
                free_irq(irq, dev);
1549
1549
                return i;
1550
1550
        }
1551
1551
        napi_enable(&np->napi);
1794
1794
        struct netdev_private *np = netdev_priv(dev);
1795
1795
        void __iomem * ioaddr = ns_ioaddr(dev);
1796
1796
        int next_tick = NATSEMI_TIMER_FREQ;
 
1797
        const int irq = np->pci_dev->irq;
1797
1798
 
1798
1799
        if (netif_msg_timer(np)) {
1799
1800
                /* DO NOT read the IntrStatus register,
1817
1818
                                if (netif_msg_drv(np))
1818
1819
                                        printk(KERN_NOTICE "%s: possible phy reset: "
1819
1820
                                                "re-initializing\n", dev->name);
1820
 
                                disable_irq(dev->irq);
 
1821
                                disable_irq(irq);
1821
1822
                                spin_lock_irq(&np->lock);
1822
1823
                                natsemi_stop_rxtx(dev);
1823
1824
                                dump_ring(dev);
1824
1825
                                reinit_ring(dev);
1825
1826
                                init_registers(dev);
1826
1827
                                spin_unlock_irq(&np->lock);
1827
 
                                enable_irq(dev->irq);
 
1828
                                enable_irq(irq);
1828
1829
                        } else {
1829
1830
                                /* hurry back */
1830
1831
                                next_tick = HZ;
1841
1842
                spin_unlock_irq(&np->lock);
1842
1843
        }
1843
1844
        if (np->oom) {
1844
 
                disable_irq(dev->irq);
 
1845
                disable_irq(irq);
1845
1846
                np->oom = 0;
1846
1847
                refill_rx(dev);
1847
 
                enable_irq(dev->irq);
 
1848
                enable_irq(irq);
1848
1849
                if (!np->oom) {
1849
1850
                        writel(RxOn, ioaddr + ChipCmd);
1850
1851
                } else {
1885
1886
{
1886
1887
        struct netdev_private *np = netdev_priv(dev);
1887
1888
        void __iomem * ioaddr = ns_ioaddr(dev);
 
1889
        const int irq = np->pci_dev->irq;
1888
1890
 
1889
 
        disable_irq(dev->irq);
 
1891
        disable_irq(irq);
1890
1892
        spin_lock_irq(&np->lock);
1891
1893
        if (!np->hands_off) {
1892
1894
                if (netif_msg_tx_err(np))
1905
1907
                        dev->name);
1906
1908
        }
1907
1909
        spin_unlock_irq(&np->lock);
1908
 
        enable_irq(dev->irq);
 
1910
        enable_irq(irq);
1909
1911
 
1910
1912
        dev->trans_start = jiffies; /* prevent tx timeout */
1911
1913
        dev->stats.tx_errors++;
2470
2472
#ifdef CONFIG_NET_POLL_CONTROLLER
2471
2473
static void natsemi_poll_controller(struct net_device *dev)
2472
2474
{
2473
 
        disable_irq(dev->irq);
2474
 
        intr_handler(dev->irq, dev);
2475
 
        enable_irq(dev->irq);
 
2475
        struct netdev_private *np = netdev_priv(dev);
 
2476
        const int irq = np->pci_dev->irq;
 
2477
 
 
2478
        disable_irq(irq);
 
2479
        intr_handler(irq, dev);
 
2480
        enable_irq(irq);
2476
2481
}
2477
2482
#endif
2478
2483
 
2523
2528
        if (netif_running(dev)) {
2524
2529
                struct netdev_private *np = netdev_priv(dev);
2525
2530
                void __iomem * ioaddr = ns_ioaddr(dev);
 
2531
                const int irq = np->pci_dev->irq;
2526
2532
 
2527
 
                disable_irq(dev->irq);
 
2533
                disable_irq(irq);
2528
2534
                spin_lock(&np->lock);
2529
2535
                /* stop engines */
2530
2536
                natsemi_stop_rxtx(dev);
2537
2543
                /* restart engines */
2538
2544
                writel(RxOn | TxOn, ioaddr + ChipCmd);
2539
2545
                spin_unlock(&np->lock);
2540
 
                enable_irq(dev->irq);
 
2546
                enable_irq(irq);
2541
2547
        }
2542
2548
        return 0;
2543
2549
}
3135
3141
{
3136
3142
        void __iomem * ioaddr = ns_ioaddr(dev);
3137
3143
        struct netdev_private *np = netdev_priv(dev);
 
3144
        const int irq = np->pci_dev->irq;
3138
3145
 
3139
3146
        if (netif_msg_ifdown(np))
3140
3147
                printk(KERN_DEBUG
3156
3163
         */
3157
3164
 
3158
3165
        del_timer_sync(&np->timer);
3159
 
        disable_irq(dev->irq);
 
3166
        disable_irq(irq);
3160
3167
        spin_lock_irq(&np->lock);
3161
3168
        natsemi_irq_disable(dev);
3162
3169
        np->hands_off = 1;
3163
3170
        spin_unlock_irq(&np->lock);
3164
 
        enable_irq(dev->irq);
 
3171
        enable_irq(irq);
3165
3172
 
3166
 
        free_irq(dev->irq, dev);
 
3173
        free_irq(irq, dev);
3167
3174
 
3168
3175
        /* Interrupt disabled, interrupt handler released,
3169
3176
         * queue stopped, timer deleted, rtnl_lock held
3256
3263
 
3257
3264
        rtnl_lock();
3258
3265
        if (netif_running (dev)) {
 
3266
                const int irq = np->pci_dev->irq;
 
3267
 
3259
3268
                del_timer_sync(&np->timer);
3260
3269
 
3261
 
                disable_irq(dev->irq);
 
3270
                disable_irq(irq);
3262
3271
                spin_lock_irq(&np->lock);
3263
3272
 
3264
3273
                natsemi_irq_disable(dev);
3267
3276
                netif_stop_queue(dev);
3268
3277
 
3269
3278
                spin_unlock_irq(&np->lock);
3270
 
                enable_irq(dev->irq);
 
3279
                enable_irq(irq);
3271
3280
 
3272
3281
                napi_disable(&np->napi);
3273
3282
 
3307
3316
        if (netif_device_present(dev))
3308
3317
                goto out;
3309
3318
        if (netif_running(dev)) {
 
3319
                const int irq = np->pci_dev->irq;
 
3320
 
3310
3321
                BUG_ON(!np->hands_off);
3311
3322
                ret = pci_enable_device(pdev);
3312
3323
                if (ret < 0) {
3320
3331
 
3321
3332
                natsemi_reset(dev);
3322
3333
                init_ring(dev);
3323
 
                disable_irq(dev->irq);
 
3334
                disable_irq(irq);
3324
3335
                spin_lock_irq(&np->lock);
3325
3336
                np->hands_off = 0;
3326
3337
                init_registers(dev);
3327
3338
                netif_device_attach(dev);
3328
3339
                spin_unlock_irq(&np->lock);
3329
 
                enable_irq(dev->irq);
 
3340
                enable_irq(irq);
3330
3341
 
3331
3342
                mod_timer(&np->timer, round_jiffies(jiffies + 1*HZ));
3332
3343
        }