← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to drivers/net/sun3lance.c

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/sun3lance.c
 
1
/* sun3lance.c: Ethernet driver for SUN3 Lance chip */
 
2
/*
 
3
 
 
4
  Sun3 Lance ethernet driver, by Sam Creasey (sammy@users.qual.net).
 
5
  This driver is a part of the linux kernel, and is thus distributed
 
6
  under the GNU General Public License.
 
7
 
 
8
  The values used in LANCE_OBIO and LANCE_IRQ seem to be empirically
 
9
  true for the correct IRQ and address of the lance registers.  They
 
10
  have not been widely tested, however.  What we probably need is a
 
11
  "proper" way to search for a device in the sun3's prom, but, alas,
 
12
  linux has no such thing.
 
13
 
 
14
  This driver is largely based on atarilance.c, by Roman Hodek.  Other
 
15
  sources of inspiration were the NetBSD sun3 am7990 driver, and the
 
16
  linux sparc lance driver (sunlance.c).
 
17
 
 
18
  There are more assumptions made throughout this driver, it almost
 
19
  certainly still needs work, but it does work at least for RARP/BOOTP and
 
20
  mounting the root NFS filesystem.
 
21
 
 
22
*/
 
23
 
 
24
static char *version = "sun3lance.c: v1.2 1/12/2001  Sam Creasey (sammy@sammy.net)\n";
 
25
 
 
26
#include <linux/module.h>
 
27
#include <linux/stddef.h>
 
28
#include <linux/kernel.h>
 
29
#include <linux/string.h>
 
30
#include <linux/errno.h>
 
31
#include <linux/slab.h>
 
32
#include <linux/interrupt.h>
 
33
#include <linux/init.h>
 
34
#include <linux/ioport.h>
 
35
#include <linux/delay.h>
 
36
#include <linux/netdevice.h>
 
37
#include <linux/etherdevice.h>
 
38
#include <linux/skbuff.h>
 
39
#include <linux/bitops.h>
 
40
 
 
41
#include <asm/cacheflush.h>
 
42
#include <asm/setup.h>
 
43
#include <asm/irq.h>
 
44
#include <asm/io.h>
 
45
#include <asm/pgtable.h>
 
46
#include <asm/dvma.h>
 
47
#include <asm/idprom.h>
 
48
#include <asm/machines.h>
 
49
 
 
50
#ifdef CONFIG_SUN3
 
51
#include <asm/sun3mmu.h>
 
52
#else
 
53
#include <asm/sun3xprom.h>
 
54
#endif
 
55
 
 
56
/* sun3/60 addr/irq for the lance chip.  If your sun is different,
 
57
   change this. */
 
58
#define LANCE_OBIO 0x120000
 
59
#define LANCE_IRQ IRQ_AUTO_3
 
60
 
 
61
/* Debug level:
 
62
 *  0 = silent, print only serious errors
 
63
 *  1 = normal, print error messages
 
64
 *  2 = debug, print debug infos
 
65
 *  3 = debug, print even more debug infos (packet data)
 
66
 */
 
67
 
 
68
#define LANCE_DEBUG     0
 
69
 
 
70
#ifdef LANCE_DEBUG
 
71
static int lance_debug = LANCE_DEBUG;
 
72
#else
 
73
static int lance_debug = 1;
 
74
#endif
 
75
module_param(lance_debug, int, 0);
 
76
MODULE_PARM_DESC(lance_debug, "SUN3 Lance debug level (0-3)");
 
77
MODULE_LICENSE("GPL");
 
78
 
 
79
#define DPRINTK(n,a) \
 
80
        do {  \
 
81
                if (lance_debug >= n)  \
 
82
                        printk a; \
 
83
        } while( 0 )
 
84
 
 
85
 
 
86
/* we're only using 32k of memory, so we use 4 TX
 
87
   buffers and 16 RX buffers.  These values are expressed as log2. */
 
88
 
 
89
#define TX_LOG_RING_SIZE                        3
 
90
#define RX_LOG_RING_SIZE                        5
 
91
 
 
92
/* These are the derived values */
 
93
 
 
94
#define TX_RING_SIZE                    (1 << TX_LOG_RING_SIZE)
 
95
#define TX_RING_LEN_BITS                (TX_LOG_RING_SIZE << 5)
 
96
#define TX_RING_MOD_MASK                (TX_RING_SIZE - 1)
 
97
 
 
98
#define RX_RING_SIZE                    (1 << RX_LOG_RING_SIZE)
 
99
#define RX_RING_LEN_BITS                (RX_LOG_RING_SIZE << 5)
 
100
#define RX_RING_MOD_MASK                (RX_RING_SIZE - 1)
 
101
 
 
102
/* Definitions for packet buffer access: */
 
103
#define PKT_BUF_SZ              1544
 
104
 
 
105
/* Get the address of a packet buffer corresponding to a given buffer head */
 
106
#define PKTBUF_ADDR(head)       (void *)((unsigned long)(MEM) | (head)->base)
 
107
 
 
108
 
 
109
/* The LANCE Rx and Tx ring descriptors. */
 
110
struct lance_rx_head {
 
111
        unsigned short  base;           /* Low word of base addr */
 
112
        volatile unsigned char  flag;
 
113
        unsigned char  base_hi; /* High word of base addr (unused) */
 
114
        short buf_length;       /* This length is 2s complement! */
 
115
        volatile short msg_length;      /* This length is "normal". */
 
116
};
 
117
 
 
118
struct lance_tx_head {
 
119
        unsigned short base;            /* Low word of base addr */
 
120
        volatile unsigned char  flag;
 
121
        unsigned char base_hi;  /* High word of base addr (unused) */
 
122
        short length;           /* Length is 2s complement! */
 
123
        volatile short misc;
 
124
};
 
