← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/net/fs_enet/fs_enet-main.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/fs_enet/fs_enet-main.c
1
 
/*
2
 
 * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
3
 
 *
4
 
 * Copyright (c) 2003 Intracom S.A.
5
 
 *  by Pantelis Antoniou <panto@intracom.gr>
6
 
 *
7
 
 * 2005 (c) MontaVista Software, Inc.
8
 
 * Vitaly Bordug <vbordug@ru.mvista.com>
9
 
 *
10
 
 * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
11
 
 * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
12
 
 *
13
 
 * This file is licensed under the terms of the GNU General Public License
14
 
 * version 2. This program is licensed "as is" without any warranty of any
15
 
 * kind, whether express or implied.
16
 
 */
17
 
 
18
 
#include <linux/module.h>
19
 
#include <linux/kernel.h>
20
 
#include <linux/types.h>
21
 
#include <linux/string.h>
22
 
#include <linux/ptrace.h>
23
 
#include <linux/errno.h>
24
 
#include <linux/ioport.h>
25
 
#include <linux/slab.h>
26
 
#include <linux/interrupt.h>
27
 
#include <linux/init.h>
28
 
#include <linux/delay.h>
29
 
#include <linux/netdevice.h>
30
 
#include <linux/etherdevice.h>
31
 
#include <linux/skbuff.h>
32
 
#include <linux/spinlock.h>
33
 
#include <linux/mii.h>
34
 
#include <linux/ethtool.h>
35
 
#include <linux/bitops.h>
36
 
#include <linux/fs.h>
37
 
#include <linux/platform_device.h>
38
 
#include <linux/phy.h>
39
 
#include <linux/of.h>
40
 
#include <linux/of_mdio.h>
41
 
#include <linux/of_platform.h>
42
 
#include <linux/of_gpio.h>
43
 
#include <linux/of_net.h>
44
 
 
45
 
#include <linux/vmalloc.h>
46
 
#include <asm/pgtable.h>
47
 
#include <asm/irq.h>
48
 
#include <asm/uaccess.h>
49
 
 
50
 
#include "fs_enet.h"
51
 
 
52
 
/*************************************************/
53
 
 
54
 
MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
55
 
MODULE_DESCRIPTION("Freescale Ethernet Driver");
56
 
MODULE_LICENSE("GPL");
57
 
MODULE_VERSION(DRV_MODULE_VERSION);
58
 
 
59
 
static int fs_enet_debug = -1; /* -1 == use FS_ENET_DEF_MSG_ENABLE as value */
60
 
module_param(fs_enet_debug, int, 0);
61
 
MODULE_PARM_DESC(fs_enet_debug,
62
 
                 "Freescale bitmapped debugging message enable value");
63
 
 
64
 
#ifdef CONFIG_NET_POLL_CONTROLLER
65
 
static void fs_enet_netpoll(struct net_device *dev);
66
 
#endif
67
 
 
68
 
static void fs_set_multicast_list(struct net_device *dev)
69
 
{
70
 
        struct fs_enet_private *fep = netdev_priv(dev);
71
 
 
72
 
        (*fep->ops->set_multicast_list)(dev);
73
 
}
74
 
 
75
 
static void skb_align(struct sk_buff *skb, int align)
76
 
{
77
 
        int off = ((unsigned long)skb->data) & (align - 1);
78
 
 
79
 
        if (off)
80
 
                skb_reserve(skb, align - off);
81
 
}
82
 
 
83
 
/* NAPI receive function */
84
 
static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
85
 
{
86
 
        struct fs_enet_private *fep = container_of(napi, struct fs_enet_private, napi);
87
 
        struct net_device *dev = fep->ndev;
88
 
        const struct fs_platform_info *fpi = fep->fpi;
89
 
        cbd_t __iomem *bdp;
90
 
        struct sk_buff *skb, *skbn, *skbt;
91
 
        int received = 0;
92
 
        u16 pkt_len, sc;
93
 
        int curidx;
94
 
 
95
 
        /*
96
 
         * First, grab all of the stats for the incoming packet.
97
 
         * These get messed up if we get called due to a busy condition.
98
 
         */
99
 
        bdp = fep->cur_rx;
100
 
 
101
 
        /* clear RX status bits for napi*/
102
 
        (*fep->ops->napi_clear_rx_event)(dev);
103
 
 
104
 
        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
105
 
                curidx = bdp - fep->rx_bd_base;
106
 
 
107
 
                /*
108
 
                 * Since we have allocated space to hold a complete frame,
109
 
                 * the last indicator should be set.
110
 
                 */
111
 
                if ((sc & BD_ENET_RX_LAST) == 0)
112
 
                        dev_warn(fep->dev, "rcv is not +last\n");
113
 
 
114
 
                /*
115
 
                 * Check for errors.
116
 
                 */
117
 
                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
118
 
                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
119
 
                        fep->stats.rx_errors++;
120
 
                        /* Frame too long or too short. */
121
 
                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
122
 
                                fep->stats.rx_length_errors++;
123
 
                        /* Frame alignment */
124
 
                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
125
 
                                fep->stats.rx_frame_errors++;
126
 
                        /* CRC Error */
127
 
                        if (sc & BD_ENET_RX_CR)
128
 
                                fep->stats.rx_crc_errors++;
129
 
                        /* FIFO overrun */
130
 
                        if (sc & BD_ENET_RX_OV)
131
 
                                fep->stats.rx_crc_errors++;
132
 
 
133
 
                        skb = fep->rx_skbuff[curidx];
134
 
 
135
 
                        dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
136
 
                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
137
 
                                DMA_FROM_DEVICE);
138
 
 
139
 
                        skbn = skb;
140
 
 
141
 
                } else {
142
 
                        skb = fep->rx_skbuff[curidx];
143
 
 
144
 
                        dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
145
 
                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
146
 
                                DMA_FROM_DEVICE);
147
 
 
148
 
                        /*
149
 
                         * Process the incoming frame.
150
 
                         */