125
 
 
126
/* The LANCE initialization block, described in databook. */
 
127
struct lance_init_block {
 
128
        unsigned short  mode;           /* Pre-set mode */
 
129
        unsigned char   hwaddr[6];      /* Physical ethernet address */
 
130
        unsigned int    filter[2];      /* Multicast filter (unused). */
 
131
        /* Receive and transmit ring base, along with length bits. */
 
132
        unsigned short rdra;
 
133
        unsigned short rlen;
 
134
        unsigned short tdra;
 
135
        unsigned short tlen;
 
136
        unsigned short pad[4]; /* is thie needed? */
 
137
};
 
138
 
 
139
/* The whole layout of the Lance shared memory */
 
140
struct lance_memory {
 
141
        struct lance_init_block init;
 
142
        struct lance_tx_head    tx_head[TX_RING_SIZE];
 
143
        struct lance_rx_head    rx_head[RX_RING_SIZE];
 
144
        char   rx_data[RX_RING_SIZE][PKT_BUF_SZ];
 
145
        char   tx_data[TX_RING_SIZE][PKT_BUF_SZ];
 
146
};
 
147
 
 
148
/* The driver's private device structure */
 
149
 
 
150
struct lance_private {
 
151
        volatile unsigned short *iobase;
 
152
        struct lance_memory     *mem;
 
153
        int new_rx, new_tx;     /* The next free ring entry */
 
154
        int old_tx, old_rx;     /* ring entry to be processed */
 
155
/* These two must be longs for set_bit() */
 
156
        long        tx_full;
 
157
        long        lock;
 
158
};
 
159
 
 
160
/* I/O register access macros */
 
161
 
 
162
#define MEM     lp->mem
 
163
#define DREG    lp->iobase[0]
 
164
#define AREG    lp->iobase[1]
 
165
#define REGA(a) (*( AREG = (a), &DREG ))
 
166
 
 
167
/* Definitions for the Lance */
 
168
 
 
169
/* tx_head flags */
 
170
#define TMD1_ENP                0x01    /* end of packet */
 
171
#define TMD1_STP                0x02    /* start of packet */
 
172
#define TMD1_DEF                0x04    /* deferred */
 
173
#define TMD1_ONE                0x08    /* one retry needed */
 
174
#define TMD1_MORE               0x10    /* more than one retry needed */
 
175
#define TMD1_ERR                0x40    /* error summary */
 
176
#define TMD1_OWN                0x80    /* ownership (set: chip owns) */
 
177
 
 
178
#define TMD1_OWN_CHIP   TMD1_OWN
 
179
#define TMD1_OWN_HOST   0
 
180
 
 
181
/* tx_head misc field */
 
182
#define TMD3_TDR                0x03FF  /* Time Domain Reflectometry counter */
 
183
#define TMD3_RTRY               0x0400  /* failed after 16 retries */
 
184
#define TMD3_LCAR               0x0800  /* carrier lost */
 
185
#define TMD3_LCOL               0x1000  /* late collision */
 
186
#define TMD3_UFLO               0x4000  /* underflow (late memory) */
 
187
#define TMD3_BUFF               0x8000  /* buffering error (no ENP) */
 
188
 
 
189
/* rx_head flags */
 
190
#define RMD1_ENP                0x01    /* end of packet */
 
191
#define RMD1_STP                0x02    /* start of packet */
 
192
#define RMD1_BUFF               0x04    /* buffer error */
 
193
#define RMD1_CRC                0x08    /* CRC error */
 
194
#define RMD1_OFLO               0x10    /* overflow */
 
195
#define RMD1_FRAM               0x20    /* framing error */
 
196
#define RMD1_ERR                0x40    /* error summary */
 
197
#define RMD1_OWN                0x80    /* ownership (set: ship owns) */
 
198
 
 
199
#define RMD1_OWN_CHIP   RMD1_OWN
 
200
#define RMD1_OWN_HOST   0
 
201
 
 
202
/* register names */
 
203
#define CSR0    0               /* mode/status */
 
204
#define CSR1    1               /* init block addr (low) */
 
205
#define CSR2    2               /* init block addr (high) */
 
206
#define CSR3    3               /* misc */
 
207
#define CSR8    8               /* address filter */
 
208
#define CSR15   15              /* promiscuous mode */
 
209
 
 
210
/* CSR0 */
 
211
/* (R=readable, W=writeable, S=set on write, C=clear on write) */
 
212
#define CSR0_INIT       0x0001          /* initialize (RS) */
 
213
#define CSR0_STRT       0x0002          /* start (RS) */
 
214
#define CSR0_STOP       0x0004          /* stop (RS) */
 
215
#define CSR0_TDMD       0x0008          /* transmit demand (RS) */
 
216
#define CSR0_TXON       0x0010          /* transmitter on (R) */
 
217
#define CSR0_RXON       0x0020          /* receiver on (R) */
 
218
#define CSR0_INEA       0x0040          /* interrupt enable (RW) */
 
219
#define CSR0_INTR       0x0080          /* interrupt active (R) */
 
220
#define CSR0_IDON       0x0100          /* initialization done (RC) */
 
221
#define CSR0_TINT       0x0200          /* transmitter interrupt (RC) */
 
222
#define CSR0_RINT       0x0400          /* receiver interrupt (RC) */
 
223
#define CSR0_MERR       0x0800          /* memory error (RC) */
 
224
#define CSR0_MISS       0x1000          /* missed frame (RC) */
 
225
#define CSR0_CERR       0x2000          /* carrier error (no heartbeat :-) (RC) */
 
226
#define CSR0_BABL       0x4000          /* babble: tx-ed too many bits (RC) */
 
227
#define CSR0_ERR        0x8000          /* error (RC) */
 
228
 
 
229
/* CSR3 */
 
230
#define CSR3_BCON       0x0001          /* byte control */
 