151
 
                        fep->stats.rx_packets++;
152
 
                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
153
 
                        fep->stats.rx_bytes += pkt_len + 4;
154
 
 
155
 
                        if (pkt_len <= fpi->rx_copybreak) {
156
 
                                /* +2 to make IP header L1 cache aligned */
157
 
                                skbn = dev_alloc_skb(pkt_len + 2);
158
 
                                if (skbn != NULL) {
159
 
                                        skb_reserve(skbn, 2);   /* align IP header */
160
 
                                        skb_copy_from_linear_data(skb,
161
 
                                                      skbn->data, pkt_len);
162
 
                                        /* swap */
163
 
                                        skbt = skb;
164
 
                                        skb = skbn;
165
 
                                        skbn = skbt;
166
 
                                }
167
 
                        } else {
168
 
                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
169
 
 
170
 
                                if (skbn)
171
 
                                        skb_align(skbn, ENET_RX_ALIGN);
172
 
                        }
173
 
 
174
 
                        if (skbn != NULL) {
175
 
                                skb_put(skb, pkt_len);  /* Make room */
176
 
                                skb->protocol = eth_type_trans(skb, dev);
177
 
                                received++;
178
 
                                netif_receive_skb(skb);
179
 
                        } else {
180
 
                                dev_warn(fep->dev,
181
 
                                         "Memory squeeze, dropping packet.\n");
182
 
                                fep->stats.rx_dropped++;
183
 
                                skbn = skb;
184
 
                        }
185
 
                }
186
 
 
187
 
                fep->rx_skbuff[curidx] = skbn;
188
 
                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
189
 
                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
190
 
                             DMA_FROM_DEVICE));
191
 
                CBDW_DATLEN(bdp, 0);
192
 
                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
193
 
 
194
 
                /*
195
 
                 * Update BD pointer to next entry.
196
 
                 */
197
 
                if ((sc & BD_ENET_RX_WRAP) == 0)
198
 
                        bdp++;
199
 
                else
200
 
                        bdp = fep->rx_bd_base;
201
 
 
202
 
                (*fep->ops->rx_bd_done)(dev);
203
 
 
204
 
                if (received >= budget)
205
 
                        break;
206
 
        }
207
 
 
208
 
        fep->cur_rx = bdp;
209
 
 
210
 
        if (received < budget) {
211
 
                /* done */
212
 
                napi_complete(napi);
213
 
                (*fep->ops->napi_enable_rx)(dev);
214
 
        }
215
 
        return received;
216
 
}
217
 
 
218
 
/* non NAPI receive function */
219
 
static int fs_enet_rx_non_napi(struct net_device *dev)
220
 
{
221
 
        struct fs_enet_private *fep = netdev_priv(dev);
222
 
        const struct fs_platform_info *fpi = fep->fpi;
223
 
        cbd_t __iomem *bdp;
224
 
        struct sk_buff *skb, *skbn, *skbt;
225
 
        int received = 0;
226
 
        u16 pkt_len, sc;
227
 
        int curidx;
228
 
        /*
229
 
         * First, grab all of the stats for the incoming packet.
230
 
         * These get messed up if we get called due to a busy condition.
231
 
         */
232
 
        bdp = fep->cur_rx;
233
 
 
234
 
        while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
235
 
 
236
 
                curidx = bdp - fep->rx_bd_base;
237
 
 
238
 
                /*
239
 
                 * Since we have allocated space to hold a complete frame,
240
 
                 * the last indicator should be set.
241
 
                 */
242
 
                if ((sc & BD_ENET_RX_LAST) == 0)
243
 
                        dev_warn(fep->dev, "rcv is not +last\n");
244
 
 
245
 
                /*
246
 
                 * Check for errors.
247
 
                 */
248
 
                if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
249
 
                          BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
250
 
                        fep->stats.rx_errors++;
251
 
                        /* Frame too long or too short. */
252
 
                        if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
253
 
                                fep->stats.rx_length_errors++;
254
 
                        /* Frame alignment */
255
 
                        if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
256
 
                                fep->stats.rx_frame_errors++;
257
 
                        /* CRC Error */
258
 
                        if (sc & BD_ENET_RX_CR)
259
 
                                fep->stats.rx_crc_errors++;
260
 
                        /* FIFO overrun */
261
 
                        if (sc & BD_ENET_RX_OV)
262
 
                                fep->stats.rx_crc_errors++;
263
 
 
264
 
                        skb = fep->rx_skbuff[curidx];
265
 
 
266
 
                        dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
267
 
                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
268
 
                                DMA_FROM_DEVICE);
269
 
 
270
 
                        skbn = skb;
271
 
 
272
 
                } else {
273
 
 
274
 
                        skb = fep->rx_skbuff[curidx];
275
 
 
276
 
                        dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
277
 
                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
278
 
                                DMA_FROM_DEVICE);
279
 
 
280
 
                        /*
281
 
                         * Process the incoming frame.
282
 
                         */
283
 
                        fep->stats.rx_packets++;
284
 
                        pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
285
 
                        fep->stats.rx_bytes += pkt_len + 4;
286
 
 
287
 
                        if (pkt_len <= fpi->rx_copybreak) {
288
 
                                /* +2 to make IP header L1 cache aligned */
289
 
                                skbn = dev_alloc_skb(pkt_len + 2);
290
 
                                if (skbn != NULL) {
291
 
                                        skb_reserve(skbn, 2);   /* align IP header */
292
 
                                        skb_copy_from_linear_data(skb,
293
 
                                                      skbn->data, pkt_len);
294
 
                                        /* swap */
295
 
                                        skbt = skb;
296
 
                                        skb = skbn;
297
 
                                        skbn = skbt;
298
 
                                }
299
 
                        } else {
300
 
                                skbn = dev_alloc_skb(ENET_RX_FRSIZE);
301
 
 
302
 
                                if (skbn)
303
 
                                        skb_align(skbn, ENET_RX_ALIGN);
304
 
                        }
305
 
 
306
 
                        if (skbn != NULL) {
307
 
                                skb_put(skb, pkt_len);  /* Make room */
308
 
                                skb->protocol = eth_type_trans(skb, dev);
309
 
                                received++;
310
 
                                netif_rx(skb);
311
 
                        } else {
312
 
                                dev_warn(fep->dev,
313
 
                                         "Memory squeeze, dropping packet.\n");
314
 
                                fep->stats.rx_dropped++;
315
 
                                skbn = skb;
316
 
                        }
317
 
                }
318
 
 
319
 
                fep->rx_skbuff[curidx] = skbn;
320
 
                CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
321
 
                             L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
322
 
                             DMA_FROM_DEVICE));
323
 
                CBDW_DATLEN(bdp, 0);
324
 
                CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
325
 
 
326
 
                /*
327
 
                 * Update BD pointer to next entry.
328
 
                 */
329
 
                if ((sc & BD_ENET_RX_WRAP) == 0)
330
 
                        bdp++;
331
 
                else
332
 
                        bdp = fep->rx_bd_base;
333
 
 
334
 
                (*fep->ops->rx_bd_done)(dev);
335
 
        }
336
 
 
337
 
        fep->cur_rx = bdp;
338
 
 
339
 
        return 0;
340
 
}
341
 
 
342
 
static void fs_enet_tx(struct net_device *dev)
343
 
{
344
 
        struct fs_enet_private *fep = netdev_priv(dev);
345
 
        cbd_t __iomem *bdp;
346
 
        struct sk_buff *skb;
347
 
        int dirtyidx, do_wake, do_restart;
348
 
        u16 sc;
349
 
 
350
 
        spin_lock(&fep->tx_lock);
351
 
        bdp = fep->dirty_tx;
352
 
 
353
 
        do_wake = do_restart = 0;
354
 
        while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
355
 
                dirtyidx = bdp - fep->tx_bd_base;
356
 
 
357
 
                if (fep->tx_free == fep->tx_ring)
358
 
                        break;
359
 
 
360
 
                skb = fep->tx_skbuff[dirtyidx];
361
 
 
362
 
                /*
363
 
                 * Check for errors.
364
 
                 */
365
 
                if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
366
 
                          BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
367
 
 
368
 
                        if (sc & BD_ENET_TX_HB) /* No heartbeat */
369
 
                                fep->stats.tx_heartbeat_errors++;
370
 
                        if (sc & BD_ENET_TX_LC) /* Late collision */
371
 
                                fep->stats.tx_window_errors++;
372
 
                        if (sc & BD_ENET_TX_RL) /* Retrans limit */
373
 
                                fep->stats.tx_aborted_errors++;
374
 
                        if (sc & BD_ENET_TX_UN) /* Underrun */
375
 
                                fep->stats.tx_fifo_errors++;
376
 
                        if (sc & BD_ENET_TX_CSL)        /* Carrier lost */
377
 
                                fep->stats.tx_carrier_errors++;
378
 
 
379
 
                        if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
380
 
                                fep->stats.tx_errors++;
381
 
                                do_restart = 1;
382
 
                        }
383
 
                } else
384
 
                        fep->stats.tx_packets++;
385
 
 
386
 
                if (sc & BD_ENET_TX_READY) {
387
 
                        dev_warn(fep->dev,
388
 
                                 "HEY! Enet xmit interrupt and TX_READY.\n");
389
 
                }
390
 
 
391
 
                /*
392
 
                 * Deferred means some collisions occurred during transmit,
393
 
                 * but we eventually sent the packet OK.
394
 
                 */
395
 
                if (sc & BD_ENET_TX_DEF)
396
 
                        fep->stats.collisions++;
397
 
 
398
 
                /* unmap */
399
 
                dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
400
 
                                skb->len, DMA_TO_DEVICE);
401
 
 
402
 
                /*
403
 
                 * Free the sk buffer associated with this last transmit.
404
 
                 */
405
 
                dev_kfree_skb_irq(skb);
406
 
                fep->tx_skbuff[dirtyidx] = NULL;
407
 
 
408
 
                /*
409
 
                 * Update pointer to next buffer descriptor to be transmitted.
410
 
                 */
411
 
                if ((sc & BD_ENET_TX_WRAP) == 0)
412
 
                        bdp++;
413
 
                else
414
 
                        bdp = fep->tx_bd_base;
415
 
 
416
 
                /*
417
 
                 * Since we have freed up a buffer, the ring is no longer
418
 
                 * full.
419
 
                 */
420
 
                if (!fep->tx_free++)
421
 
                        do_wake = 1;
422
 
        }
423
 
 
424
 
        fep->dirty_tx = bdp;
425
 
 
426
 
        if (do_restart)
427
 
                (*fep->ops->tx_restart)(dev);
428
 
 
429
 
        spin_unlock(&fep->tx_lock);
430
 
 
431
 
        if (do_wake)
432
 
                netif_wake_queue(dev);
433
 
}
434
 
 
435
 
/*
436
 
 * The interrupt handler.
437
 
 * This is called from the MPC core interrupt.
438
 
 */
439
 
static irqreturn_t
440
 
fs_enet_interrupt(int irq, void *dev_id)
441
 