231
#define CSR3_ACON       0x0002          /* ALE control */
 
232
#define CSR3_BSWP       0x0004          /* byte swap (1=big endian) */
 
233
 
 
234
/***************************** Prototypes *****************************/
 
235
 
 
236
static int lance_probe( struct net_device *dev);
 
237
static int lance_open( struct net_device *dev );
 
238
static void lance_init_ring( struct net_device *dev );
 
239
static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev );
 
240
static irqreturn_t lance_interrupt( int irq, void *dev_id);
 
241
static int lance_rx( struct net_device *dev );
 
242
static int lance_close( struct net_device *dev );
 
243
static void set_multicast_list( struct net_device *dev );
 
244
 
 
245
/************************* End of Prototypes **************************/
 
246
 
 
247
struct net_device * __init sun3lance_probe(int unit)
 
248
{
 
249
        struct net_device *dev;
 
250
        static int found;
 
251
        int err = -ENODEV;
 
252
 
 
253
        if (!MACH_IS_SUN3 && !MACH_IS_SUN3X)
 
254
                return ERR_PTR(-ENODEV);
 
255
 
 
256
        /* check that this machine has an onboard lance */
 
257
        switch(idprom->id_machtype) {
 
258
        case SM_SUN3|SM_3_50:
 
259
        case SM_SUN3|SM_3_60:
 
260
        case SM_SUN3X|SM_3_80:
 
261
                /* these machines have lance */
 
262
                break;
 
263
 
 
264
        default:
 
265
                return ERR_PTR(-ENODEV);
 
266
        }
 
267
 
 
268
        if (found)
 
269
                return ERR_PTR(-ENODEV);
 
270
 
 
271
        dev = alloc_etherdev(sizeof(struct lance_private));
 
272
        if (!dev)
 
273
                return ERR_PTR(-ENOMEM);
 
274
        if (unit >= 0) {
 
275
                sprintf(dev->name, "eth%d", unit);
 
276
                netdev_boot_setup_check(dev);
 
277
        }
 
278
 
 
279
        if (!lance_probe(dev))
 
280
                goto out;
 
281
 
 
282
        err = register_netdev(dev);
 
283
        if (err)
 
284
                goto out1;
 
285
        found = 1;
 
286
        return dev;
 
287
 
 
288
out1:
 
289
#ifdef CONFIG_SUN3
 
290
        iounmap((void __iomem *)dev->base_addr);
 
291
#endif
 
292
out:
 
293
        free_netdev(dev);
 
294
        return ERR_PTR(err);
 
295
}
 
296
 
 
297
static const struct net_device_ops lance_netdev_ops = {
 
298
        .ndo_open               = lance_open,
 
299
        .ndo_stop               = lance_close,
 
300
        .ndo_start_xmit         = lance_start_xmit,
 
301
        .ndo_set_multicast_list = set_multicast_list,
 
302
        .ndo_set_mac_address    = NULL,
 
303
        .ndo_change_mtu         = eth_change_mtu,
 
304
        .ndo_validate_addr      = eth_validate_addr,
 
305
};
 
306
 
 
307
static int __init lance_probe( struct net_device *dev)
 
308
{
 
309
        unsigned long ioaddr;
 
310
 
 
311
        struct lance_private    *lp;
 
312
        int                     i;
 
313
        static int              did_version;
 
314
        volatile unsigned short *ioaddr_probe;
 
315
        unsigned short tmp1, tmp2;
 
316
 
 
317
#ifdef CONFIG_SUN3
 
318
        ioaddr = (unsigned long)ioremap(LANCE_OBIO, PAGE_SIZE);
 
319
        if (!ioaddr)
 
320
                return 0;
 
321
#else
 
322
        ioaddr = SUN3X_LANCE;
 
323
#endif
 
324
 
 
325
        /* test to see if there's really a lance here */
 
326
        /* (CSRO_INIT shouldn't be readable) */
 
327
 
 
328
        ioaddr_probe = (volatile unsigned short *)ioaddr;
 
329
        tmp1 = ioaddr_probe[0];
 
330
        tmp2 = ioaddr_probe[1];
 
331
 
 
332
        ioaddr_probe[1] = CSR0;
 
333
        ioaddr_probe[0] = CSR0_INIT | CSR0_STOP;
 
334
 
 
335
        if(ioaddr_probe[0] != CSR0_STOP) {
 
336
                ioaddr_probe[0] = tmp1;
 
337
                ioaddr_probe[1] = tmp2;
 
338
 
 
339
#ifdef CONFIG_SUN3
 
340
                iounmap((void __iomem *)ioaddr);
 
341
#endif
 
342
                return 0;
 
343
        }
 
344
 
 
345
        lp = netdev_priv(dev);
 
346
 
 
347
        /* XXX - leak? */
 
348
        MEM = dvma_malloc_align(sizeof(struct lance_memory), 0x10000);
 
349
        if (MEM == NULL) {
 
350
#ifdef CONFIG_SUN3
 
351
                iounmap((void __iomem *)ioaddr);
 
352
#endif
 
353
                printk(KERN_WARNING "SUN3 Lance couldn't allocate DVMA memory\n");
 
354
                return 0;
 
355
        }
 
356
 
 
357
        lp->iobase = (volatile unsigned short *)ioaddr;
 
358
        dev->base_addr = (unsigned long)ioaddr; /* informational only */
 
359
 
 
360
        REGA(CSR0) = CSR0_STOP;
 
361
 
 
362
        if (request_irq(LANCE_IRQ, lance_interrupt, IRQF_DISABLED, "SUN3 Lance", dev) < 0) {
 
363
#ifdef CONFIG_SUN3
 
364
                iounmap((void __iomem *)ioaddr);
 
365
#endif
 
366
                dvma_free((void *)MEM);
 
367
                printk(KERN_WARNING "SUN3 Lance unable to allocate IRQ\n");
 
368
                return 0;
 
369
        }
 
370
        dev->irq = (unsigned short)LANCE_IRQ;
 
371
 
 
372
 
 
373
        printk("%s: SUN3 Lance at io %#lx, mem %#lx, irq %d, hwaddr ",
 
374
                   dev->name,
 
375
                   (unsigned long)ioaddr,
 
376
                   (unsigned long)MEM,
 
377
                   dev->irq);
 
378
 
 
379
        /* copy in the ethernet address from the prom */
 
380
        for(i = 0; i < 6 ; i++)
 
381
             dev->dev_addr[i] = idprom->id_ethaddr[i];
 
382
 
 
383
        /* tell the card it's ether address, bytes swapped */
 
384
        MEM->init.hwaddr[0] = dev->dev_addr[1];
 
385
        MEM->init.hwaddr[1] = dev->dev_addr[0];
 
386
        MEM->init.hwaddr[2] = dev->dev_addr[3];
 
387
        MEM->init.hwaddr[3] = dev->dev_addr[2];
 
388
        MEM->init.hwaddr[4] = dev->dev_addr[5];
 
389
        MEM->init.hwaddr[5] = dev->dev_addr[4];
 
390
 
 
391
        printk("%pM\n", dev->dev_addr);
 
392
 
 
393
        MEM->init.mode = 0x0000;
 
394
        MEM->init.filter[0] = 0x00000000;
 
395
        MEM->init.filter[1] = 0x00000000;
 
396
        MEM->init.rdra = dvma_vtob(MEM->rx_head);
 
397
        MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
 
398
                (dvma_vtob(MEM->rx_head) >> 16);
 
399
        MEM->init.tdra = dvma_vtob(MEM->tx_head);
 
400
        MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
 
401
                (dvma_vtob(MEM->tx_head) >> 16);
 
402
 
 
403
        DPRINTK(2, ("initaddr: %08lx rx_ring: %08lx tx_ring: %08lx\n",
 
404
               dvma_vtob(&(MEM->init)), dvma_vtob(MEM->rx_head),
 
405
               (dvma_vtob(MEM->tx_head))));
 
406
 
 
407
        if (did_version++ == 0)
 
408
                printk( version );
 
409
 
 
410
        dev->netdev_ops = &lance_netdev_ops;
 
411
//      KLUDGE -- REMOVE ME
 
412
        set_bit(__LINK_STATE_PRESENT, &dev->state);
 
413
 
 
414
 
 
415
        return 1;
 
416
}
 