{
442
 
        struct net_device *dev = dev_id;
443
 
        struct fs_enet_private *fep;
444
 
        const struct fs_platform_info *fpi;
445
 
        u32 int_events;
446
 
        u32 int_clr_events;
447
 
        int nr, napi_ok;
448
 
        int handled;
449
 
 
450
 
        fep = netdev_priv(dev);
451
 
        fpi = fep->fpi;
452
 
 
453
 
        nr = 0;
454
 
        while ((int_events = (*fep->ops->get_int_events)(dev)) != 0) {
455
 
                nr++;
456
 
 
457
 
                int_clr_events = int_events;
458
 
                if (fpi->use_napi)
459
 
                        int_clr_events &= ~fep->ev_napi_rx;
460
 
 
461
 
                (*fep->ops->clear_int_events)(dev, int_clr_events);
462
 
 
463
 
                if (int_events & fep->ev_err)
464
 
                        (*fep->ops->ev_error)(dev, int_events);
465
 
 
466
 
                if (int_events & fep->ev_rx) {
467
 
                        if (!fpi->use_napi)
468
 
                                fs_enet_rx_non_napi(dev);
469
 
                        else {
470
 
                                napi_ok = napi_schedule_prep(&fep->napi);
471
 
 
472
 
                                (*fep->ops->napi_disable_rx)(dev);
473
 
                                (*fep->ops->clear_int_events)(dev, fep->ev_napi_rx);
474
 
 
475
 
                                /* NOTE: it is possible for FCCs in NAPI mode    */
476
 
                                /* to submit a spurious interrupt while in poll  */
477
 
                                if (napi_ok)
478
 
                                        __napi_schedule(&fep->napi);
479
 
                        }
480
 
                }
481
 
 
482
 
                if (int_events & fep->ev_tx)
483
 
                        fs_enet_tx(dev);
484
 
        }
485
 
 
486
 
        handled = nr > 0;
487
 
        return IRQ_RETVAL(handled);
488
 
}
489
 
 
490
 
void fs_init_bds(struct net_device *dev)
491
 
{
492
 
        struct fs_enet_private *fep = netdev_priv(dev);
493
 
        cbd_t __iomem *bdp;
494
 
        struct sk_buff *skb;
495
 
        int i;
496
 
 
497
 
        fs_cleanup_bds(dev);
498
 
 
499
 
        fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
500
 
        fep->tx_free = fep->tx_ring;
501
 
        fep->cur_rx = fep->rx_bd_base;
502
 
 
503
 
        /*
504
 
         * Initialize the receive buffer descriptors.
505
 
         */
506
 
        for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
507
 
                skb = dev_alloc_skb(ENET_RX_FRSIZE);
508
 
                if (skb == NULL) {
509
 
                        dev_warn(fep->dev,
510
 
                                 "Memory squeeze, unable to allocate skb\n");
511
 
                        break;
512
 
                }
513
 
                skb_align(skb, ENET_RX_ALIGN);
514
 
                fep->rx_skbuff[i] = skb;
515
 
                CBDW_BUFADDR(bdp,
516
 
                        dma_map_single(fep->dev, skb->data,
517
 
                                L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
518
 
                                DMA_FROM_DEVICE));
519
 
                CBDW_DATLEN(bdp, 0);    /* zero */
520
 
                CBDW_SC(bdp, BD_ENET_RX_EMPTY |
521
 
                        ((i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP));
522
 
        }
523
 
        /*
524
 
         * if we failed, fillup remainder
525
 
         */
526
 
        for (; i < fep->rx_ring; i++, bdp++) {
527
 
                fep->rx_skbuff[i] = NULL;
528
 
                CBDW_SC(bdp, (i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP);
529
 
        }
530
 
 
531
 
        /*
532
 
         * ...and the same for transmit.
533
 
         */
534
 
        for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
535
 
                fep->tx_skbuff[i] = NULL;
536
 
                CBDW_BUFADDR(bdp, 0);
537
 
                CBDW_DATLEN(bdp, 0);
538
 
                CBDW_SC(bdp, (i < fep->tx_ring - 1) ? 0 : BD_SC_WRAP);
539
 
        }
540
 
}
541
 
 
542
 
void fs_cleanup_bds(struct net_device *dev)
543
 
{
544
 
        struct fs_enet_private *fep = netdev_priv(dev);
545
 
        struct sk_buff *skb;
546
 
        cbd_t __iomem *bdp;
547
 
        int i;
548
 
 
549
 
        /*
550
 
         * Reset SKB transmit buffers.
551
 
         */
552
 
        for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
553
 
                if ((skb = fep->tx_skbuff[i]) == NULL)
554
 
                        continue;
555
 
 
556
 
                /* unmap */
557
 
                dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
558
 
                                skb->len, DMA_TO_DEVICE);
559
 
 
560
 
                fep->tx_skbuff[i] = NULL;
561
 
                dev_kfree_skb(skb);
562
 
        }
563
 
 
564
 
        /*
565
 
         * Reset SKB receive buffers
566
 
         */
567
 
        for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
568
 
                if ((skb = fep->rx_skbuff[i]) == NULL)
569
 
                        continue;
570
 
 
571
 
                /* unmap */
572
 
                dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
573
 
                        L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
574
 
                        DMA_FROM_DEVICE);
575
 
 
576
 
                fep->rx_skbuff[i] = NULL;
577
 
 
578
 
                dev_kfree_skb(skb);
579
 
        }
580
 
}
581
 
 
582
 
/**********************************************************************************/
583
 
 
584
 
#ifdef CONFIG_FS_ENET_MPC5121_FEC
585
 
/*
586
 
 * MPC5121 FEC requeries 4-byte alignment for TX data buffer!
587
 
 */
588
 
static struct sk_buff *tx_skb_align_workaround(struct net_device *dev,
589
 
                                               struct sk_buff *skb)
590
 
{
591
 
        struct sk_buff *new_skb;
592
 
        struct fs_enet_private *fep = netdev_priv(dev);
593
 
 
594
 
        /* Alloc new skb */
595
 
        new_skb = dev_alloc_skb(skb->len + 4);
596
 
        if (!new_skb) {
597
 
                if (net_ratelimit()) {
598
 
                        dev_warn(fep->dev,
599
 
                                 "Memory squeeze, dropping tx packet.\n");
600
 
                }
601
 
                return NULL;
602
 
        }
603
 
 
604
 
        /* Make sure new skb is properly aligned */
605
 
        skb_align(new_skb, 4);
606
 
 
607
 
        /* Copy data to new skb ... */
608
 
        skb_copy_from_linear_data(skb, new_skb->data, skb->len);
609
 
        skb_put(new_skb, skb->len);
610
 
 
611
 
        /* ... and free an old one */
612
 
        dev_kfree_skb_any(skb);
613
 
 
614
 
        return new_skb;
615
 
}
616
 