417
 
 
418
static int lance_open( struct net_device *dev )
 
419
{
 
420
        struct lance_private *lp = netdev_priv(dev);
 
421
        int i;
 
422
 
 
423
        DPRINTK( 2, ( "%s: lance_open()\n", dev->name ));
 
424
 
 
425
        REGA(CSR0) = CSR0_STOP;
 
426
 
 
427
        lance_init_ring(dev);
 
428
 
 
429
        /* From now on, AREG is kept to point to CSR0 */
 
430
        REGA(CSR0) = CSR0_INIT;
 
431
 
 
432
        i = 1000000;
 
433
        while (--i > 0)
 
434
                if (DREG & CSR0_IDON)
 
435
                        break;
 
436
        if (i <= 0 || (DREG & CSR0_ERR)) {
 
437
                DPRINTK( 2, ( "lance_open(): opening %s failed, i=%d, csr0=%04x\n",
 
438
                                          dev->name, i, DREG ));
 
439
                DREG = CSR0_STOP;
 
440
                return( -EIO );
 
441
        }
 
442
 
 
443
        DREG = CSR0_IDON | CSR0_STRT | CSR0_INEA;
 
444
 
 
445
        netif_start_queue(dev);
 
446
 
 
447
        DPRINTK( 2, ( "%s: LANCE is open, csr0 %04x\n", dev->name, DREG ));
 
448
 
 
449
        return( 0 );
 
450
}
 
451
 
 
452
 
 
453
/* Initialize the LANCE Rx and Tx rings. */
 
454
 
 
455
static void lance_init_ring( struct net_device *dev )
 
456
{
 
457
        struct lance_private *lp = netdev_priv(dev);
 
458
        int i;
 
459
 
 
460
        lp->lock = 0;
 
461
        lp->tx_full = 0;
 
462
        lp->new_rx = lp->new_tx = 0;
 
463
        lp->old_rx = lp->old_tx = 0;
 
464
 
 
465
        for( i = 0; i < TX_RING_SIZE; i++ ) {
 
466
                MEM->tx_head[i].base = dvma_vtob(MEM->tx_data[i]);
 
467
                MEM->tx_head[i].flag = 0;
 
468
                MEM->tx_head[i].base_hi =
 
469
                        (dvma_vtob(MEM->tx_data[i])) >>16;
 
470
                MEM->tx_head[i].length = 0;
 
471
                MEM->tx_head[i].misc = 0;
 
472
        }
 
473
 
 
474
        for( i = 0; i < RX_RING_SIZE; i++ ) {
 
475
                MEM->rx_head[i].base = dvma_vtob(MEM->rx_data[i]);
 
476
                MEM->rx_head[i].flag = RMD1_OWN_CHIP;
 
477
                MEM->rx_head[i].base_hi =
 
478
                        (dvma_vtob(MEM->rx_data[i])) >> 16;
 
479
                MEM->rx_head[i].buf_length = -PKT_BUF_SZ | 0xf000;
 
480
                MEM->rx_head[i].msg_length = 0;
 
481
        }
 
482
 
 
483
        /* tell the card it's ether address, bytes swapped */
 
484
        MEM->init.hwaddr[0] = dev->dev_addr[1];
 
485
        MEM->init.hwaddr[1] = dev->dev_addr[0];
 
486
        MEM->init.hwaddr[2] = dev->dev_addr[3];
 
487
        MEM->init.hwaddr[3] = dev->dev_addr[2];
 
488
        MEM->init.hwaddr[4] = dev->dev_addr[5];
 
489
        MEM->init.hwaddr[5] = dev->dev_addr[4];
 
490
 
 
491
        MEM->init.mode = 0x0000;
 
492
        MEM->init.filter[0] = 0x00000000;
 
493
        MEM->init.filter[1] = 0x00000000;
 
494
        MEM->init.rdra = dvma_vtob(MEM->rx_head);
 
495
        MEM->init.rlen    = (RX_LOG_RING_SIZE << 13) |
 
496
                (dvma_vtob(MEM->rx_head) >> 16);
 
497
        MEM->init.tdra = dvma_vtob(MEM->tx_head);
 
498
        MEM->init.tlen    = (TX_LOG_RING_SIZE << 13) |
 
499
                (dvma_vtob(MEM->tx_head) >> 16);
 
500
 
 
501
 
 
502
        /* tell the lance the address of its init block */
 
503
        REGA(CSR1) = dvma_vtob(&(MEM->init));
 
504
        REGA(CSR2) = dvma_vtob(&(MEM->init)) >> 16;
 
505
 
 
506
#ifdef CONFIG_SUN3X
 
507
        REGA(CSR3) = CSR3_BSWP | CSR3_ACON | CSR3_BCON;
 
508
#else
 
509
        REGA(CSR3) = CSR3_BSWP;
 
510
#endif
 
511
 
 
512
}
 