#endif
617
 
 
618
 
static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
619
 
{
620
 
        struct fs_enet_private *fep = netdev_priv(dev);
621
 
        cbd_t __iomem *bdp;
622
 
        int curidx;
623
 
        u16 sc;
624
 
        unsigned long flags;
625
 
 
626
 
#ifdef CONFIG_FS_ENET_MPC5121_FEC
627
 
        if (((unsigned long)skb->data) & 0x3) {
628
 
                skb = tx_skb_align_workaround(dev, skb);
629
 
                if (!skb) {
630
 
                        /*
631
 
                         * We have lost packet due to memory allocation error
632
 
                         * in tx_skb_align_workaround(). Hopefully original
633
 
                         * skb is still valid, so try transmit it later.
634
 
                         */
635
 
                        return NETDEV_TX_BUSY;
636
 
                }
637
 
        }
638
 
#endif
639
 
        spin_lock_irqsave(&fep->tx_lock, flags);
640
 
 
641
 
        /*
642
 
         * Fill in a Tx ring entry
643
 
         */
644
 
        bdp = fep->cur_tx;
645
 
 
646
 
        if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
647
 
                netif_stop_queue(dev);
648
 
                spin_unlock_irqrestore(&fep->tx_lock, flags);
649
 
 
650
 
                /*
651
 
                 * Ooops.  All transmit buffers are full.  Bail out.
652
 
                 * This should not happen, since the tx queue should be stopped.
653
 
                 */
654
 
                dev_warn(fep->dev, "tx queue full!.\n");
655
 
                return NETDEV_TX_BUSY;
656
 
        }
657
 
 
658
 
        curidx = bdp - fep->tx_bd_base;
659
 
        /*
660
 
         * Clear all of the status flags.
661
 
         */
662
 
        CBDC_SC(bdp, BD_ENET_TX_STATS);
663
 
 
664
 
        /*
665
 
         * Save skb pointer.
666
 
         */
667
 
        fep->tx_skbuff[curidx] = skb;
668
 
 
669
 
        fep->stats.tx_bytes += skb->len;
670
 
 
671
 
        /*
672
 
         * Push the data cache so the CPM does not get stale memory data.
673
 
         */
674
 
        CBDW_BUFADDR(bdp, dma_map_single(fep->dev,
675
 
                                skb->data, skb->len, DMA_TO_DEVICE));
676
 
        CBDW_DATLEN(bdp, skb->len);
677
 
 
678
 
        /*
679
 
         * If this was the last BD in the ring, start at the beginning again.
680
 
         */
681
 
        if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
682
 
                fep->cur_tx++;
683
 
        else
684
 
                fep->cur_tx = fep->tx_bd_base;
685
 
 
686
 
        if (!--fep->tx_free)
687
 
                netif_stop_queue(dev);
688
 
 
689
 
        /* Trigger transmission start */
690
 
        sc = BD_ENET_TX_READY | BD_ENET_TX_INTR |
691
 
             BD_ENET_TX_LAST | BD_ENET_TX_TC;
692
 
 
693
 
        /* note that while FEC does not have this bit
694
 
         * it marks it as available for software use
695
 
         * yay for hw reuse :) */
696
 
        if (skb->len <= 60)
697
 
                sc |= BD_ENET_TX_PAD;
698
 
        CBDS_SC(bdp, sc);
699
 
 
700
 
        (*fep->ops->tx_kickstart)(dev);
701
 
 
702
 
        spin_unlock_irqrestore(&fep->tx_lock, flags);
703
 
 
704
 
        return NETDEV_TX_OK;
705
 
}
706
 
 
707
 
static void fs_timeout(struct net_device *dev)
708
 
{
709
 
        struct fs_enet_private *fep = netdev_priv(dev);
710
 
        unsigned long flags;
711
 
        int wake = 0;
712
 
 
713
 
        fep->stats.tx_errors++;
714
 
 
715
 
        spin_lock_irqsave(&fep->lock, flags);
716
 
 
717
 
        if (dev->flags & IFF_UP) {
718
 
                phy_stop(fep->phydev);
719
 
                (*fep->ops->stop)(dev);
720
 
                (*fep->ops->restart)(dev);
721
 
                phy_start(fep->phydev);
722
 
        }
723
 
 
724
 
        phy_start(fep->phydev);
725
 
        wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
726
 
        spin_unlock_irqrestore(&fep->lock, flags);
727
 
 
728
 
        if (wake)
729
 
                netif_wake_queue(dev);
730
 
}
731
 
 
732
 
/*-----------------------------------------------------------------------------
733
 
 *  generic link-change handler - should be sufficient for most cases
734
 
 *-----------------------------------------------------------------------------*/
735
 
static void generic_adjust_link(struct  net_device *dev)
736
 
{
737
 
        struct fs_enet_private *fep = netdev_priv(dev);
738
 
        struct phy_device *phydev = fep->phydev;
739
 
        int new_state = 0;
740
 
 
741
 
        if (phydev->link) {
742
 
                /* adjust to duplex mode */
743
 
                if (phydev->duplex != fep->oldduplex) {
744
 
                        new_state = 1;
745
 
                        fep->oldduplex = phydev->duplex;
746
 
                }
747
 
 
748
 
                if (phydev->speed != fep->oldspeed) {
749
 
                        new_state = 1;
750
 
                        fep->oldspeed = phydev->speed;
751
 
                }
752
 
 
753
 
                if (!fep->oldlink) {
754
 
                        new_state = 1;
755
 
                        fep->oldlink = 1;
756
 
                }
757
 
 
758
 
                if (new_state)
759
 
                        fep->ops->restart(dev);
760
 
        } else if (fep->oldlink) {
761
 
                new_state = 1;
762
 
                fep->oldlink = 0;
763
 
                fep->oldspeed = 0;
764
 
                fep->oldduplex = -1;
765
 
        }
766
 
 
767
 
        if (new_state && netif_msg_link(fep))
768
 
                phy_print_status(phydev);
769
 
}
770
 
 
771
 
 
772
 