513
 
 
514
 
 
515
static int lance_start_xmit( struct sk_buff *skb, struct net_device *dev )
 
516
{
 
517
        struct lance_private *lp = netdev_priv(dev);
 
518
        int entry, len;
 
519
        struct lance_tx_head *head;
 
520
        unsigned long flags;
 
521
 
 
522
        DPRINTK( 1, ( "%s: transmit start.\n",
 
523
                      dev->name));
 
524
 
 
525
        /* Transmitter timeout, serious problems. */
 
526
        if (netif_queue_stopped(dev)) {
 
527
                int tickssofar = jiffies - dev->trans_start;
 
528
                if (tickssofar < 20)
 
529
                        return NETDEV_TX_BUSY;
 
530
 
 
531
                DPRINTK( 1, ( "%s: transmit timed out, status %04x, resetting.\n",
 
532
                                          dev->name, DREG ));
 
533
                DREG = CSR0_STOP;
 
534
                /*
 
535
                 * Always set BSWP after a STOP as STOP puts it back into
 
536
                 * little endian mode.
 
537
                 */
 
538
                REGA(CSR3) = CSR3_BSWP;
 
539
                dev->stats.tx_errors++;
 
540
 
 
541
                if(lance_debug >= 2) {
 
542
                        int i;
 
543
                        printk("Ring data: old_tx %d new_tx %d%s new_rx %d\n",
 
544
                               lp->old_tx, lp->new_tx,
 
545
                               lp->tx_full ? " (full)" : "",
 
546
                               lp->new_rx );
 
547
                        for( i = 0 ; i < RX_RING_SIZE; i++ )
 
548
                                printk( "rx #%d: base=%04x blen=%04x mlen=%04x\n",
 
549
                                        i, MEM->rx_head[i].base,
 
550
                                        -MEM->rx_head[i].buf_length,
 
551
                                        MEM->rx_head[i].msg_length);
 
552
                        for( i = 0 ; i < TX_RING_SIZE; i++ )
 
553
                                printk("tx #%d: base=%04x len=%04x misc=%04x\n",
 
554
                                       i, MEM->tx_head[i].base,
 
555
                                       -MEM->tx_head[i].length,
 
556
                                       MEM->tx_head[i].misc );
 
557
                }
 
558
 
 
559
                lance_init_ring(dev);
 
560
                REGA( CSR0 ) = CSR0_INEA | CSR0_INIT | CSR0_STRT;
 
561
 
 
562
                netif_start_queue(dev);
 
563
                dev->trans_start = jiffies;
 
564
 
 
565
                return NETDEV_TX_OK;
 
566
        }
 
567
 
 
568
 
 
569
        /* Block a timer-based transmit from overlapping.  This could better be
 
570
           done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 
571
 
 
572
        /* Block a timer-based transmit from overlapping with us by
 
573
           stopping the queue for a bit... */
 
574
 
 
575
        netif_stop_queue(dev);
 
576
 
 
577
        if (test_and_set_bit( 0, (void*)&lp->lock ) != 0) {
 
578
                printk( "%s: tx queue lock!.\n", dev->name);
 
579
                /* don't clear dev->tbusy flag. */
 
580
                return NETDEV_TX_BUSY;
 
581
        }
 
582
 
 
583
        AREG = CSR0;
 
584
        DPRINTK( 2, ( "%s: lance_start_xmit() called, csr0 %4.4x.\n",
 
585
                                  dev->name, DREG ));
 
586
 
 
587
#ifdef CONFIG_SUN3X
 
588
        /* this weirdness doesn't appear on sun3... */
 
589
        if(!(DREG & CSR0_INIT)) {
 
590
                DPRINTK( 1, ("INIT not set, reinitializing...\n"));
 
591
                REGA( CSR0 ) = CSR0_STOP;
 
592
                lance_init_ring(dev);
 
593
                REGA( CSR0 ) = CSR0_INIT | CSR0_STRT;
 
594
        }
 
595
#endif
 
596
 
 
597
        /* Fill in a Tx ring entry */
 
598
#if 0
 
599
        if (lance_debug >= 2) {
 
600
                printk( "%s: TX pkt %d type 0x%04x"
 
601
                        " from %s to %s"
 
602
                        " data at 0x%08x len %d\n",
 
603
                        dev->name, lp->new_tx, ((u_short *)skb->data)[6],
 
604
                        DEV_ADDR(&skb->data[6]), DEV_ADDR(skb->data),
 
605
                        (int)skb->data, (int)skb->len );
 
606
        }
 
607
#endif
 
608
        /* We're not prepared for the int until the last flags are set/reset.
 
609
         * And the int may happen already after setting the OWN_CHIP... */
 
610
        local_irq_save(flags);
 
611
 
 
612
        /* Mask to ring buffer boundary. */
 
613
        entry = lp->new_tx;
 
614
        head  = &(MEM->tx_head[entry]);
 
615
 
 
616
        /* Caution: the write order is important here, set the "ownership" bits
 
617
         * last.
 
618
         */
 
619
 
 
620
        /* the sun3's lance needs it's buffer padded to the minimum
 
621
           size */
 
622
        len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
 
623
 
 
624
//      head->length = -len;
 
625
        head->length = (-len) | 0xf000;
 
626
        head->misc = 0;
 
627
 
 
628
        skb_copy_from_linear_data(skb, PKTBUF_ADDR(head), skb->len);
 
629
        if (len != skb->len)
 
630
                memset(PKTBUF_ADDR(head) + skb->len, 0, len-skb->len);
 
631
 
 
632
        head->flag = TMD1_OWN_CHIP | TMD1_ENP | TMD1_STP;
 
633
        lp->new_tx = (lp->new_tx + 1) & TX_RING_MOD_MASK;
 
634
        dev->stats.tx_bytes += skb->len;
 
635
 
 
636
        /* Trigger an immediate send poll. */
 
637
        REGA(CSR0) = CSR0_INEA | CSR0_TDMD | CSR0_STRT;
 
638
        AREG = CSR0;
 
639
        DPRINTK( 2, ( "%s: lance_start_xmit() exiting, csr0 %4.4x.\n",
 
640
                                  dev->name, DREG ));
 
641
        dev->trans_start = jiffies;
 
642
        dev_kfree_skb( skb );
 
643
 
 
644
        lp->lock = 0;
 
645
        if ((MEM->tx_head[(entry+1) & TX_RING_MOD_MASK].flag & TMD1_OWN) ==
 
646
            TMD1_OWN_HOST)
 
647
                netif_start_queue(dev);
 
648
 
 
649
        local_irq_restore(flags);
 
650
 
 
651
        return NETDEV_TX_OK;
 
652
}
 
653
 
 
654
/* The LANCE interrupt handler. */
 
655
 
 
656
static irqreturn_t lance_interrupt( int irq, void *dev_id)
 
657
{
 
658
        struct net_device *dev = dev_id;
 
659
        struct lance_private *lp = netdev_priv(dev);
 
660
        int csr0;
 
661
        static int in_interrupt;
 
662
 
 
663
        if (dev == NULL) {
 
664
                DPRINTK( 1, ( "lance_interrupt(): invalid dev_id\n" ));
 
665
                return IRQ_NONE;
 
666
        }
 
667
 
 
668
        if (in_interrupt)
 
669
                DPRINTK( 2, ( "%s: Re-entering the interrupt handler.\n", dev->name ));
 
670
        in_interrupt = 1;
 
671
 
 
672
 still_more:
 
673
        flush_cache_all();
 
674
 
 
675
        AREG = CSR0;
 
676
        csr0 = DREG;
 
677
 
 
678
        /* ack interrupts */
 
679
        DREG = csr0 & (CSR0_TINT | CSR0_RINT | CSR0_IDON);
 
680
 
 
681
        /* clear errors */
 
682
        if(csr0 & CSR0_ERR)
 
683
                DREG = CSR0_BABL | CSR0_MERR | CSR0_CERR | CSR0_MISS;
 
684
 
 
685
 
 
686
        DPRINTK( 2, ( "%s: interrupt  csr0=%04x new csr=%04x.\n",
 
687
                      dev->name, csr0, DREG ));
 
688
 
 
689
        if (csr0 & CSR0_TINT) {                 /* Tx-done interrupt */
 
690
                int old_tx = lp->old_tx;
 
691
 
 
692
//              if(lance_debug >= 3) {
 
693
//                      int i;
 
694
//
 
695
//                      printk("%s: tx int\n", dev->name);
 
696
//
 
697
//                      for(i = 0; i < TX_RING_SIZE; i++)
 
698
//                              printk("ring %d flag=%04x\n", i,
 
699
//                                     MEM->tx_head[i].flag);
 
700
//              }
 
701
 
 
702
                while( old_tx != lp->new_tx) {
 
703
                        struct lance_tx_head *head = &(MEM->tx_head[old_tx]);
 
704
 
 
705
                        DPRINTK(3, ("on tx_ring %d\n", old_tx));
 
706
 
 
707
                        if (head->flag & TMD1_OWN_CHIP)
 
708
                                break; /* It still hasn't been Txed */
 
709
 
 
710
                        if (head->flag & TMD1_ERR) {
 
711
                                int status = head->misc;
 
712
                                dev->stats.tx_errors++;
 
713
                                if (status & TMD3_RTRY) dev->stats.tx_aborted_errors++;
 
714
                                if (status & TMD3_LCAR) dev->stats.tx_carrier_errors++;
 
715
                                if (status & TMD3_LCOL) dev->stats.tx_window_errors++;
 
716
                                if (status & (TMD3_UFLO | TMD3_BUFF)) {
 
717
                                        dev->stats.tx_fifo_errors++;
 
718
                                        printk("%s: Tx FIFO error\n",
 
719
                                               dev->name);
 
720
                                        REGA(CSR0) = CSR0_STOP;
 
721
                                        REGA(CSR3) = CSR3_BSWP;
 
722
                                        lance_init_ring(dev);
 
723
                                        REGA(CSR0) = CSR0_STRT | CSR0_INEA;
 
724
                                        return IRQ_HANDLED;
 
725
                                }
 
726
                        } else if(head->flag & (TMD1_ENP | TMD1_STP)) {
 
727
 
 
728
                                head->flag &= ~(TMD1_ENP | TMD1_STP);
 
729
                                if(head->flag & (TMD1_ONE | TMD1_MORE))
 
730
                                        dev->stats.collisions++;
 
731
 
 
732
                                dev->stats.tx_packets++;
 
733
                                DPRINTK(3, ("cleared tx ring %d\n", old_tx));
 
734
                        }
 
735
                        old_tx = (old_tx +1) & TX_RING_MOD_MASK;
 
736
                }
 
737
 
 
738
                lp->old_tx = old_tx;
 
739
        }
 
740
 
 
741
 
 
742
        if (netif_queue_stopped(dev)) {
 
743
                /* The ring is no longer full, clear tbusy. */
 
744
                netif_start_queue(dev);
 
745
                netif_wake_queue(dev);
 
746
        }
 
747
 
 
748
        if (csr0 & CSR0_RINT)                   /* Rx interrupt */
 
749
                lance_rx( dev );
 
750
 
 
751
        /* Log misc errors. */
 
752
        if (csr0 & CSR0_BABL) dev->stats.tx_errors++; /* Tx babble. */
 
753
        if (csr0 & CSR0_MISS) dev->stats.rx_errors++; /* Missed a Rx frame. */
 
754
        if (csr0 & CSR0_MERR) {
 
755
                DPRINTK( 1, ( "%s: Bus master arbitration failure (?!?), "
 
756
                              "status %04x.\n", dev->name, csr0 ));
 
757
                /* Restart the chip. */
 
758
                REGA(CSR0) = CSR0_STOP;
 
759
                REGA(CSR3) = CSR3_BSWP;
 
760
                lance_init_ring(dev);
 
761
                REGA(CSR0) = CSR0_STRT | CSR0_INEA;
 
762
        }
 
763
 
 
764
 
 
765
    /* Clear any other interrupt, and set interrupt enable. */
 
766
//      DREG = CSR0_BABL | CSR0_CERR | CSR0_MISS | CSR0_MERR |
 
767
//                 CSR0_IDON | CSR0_INEA;
 
768
 
 
769
        REGA(CSR0) = CSR0_INEA;
 
770
 
 
771
        if(DREG & (CSR0_RINT | CSR0_TINT)) {
 
772
             DPRINTK(2, ("restarting interrupt, csr0=%#04x\n", DREG));
 
773
             goto still_more;
 
774
        }
 
775
 
 
776
        DPRINTK( 2, ( "%s: exiting interrupt, csr0=%#04x.\n",
 
777
                                  dev->name, DREG ));
 
778
        in_interrupt = 0;
 
779
        return IRQ_HANDLED;
 
780
}
 