static void fs_adjust_link(struct net_device *dev)
773
 
{
774
 
        struct fs_enet_private *fep = netdev_priv(dev);
775
 
        unsigned long flags;
776
 
 
777
 
        spin_lock_irqsave(&fep->lock, flags);
778
 
 
779
 
        if(fep->ops->adjust_link)
780
 
                fep->ops->adjust_link(dev);
781
 
        else
782
 
                generic_adjust_link(dev);
783
 
 
784
 
        spin_unlock_irqrestore(&fep->lock, flags);
785
 
}
786
 
 
787
 
static int fs_init_phy(struct net_device *dev)
788
 
{
789
 
        struct fs_enet_private *fep = netdev_priv(dev);
790
 
        struct phy_device *phydev;
791
 
 
792
 
        fep->oldlink = 0;
793
 
        fep->oldspeed = 0;
794
 
        fep->oldduplex = -1;
795
 
 
796
 
        phydev = of_phy_connect(dev, fep->fpi->phy_node, &fs_adjust_link, 0,
797
 
                                PHY_INTERFACE_MODE_MII);
798
 
        if (!phydev) {
799
 
                phydev = of_phy_connect_fixed_link(dev, &fs_adjust_link,
800
 
                                                   PHY_INTERFACE_MODE_MII);
801
 
        }
802
 
        if (!phydev) {
803
 
                dev_err(&dev->dev, "Could not attach to PHY\n");
804
 
                return -ENODEV;
805
 
        }
806
 
 
807
 
        fep->phydev = phydev;
808
 
 
809
 
        return 0;
810
 
}
811
 
 
812
 
static int fs_enet_open(struct net_device *dev)
813
 
{
814
 
        struct fs_enet_private *fep = netdev_priv(dev);
815
 
        int r;
816
 
        int err;
817
 
 
818
 
        /* to initialize the fep->cur_rx,... */
819
 
        /* not doing this, will cause a crash in fs_enet_rx_napi */
820
 
        fs_init_bds(fep->ndev);
821
 
 
822
 
        if (fep->fpi->use_napi)
823
 
                napi_enable(&fep->napi);
824
 
 
825
 
        /* Install our interrupt handler. */
826
 
        r = request_irq(fep->interrupt, fs_enet_interrupt, IRQF_SHARED,
827
 
                        "fs_enet-mac", dev);
828
 
        if (r != 0) {
829
 
                dev_err(fep->dev, "Could not allocate FS_ENET IRQ!");
830
 
                if (fep->fpi->use_napi)
831
 
                        napi_disable(&fep->napi);
832
 
                return -EINVAL;
833
 
        }
834
 
 
835
 
        err = fs_init_phy(dev);
836
 
        if (err) {
837
 
                free_irq(fep->interrupt, dev);
838
 
                if (fep->fpi->use_napi)
839
 
                        napi_disable(&fep->napi);
840
 
                return err;
841
 
        }
842
 
        phy_start(fep->phydev);
843
 
 
844
 
        netif_start_queue(dev);
845
 
 
846
 
        return 0;
847
 
}
848
 
 
849
 
static int fs_enet_close(struct net_device *dev)
850
 
{
851
 
        struct fs_enet_private *fep = netdev_priv(dev);
852
 
        unsigned long flags;
853
 
 
854
 
        netif_stop_queue(dev);
855
 
        netif_carrier_off(dev);
856
 
        if (fep->fpi->use_napi)
857
 
                napi_disable(&fep->napi);
858
 
        phy_stop(fep->phydev);
859
 
 
860
 
        spin_lock_irqsave(&fep->lock, flags);
861
 
        spin_lock(&fep->tx_lock);
862
 
        (*fep->ops->stop)(dev);
863
 
        spin_unlock(&fep->tx_lock);
864
 
        spin_unlock_irqrestore(&fep->lock, flags);
865
 
 
866
 
        /* release any irqs */
867
 
        phy_disconnect(fep->phydev);
868
 
        fep->phydev = NULL;
869
 
        free_irq(fep->interrupt, dev);
870
 
 
871
 
        return 0;
872
 
}
873
 
 
874
 
static struct net_device_stats *fs_enet_get_stats(struct net_device *dev)
875
 
{
876
 
        struct fs_enet_private *fep = netdev_priv(dev);
877
 
        return &fep->stats;
878
 
}
879
 
 
880
 
/*************************************************************************/
881
 
 
882
 
static void fs_get_drvinfo(struct net_device *dev,
883
 
                            struct ethtool_drvinfo *info)
884
 
{
885
 
        strcpy(info->driver, DRV_MODULE_NAME);
886
 
        strcpy(info->version, DRV_MODULE_VERSION);
887
 
}
888
 
 
889
 
static int fs_get_regs_len(struct net_device *dev)
890
 
{
891
 
        struct fs_enet_private *fep = netdev_priv(dev);
892
 
 
893
 
        return (*fep->ops->get_regs_len)(dev);
894
 
}
895
 
 
896
 
static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
897
 
                         void *p)
898
 
{
899
 
        struct fs_enet_private *fep = netdev_priv(dev);
900
 
        unsigned long flags;
901
 
        int r, len;
902
 
 
903
 
        len = regs->len;
904
 
 
905
 
        spin_lock_irqsave(&fep->lock, flags);
906
 
        r = (*fep->ops->get_regs)(dev, p, &len);
907
 
        spin_unlock_irqrestore(&fep->lock, flags);
908
 
 
909
 
        if (r == 0)
910
 
                regs->version = 0;
911
 
}
912
 
 
913
 