781
 
 
782
/* get packet, toss into skbuff */
 
783
static int lance_rx( struct net_device *dev )
 
784
{
 
785
        struct lance_private *lp = netdev_priv(dev);
 
786
        int entry = lp->new_rx;
 
787
 
 
788
        /* If we own the next entry, it's a new packet. Send it up. */
 
789
        while( (MEM->rx_head[entry].flag & RMD1_OWN) == RMD1_OWN_HOST ) {
 
790
                struct lance_rx_head *head = &(MEM->rx_head[entry]);
 
791
                int status = head->flag;
 
792
 
 
793
                if (status != (RMD1_ENP|RMD1_STP)) {  /* There was an error. */
 
794
                        /* There is a tricky error noted by John Murphy,
 
795
                           <murf@perftech.com> to Russ Nelson: Even with
 
796
                           full-sized buffers it's possible for a jabber packet to use two
 
797
                           buffers, with only the last correctly noting the error. */
 
798
                        if (status & RMD1_ENP)  /* Only count a general error at the */
 
799
                                dev->stats.rx_errors++; /* end of a packet.*/
 
800
                        if (status & RMD1_FRAM) dev->stats.rx_frame_errors++;
 
801
                        if (status & RMD1_OFLO) dev->stats.rx_over_errors++;
 
802
                        if (status & RMD1_CRC) dev->stats.rx_crc_errors++;
 
803
                        if (status & RMD1_BUFF) dev->stats.rx_fifo_errors++;
 
804
                        head->flag &= (RMD1_ENP|RMD1_STP);
 
805
                } else {
 
806
                        /* Malloc up new buffer, compatible with net-3. */
 
807
//                      short pkt_len = head->msg_length;// & 0xfff;
 
808
                        short pkt_len = (head->msg_length & 0xfff) - 4;
 
809
                        struct sk_buff *skb;
 
810
 
 
811
                        if (pkt_len < 60) {
 
812
                                printk( "%s: Runt packet!\n", dev->name );
 
813
                                dev->stats.rx_errors++;
 
814
                        }
 
815
                        else {
 
816
                                skb = dev_alloc_skb( pkt_len+2 );
 
817
                                if (skb == NULL) {
 
818
                                        DPRINTK( 1, ( "%s: Memory squeeze, deferring packet.\n",
 
819
                                                      dev->name ));
 
820
 
 
821
                                        dev->stats.rx_dropped++;
 
822
                                        head->msg_length = 0;
 
823
                                        head->flag |= RMD1_OWN_CHIP;
 
824
                                        lp->new_rx = (lp->new_rx+1) &
 
825
                                             RX_RING_MOD_MASK;
 
826
                                }
 
827
 
 
828
#if 0
 
829
                                if (lance_debug >= 3) {
 
830
                                        u_char *data = PKTBUF_ADDR(head);
 
831
                                        printk("%s: RX pkt %d type 0x%04x"
 
832
                                               " from %pM to %pM",
 
833
                                               dev->name, lp->new_tx, ((u_short *)data)[6],
 
834
                                               &data[6], data);
 
835
 
 
836
                                        printk(" data %02x %02x %02x %02x %02x %02x %02x %02x "
 
837
                                               "len %d at %08x\n",
 
838
                                               data[15], data[16], data[17], data[18],
 
839
                                               data[19], data[20], data[21], data[22],
 
840
                                               pkt_len, data);
 
841
                                }
 
842
#endif
 
843
                                if (lance_debug >= 3) {
 
844
                                        u_char *data = PKTBUF_ADDR(head);
 
845
                                        printk( "%s: RX pkt %d type 0x%04x len %d\n ", dev->name, entry, ((u_short *)data)[6], pkt_len);
 
846
                                }
 
847
 
 
848
 
 
849
                                skb_reserve( skb, 2 );  /* 16 byte align */
 
850
                                skb_put( skb, pkt_len );        /* Make room */
 
851
                                skb_copy_to_linear_data(skb,
 
852
                                                 PKTBUF_ADDR(head),
 
853
                                                 pkt_len);
 
854
 
 
855
                                skb->protocol = eth_type_trans( skb, dev );
 
856
                                netif_rx( skb );
 
857
                                dev->stats.rx_packets++;
 
858
                                dev->stats.rx_bytes += pkt_len;
 
859
                        }
 
860
                }
 
861
 
 
862
//              head->buf_length = -PKT_BUF_SZ | 0xf000;
 
863
                head->msg_length = 0;
 
864
                head->flag = RMD1_OWN_CHIP;
 
865
 
 
866
                entry = lp->new_rx = (lp->new_rx +1) & RX_RING_MOD_MASK;
 
867
        }
 
868
 
 
869
        /* From lance.c (Donald Becker): */
 
870
        /* We should check that at least two ring entries are free.
 
871
           If not, we should free one and mark stats->rx_dropped++. */
 
872
 
 
873
        return 0;
 
874
}
 