static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
914
 
{
915
 
        struct fs_enet_private *fep = netdev_priv(dev);
916
 
 
917
 
        if (!fep->phydev)
918
 
                return -ENODEV;
919
 
 
920
 
        return phy_ethtool_gset(fep->phydev, cmd);
921
 
}
922
 
 
923
 
static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
924
 
{
925
 
        struct fs_enet_private *fep = netdev_priv(dev);
926
 
 
927
 
        if (!fep->phydev)
928
 
                return -ENODEV;
929
 
 
930
 
        return phy_ethtool_sset(fep->phydev, cmd);
931
 
}
932
 
 
933
 
static int fs_nway_reset(struct net_device *dev)
934
 
{
935
 
        return 0;
936
 
}
937
 
 
938
 
static u32 fs_get_msglevel(struct net_device *dev)
939
 
{
940
 
        struct fs_enet_private *fep = netdev_priv(dev);
941
 
        return fep->msg_enable;
942
 
}
943
 
 
944
 
static void fs_set_msglevel(struct net_device *dev, u32 value)
945
 
{
946
 
        struct fs_enet_private *fep = netdev_priv(dev);
947
 
        fep->msg_enable = value;
948
 
}
949
 
 
950
 
static const struct ethtool_ops fs_ethtool_ops = {
951
 
        .get_drvinfo = fs_get_drvinfo,
952
 
        .get_regs_len = fs_get_regs_len,
953
 
        .get_settings = fs_get_settings,
954
 
        .set_settings = fs_set_settings,
955
 
        .nway_reset = fs_nway_reset,
956
 
        .get_link = ethtool_op_get_link,
957
 
        .get_msglevel = fs_get_msglevel,
958
 
        .set_msglevel = fs_set_msglevel,
959
 
        .get_regs = fs_get_regs,
960
 
};
961
 
 
962
 
static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
963
 
{
964
 
        struct fs_enet_private *fep = netdev_priv(dev);
965
 
 
966
 
        if (!netif_running(dev))
967
 
                return -EINVAL;
968
 
 
969
 
        return phy_mii_ioctl(fep->phydev, rq, cmd);
970
 
}
971
 
 
972
 
extern int fs_mii_connect(struct net_device *dev);
973
 
extern void fs_mii_disconnect(struct net_device *dev);
974
 
 
975
 
/**************************************************************************************/
976
 
 
977
 
#ifdef CONFIG_FS_ENET_HAS_FEC
978
 
#define IS_FEC(match) ((match)->data == &fs_fec_ops)
979
 
#else
980
 
#define IS_FEC(match) 0
981
 
#endif
982
 
 
983
 
static const struct net_device_ops fs_enet_netdev_ops = {
984
 
        .ndo_open               = fs_enet_open,
985
 
        .ndo_stop               = fs_enet_close,
986
 
        .ndo_get_stats          = fs_enet_get_stats,
987
 
        .ndo_start_xmit         = fs_enet_start_xmit,
988
 
        .ndo_tx_timeout         = fs_timeout,
989
 
        .ndo_set_multicast_list = fs_set_multicast_list,
990
 
        .ndo_do_ioctl           = fs_ioctl,
991
 
        .ndo_validate_addr      = eth_validate_addr,
992
 
        .ndo_set_mac_address    = eth_mac_addr,
993
 
        .ndo_change_mtu         = eth_change_mtu,
994
 
#ifdef CONFIG_NET_POLL_CONTROLLER
995
 
        .ndo_poll_controller    = fs_enet_netpoll,
996
 
#endif
997
 
};
998
 
 
999
 
static struct of_device_id fs_enet_match[];
1000
 
static int __devinit fs_enet_probe(struct platform_device *ofdev)
1001
 
{
1002
 
        const struct of_device_id *match;
1003
 
        struct net_device *ndev;
1004
 
        struct fs_enet_private *fep;
1005
 
        struct fs_platform_info *fpi;
1006
 
        const u32 *data;
1007
 
        const u8 *mac_addr;
1008
 
        int privsize, len, ret = -ENODEV;
1009
 
 
1010
 
        match = of_match_device(fs_enet_match, &ofdev->dev);
1011
 
        if (!match)
1012
 
                return -EINVAL;
1013
 
 
1014
 
        fpi = kzalloc(sizeof(*fpi), GFP_KERNEL);
1015
 
        if (!fpi)
1016
 
                return -ENOMEM;
1017
 
 
1018
 
        if (!IS_FEC(match)) {
1019
 
                data = of_get_property(ofdev->dev.of_node, "fsl,cpm-command", &len);
1020
 
                if (!data || len != 4)
1021
 
                        goto out_free_fpi;
1022
 
 
1023
 
                fpi->cp_command = *data;
1024
 
        }
1025
 
 
1026
 
        fpi->rx_ring = 32;
1027
 
        fpi->tx_ring = 32;
1028
 
        fpi->rx_copybreak = 240;
1029
 
        fpi->use_napi = 1;
1030
 
        fpi->napi_weight = 17;
1031
 
        fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
1032
 
        if ((!fpi->phy_node) && (!of_get_property(ofdev->dev.of_node, "fixed-link",
1033
 
                                                  NULL)))
1034
 
                goto out_free_fpi;
1035
 
 
1036
 
        privsize = sizeof(*fep) +
1037
 
                   sizeof(struct sk_buff **) *
1038
 
                   (fpi->rx_ring + fpi->tx_ring);
1039
 
 
1040
 
        ndev = alloc_etherdev(privsize);
1041
 
        if (!ndev) {
1042
 
                ret = -ENOMEM;
1043
 
                goto out_put;
1044
 
        }
1045
 
 
1046
 
        SET_NETDEV_DEV(ndev, &ofdev->dev);
1047
 
        dev_set_drvdata(&ofdev->dev, ndev);
1048
 
 
1049
 
        fep = netdev_priv(ndev);
1050
 
        fep->dev = &ofdev->dev;
1051
 
        fep->ndev = ndev;
1052
 
        fep->fpi = fpi;
1053
 
        fep->ops = match->data;
1054
 
 
1055
 
        ret = fep->ops->setup_data(ndev);
1056
 
        if (ret)
1057
 
                goto out_free_dev;
1058
 
 
1059
 
        fep->rx_skbuff = (struct sk_buff **)&fep[1];
1060
 
        fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
1061
 
 
1062
 
        spin_lock_init(&fep->lock);
1063
 
        spin_lock_init(&fep->tx_lock);
1064
 
 
1065
 
        mac_addr = of_get_mac_address(ofdev->dev.of_node);
1066
 
        if (mac_addr)
1067
 
                memcpy(ndev->dev_addr, mac_addr, 6);
1068
 
 
1069
 
        ret = fep->ops->allocate_bd(ndev);
1070
 
        if (ret)
1071
 
                goto out_cleanup_data;
1072
 
 
1073
 
        fep->rx_bd_base = fep->ring_base;
1074
 
        fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
1075
 
 
1076
 
        fep->tx_ring = fpi->tx_ring;
1077
 
        fep->rx_ring = fpi->rx_ring;
1078
 
 
1079
 
        ndev->netdev_ops = &fs_enet_netdev_ops;
1080
 
        ndev->watchdog_timeo = 2 * HZ;
1081
 
        if (fpi->use_napi)
1082
 
                netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi,
1083
 
                               fpi->napi_weight);