875
 
 
876
 
 
877
static int lance_close( struct net_device *dev )
 
878
{
 
879
        struct lance_private *lp = netdev_priv(dev);
 
880
 
 
881
        netif_stop_queue(dev);
 
882
 
 
883
        AREG = CSR0;
 
884
 
 
885
        DPRINTK( 2, ( "%s: Shutting down ethercard, status was %2.2x.\n",
 
886
                                  dev->name, DREG ));
 
887
 
 
888
        /* We stop the LANCE here -- it occasionally polls
 
889
           memory if we don't. */
 
890
        DREG = CSR0_STOP;
 
891
        return 0;
 
892
}
 
893
 
 
894
 
 
895
/* Set or clear the multicast filter for this adaptor.
 
896
   num_addrs == -1              Promiscuous mode, receive all packets
 
897
   num_addrs == 0               Normal mode, clear multicast list
 
898
   num_addrs > 0                Multicast mode, receive normal and MC packets, and do
 
899
                                                best-effort filtering.
 
900
 */
 
901
 
 
902
/* completely untested on a sun3 */
 
903
static void set_multicast_list( struct net_device *dev )
 
904
{
 
905
        struct lance_private *lp = netdev_priv(dev);
 
906
 
 
907
        if(netif_queue_stopped(dev))
 
908
                /* Only possible if board is already started */
 
909
                return;
 
910
 
 
911
        /* We take the simple way out and always enable promiscuous mode. */
 
912
        DREG = CSR0_STOP; /* Temporarily stop the lance. */
 
913
 
 
914
        if (dev->flags & IFF_PROMISC) {
 
915
                /* Log any net taps. */
 
916
                DPRINTK( 3, ( "%s: Promiscuous mode enabled.\n", dev->name ));
 
917
                REGA( CSR15 ) = 0x8000; /* Set promiscuous mode */
 
918
        } else {
 
919
                short multicast_table[4];
 
920
                int num_addrs = dev->mc_count;
 
921
                int i;
 
922
                /* We don't use the multicast table, but rely on upper-layer
 
923
                 * filtering. */
 
924
                memset( multicast_table, (num_addrs == 0) ? 0 : -1,
 
925
                                sizeof(multicast_table) );
 
926
                for( i = 0; i < 4; i++ )
 
927
                        REGA( CSR8+i ) = multicast_table[i];
 
928
                REGA( CSR15 ) = 0; /* Unset promiscuous mode */
 
929
        }
 
930
 
 
931
        /*
 
932
         * Always set BSWP after a STOP as STOP puts it back into
 
933
         * little endian mode.
 
934
         */
 
935
        REGA( CSR3 ) = CSR3_BSWP;
 
936
 
 
937
        /* Resume normal operation and reset AREG to CSR0 */
 
938
        REGA( CSR0 ) = CSR0_IDON | CSR0_INEA | CSR0_STRT;
 
939
}
 
940
 
 
941
 
 
942
#ifdef MODULE
 
943
 
 
944
static struct net_device *sun3lance_dev;
 
945
 
 
946
int __init init_module(void)
 
947
{
 
948
        sun3lance_dev = sun3lance_probe(-1);
 
949
        if (IS_ERR(sun3lance_dev))
 
950
                return PTR_ERR(sun3lance_dev);
 
951
        return 0;
 
952
}
 
953
 
 
954
void __exit cleanup_module(void)
 
955
{
 
956
        unregister_netdev(sun3lance_dev);
 
957
#ifdef CONFIG_SUN3
 
958
        iounmap((void __iomem *)sun3lance_dev->base_addr);
 
959
#endif
 
960
        free_netdev(sun3lance_dev);
 
961
}
 
962
 
 
963
#endif /* MODULE */
 
964