1084
 
 
1085
 
        ndev->ethtool_ops = &fs_ethtool_ops;
1086
 
 
1087
 
        init_timer(&fep->phy_timer_list);
1088
 
 
1089
 
        netif_carrier_off(ndev);
1090
 
 
1091
 
        ret = register_netdev(ndev);
1092
 
        if (ret)
1093
 
                goto out_free_bd;
1094
 
 
1095
 
        pr_info("%s: fs_enet: %pM\n", ndev->name, ndev->dev_addr);
1096
 
 
1097
 
        return 0;
1098
 
 
1099
 
out_free_bd:
1100
 
        fep->ops->free_bd(ndev);
1101
 
out_cleanup_data:
1102
 
        fep->ops->cleanup_data(ndev);
1103
 
out_free_dev:
1104
 
        free_netdev(ndev);
1105
 
        dev_set_drvdata(&ofdev->dev, NULL);
1106
 
out_put:
1107
 
        of_node_put(fpi->phy_node);
1108
 
out_free_fpi:
1109
 
        kfree(fpi);
1110
 
        return ret;
1111
 
}
1112
 
 
1113
 
static int fs_enet_remove(struct platform_device *ofdev)
1114
 
{
1115
 
        struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
1116
 
        struct fs_enet_private *fep = netdev_priv(ndev);
1117
 
 
1118
 
        unregister_netdev(ndev);
1119
 
 
1120
 
        fep->ops->free_bd(ndev);
1121
 
        fep->ops->cleanup_data(ndev);
1122
 
        dev_set_drvdata(fep->dev, NULL);
1123
 
        of_node_put(fep->fpi->phy_node);
1124
 
        free_netdev(ndev);
1125
 
        return 0;
1126
 
}
1127
 
 
1128
 
static struct of_device_id fs_enet_match[] = {
1129
 
#ifdef CONFIG_FS_ENET_HAS_SCC
1130
 
        {
1131
 
                .compatible = "fsl,cpm1-scc-enet",
1132
 
                .data = (void *)&fs_scc_ops,
1133
 
        },
1134
 
        {
1135
 
                .compatible = "fsl,cpm2-scc-enet",
1136
 
                .data = (void *)&fs_scc_ops,
1137
 
        },
1138
 
#endif
1139
 
#ifdef CONFIG_FS_ENET_HAS_FCC
1140
 
        {
1141
 
                .compatible = "fsl,cpm2-fcc-enet",
1142
 
                .data = (void *)&fs_fcc_ops,
1143
 
        },
1144
 
#endif
1145
 
#ifdef CONFIG_FS_ENET_HAS_FEC
1146
 
#ifdef CONFIG_FS_ENET_MPC5121_FEC
1147
 
        {
1148
 
                .compatible = "fsl,mpc5121-fec",
1149
 
                .data = (void *)&fs_fec_ops,
1150
 
        },
1151
 
#else
1152
 
        {
1153
 
                .compatible = "fsl,pq1-fec-enet",
1154
 
                .data = (void *)&fs_fec_ops,
1155
 
        },
1156
 
#endif
1157
 
#endif
1158
 
        {}
1159
 
};
1160
 
MODULE_DEVICE_TABLE(of, fs_enet_match);
1161
 
 
1162
 
static struct platform_driver fs_enet_driver = {
1163
 
        .driver = {
1164
 
                .owner = THIS_MODULE,
1165
 
                .name = "fs_enet",
1166
 
                .of_match_table = fs_enet_match,
1167
 
        },
1168
 
        .probe = fs_enet_probe,
1169
 
        .remove = fs_enet_remove,
1170
 
};
1171
 
 
1172
 
static int __init fs_init(void)
1173
 
{
1174
 
        return platform_driver_register(&fs_enet_driver);
1175
 
}
1176
 
 
1177
 
static void __exit fs_cleanup(void)
1178
 
{
1179
 
        platform_driver_unregister(&fs_enet_driver);
1180
 
}
1181
 
 
1182
 
#ifdef CONFIG_NET_POLL_CONTROLLER
1183
 
static void fs_enet_netpoll(struct net_device *dev)
1184
 
{
1185
 
       disable_irq(dev->irq);
1186
 
       fs_enet_interrupt(dev->irq, dev);
1187
 
       enable_irq(dev->irq);
1188
 
}
1189
 
#endif
1190
 
 
1191
 
/**************************************************************************************/
1192
 
 
1193
 
module_init(fs_init);
1194
 
module_exit(fs_cleanup);