![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to depca.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to depca.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: /* depca.c: A DIGITAL DEPCA & EtherWORKS ethernet driver for linux.
2:
3: Written 1994, 1995 by David C. Davies.
4:
5:
6: Copyright 1994 David C. Davies
7: and
8: United States Government
9: (as represented by the Director, National Security Agency).
10:
11: Copyright 1995 Digital Equipment Corporation.
12:
13:
14: This software may be used and distributed according to the terms of
15: the GNU Public License, incorporated herein by reference.
16:
17: This driver is written for the Digital Equipment Corporation series
18: of DEPCA and EtherWORKS ethernet cards:
19:
20: DEPCA (the original)
21: DE100
22: DE101
23: DE200 Turbo
24: DE201 Turbo
25: DE202 Turbo (TP BNC)
26: DE210
27: DE422 (EISA)
28:
29: The driver has been tested on DE100, DE200 and DE202 cards in a
30: relatively busy network. The DE422 has been tested a little.
31:
32: This driver will NOT work for the DE203, DE204 and DE205 series of
33: cards, since they have a new custom ASIC in place of the AMD LANCE
34: chip. See the 'ewrk3.c' driver in the Linux source tree for running
35: those cards.
36:
37: I have benchmarked the driver with a DE100 at 595kB/s to (542kB/s from)
38: a DECstation 5000/200.
39:
40: The author may be reached at [email protected]
41:
42: =========================================================================
43:
44: The driver was originally based on the 'lance.c' driver from Donald
45: Becker which is included with the standard driver distribution for
46: linux. V0.4 is a complete re-write with only the kernel interface
47: remaining from the original code.
48:
49: 1) Lance.c code in /linux/drivers/net/
50: 2) "Ethernet/IEEE 802.3 Family. 1992 World Network Data Book/Handbook",
51: AMD, 1992 [(800) 222-9323].
52: 3) "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)",
53: AMD, Pub. #17881, May 1993.
54: 4) "Am79C960 PCnet-ISA(tm), Single-Chip Ethernet Controller for ISA",
55: AMD, Pub. #16907, May 1992
56: 5) "DEC EtherWORKS LC Ethernet Controller Owners Manual",
57: Digital Equipment corporation, 1990, Pub. #EK-DE100-OM.003
58: 6) "DEC EtherWORKS Turbo Ethernet Controller Owners Manual",
59: Digital Equipment corporation, 1990, Pub. #EK-DE200-OM.003
60: 7) "DEPCA Hardware Reference Manual", Pub. #EK-DEPCA-PR
61: Digital Equipment Corporation, 1989
62: 8) "DEC EtherWORKS Turbo_(TP BNC) Ethernet Controller Owners Manual",
63: Digital Equipment corporation, 1991, Pub. #EK-DE202-OM.001
64:
65:
66: Peter Bauer's depca.c (V0.5) was referred to when debugging V0.1 of this
67: driver.
68:
69: The original DEPCA card requires that the ethernet ROM address counter
70: be enabled to count and has an 8 bit NICSR. The ROM counter enabling is
71: only done when a 0x08 is read as the first address octet (to minimise
72: the chances of writing over some other hardware's I/O register). The
73: NICSR accesses have been changed to byte accesses for all the cards
74: supported by this driver, since there is only one useful bit in the MSB
75: (remote boot timeout) and it is not used. Also, there is a maximum of
76: only 48kB network RAM for this card. My thanks to Torbjorn Lindh for
77: help debugging all this (and holding my feet to the fire until I got it
78: right).
79:
80: The DE200 series boards have on-board 64kB RAM for use as a shared
81: memory network buffer. Only the DE100 cards make use of a 2kB buffer
82: mode which has not been implemented in this driver (only the 32kB and
83: 64kB modes are supported [16kB/48kB for the original DEPCA]).
84:
85: At the most only 2 DEPCA cards can be supported on the ISA bus because
86: there is only provision for two I/O base addresses on each card (0x300
87: and 0x200). The I/O address is detected by searching for a byte sequence
88: in the Ethernet station address PROM at the expected I/O address for the
89: Ethernet PROM. The shared memory base address is 'autoprobed' by
90: looking for the self test PROM and detecting the card name. When a
91: second DEPCA is detected, information is placed in the base_addr
92: variable of the next device structure (which is created if necessary),
93: thus enabling ethif_probe initialization for the device. More than 2
94: EISA cards can be supported, but care will be needed assigning the
95: shared memory to ensure that each slot has the correct IRQ, I/O address
96: and shared memory address assigned.
97:
98: ************************************************************************
99:
100: NOTE: If you are using two ISA DEPCAs, it is important that you assign
101: the base memory addresses correctly. The driver autoprobes I/O 0x300
102: then 0x200. The base memory address for the first device must be less
103: than that of the second so that the auto probe will correctly assign the
104: I/O and memory addresses on the same card. I can't think of a way to do
105: this unambiguously at the moment, since there is nothing on the cards to
106: tie I/O and memory information together.
107:
108: I am unable to test 2 cards together for now, so this code is
109: unchecked. All reports, good or bad, are welcome.
110:
111: ************************************************************************
112:
113: The board IRQ setting must be at an unused IRQ which is auto-probed
114: using Donald Becker's autoprobe routines. DEPCA and DE100 board IRQs are
115: {2,3,4,5,7}, whereas the DE200 is at {5,9,10,11,15}. Note that IRQ2 is
116: really IRQ9 in machines with 16 IRQ lines.
117:
118: No 16MB memory limitation should exist with this driver as DMA is not
119: used and the common memory area is in low memory on the network card (my
120: current system has 20MB and I've not had problems yet).
121:
122: The ability to load this driver as a loadable module has been added. To
123: utilise this ability, you have to do <8 things:
124:
125: 0) have a copy of the loadable modules code installed on your system.
126: 1) copy depca.c from the /linux/drivers/net directory to your favourite
127: temporary directory.
128: 2) if you wish, edit the source code near line 1530 to reflect the I/O
129: address and IRQ you're using (see also 5).
130: 3) compile depca.c, but include -DMODULE in the command line to ensure
131: that the correct bits are compiled (see end of source code).
132: 4) if you are wanting to add a new card, goto 5. Otherwise, recompile a
133: kernel with the depca configuration turned off and reboot.
134: 5) insmod depca.o [irq=7] [io=0x200] [mem=0xd0000] [adapter_name=DE100]
135: [Alan Cox: Changed the code to allow command line irq/io assignments]
136: [Dave Davies: Changed the code to allow command line mem/name
137: assignments]
138: 6) run the net startup bits for your eth?? interface manually
139: (usually /etc/rc.inet[12] at boot time).
140: 7) enjoy!
141:
142: Note that autoprobing is not allowed in loadable modules - the system is
143: already up and running and you're messing with interrupts.
144:
145: To unload a module, turn off the associated interface
146: 'ifconfig eth?? down' then 'rmmod depca'.
147:
148: To assign a base memory address for the shared memory when running as a
149: loadable module, see 5 above. To include the adapter name (if you have
150: no PROM but know the card name) also see 5 above. Note that this last
151: option will not work with kernel built-in depca's.
152:
153: The shared memory assignment for a loadable module makes sense to avoid
154: the 'memory autoprobe' picking the wrong shared memory (for the case of
155: 2 depca's in a PC).
156:
157:
158: TO DO:
159: ------
160:
161:
162: Revision History
163: ----------------
164:
165: Version Date Description
166:
167: 0.1 25-jan-94 Initial writing.
168: 0.2 27-jan-94 Added LANCE TX hardware buffer chaining.
169: 0.3 1-feb-94 Added multiple DEPCA support.
170: 0.31 4-feb-94 Added DE202 recognition.
171: 0.32 19-feb-94 Tidy up. Improve multi-DEPCA support.
172: 0.33 25-feb-94 Fix DEPCA ethernet ROM counter enable.
173: Add jabber packet fix from [email protected]
174: and [email protected]
175: 0.34 7-mar-94 Fix DEPCA max network memory RAM & NICSR access.
176: 0.35 8-mar-94 Added DE201 recognition. Tidied up.
177: 0.351 30-apr-94 Added EISA support. Added DE422 recognition.
178: 0.36 16-may-94 DE422 fix released.
179: 0.37 22-jul-94 Added MODULE support
180: 0.38 15-aug-94 Added DBR ROM switch in depca_close().
181: Multi DEPCA bug fix.
182: 0.38axp 15-sep-94 Special version for Alpha AXP Linux V1.0.
183: 0.381 12-dec-94 Added DE101 recognition, fix multicast bug.
184: 0.382 9-feb-95 Fix recognition bug reported by <[email protected]>.
185: 0.383 22-feb-95 Fix for conflict with VESA SCSI reported by
186: <[email protected]>
187: 0.384 17-mar-95 Fix a ring full bug reported by <[email protected]>
188: 0.385 3-apr-95 Fix a recognition bug reported by
189: <[email protected]>
190: 0.386 21-apr-95 Fix the last fix...sorry, must be galloping senility
191: 0.40 25-May-95 Rewrite for portability & updated.
192: ALPHA support from <[email protected]>
193: 0.41 26-Jun-95 Added verify_area() calls in depca_ioctl() from
194: suggestion by <[email protected]>
195: 0.42 27-Dec-95 Add 'mem' shared memory assignment for loadable
196: modules.
197: Add 'adapter_name' for loadable modules when no PROM.
198: Both above from a suggestion by
199: <[email protected]>.
200: Add new multicasting code.
201: 0.421 22-Apr-96 Fix alloc_device() bug <[email protected]>
202: 0.422 29-Apr-96 Fix depca_hw_init() bug <[email protected]>
203: 0.423 7-Jun-96 Fix module load bug <[email protected]>
204: 0.43 16-Aug-96 Update alloc_device() to conform to de4x5.c
205:
206: =========================================================================
207: */
208:
209: static const char *version = "depca.c:v0.43 96/8/16 [email protected]\n";
210:
211: #include <linux/module.h>
212:
213: #include <linux/kernel.h>
214: #include <linux/sched.h>
215: #include <linux/string.h>
216: #include <linux/ptrace.h>
217: #include <linux/errno.h>
218: #include <linux/ioport.h>
219: #include <linux/malloc.h>
220: #include <linux/interrupt.h>
221: #include <linux/delay.h>
222: #include <asm/segment.h>
223: #include <asm/bitops.h>
224: #include <asm/io.h>
225: #include <asm/dma.h>
226:
227: #include <linux/netdevice.h>
228: #include <linux/etherdevice.h>
229: #include <linux/skbuff.h>
230:
231: #include <linux/time.h>
232: #include <linux/types.h>
233: #include <linux/unistd.h>
234: #include <linux/ctype.h>
235:
236: #include "depca.h"
237:
238: #ifdef DEPCA_DEBUG
239: static int depca_debug = DEPCA_DEBUG;
240: #else
241: static int depca_debug = 1;
242: #endif
243:
244: #define DEPCA_NDA 0xffe0 /* No Device Address */
245:
246: /*
247: ** Ethernet PROM defines
248: */
249: #define PROBE_LENGTH 32
250: #define ETH_PROM_SIG 0xAA5500FFUL
251:
252: /*
253: ** Set the number of Tx and Rx buffers. Ensure that the memory requested
254: ** here is <= to the amount of shared memory set up by the board switches.
255: ** The number of descriptors MUST BE A POWER OF 2.
256: **
257: ** total_memory = NUM_RX_DESC*(8+RX_BUFF_SZ) + NUM_TX_DESC*(8+TX_BUFF_SZ)
258: */
259: #define NUM_RX_DESC 8 /* Number of RX descriptors */
260: #define NUM_TX_DESC 8 /* Number of TX descriptors */
261: #define RX_BUFF_SZ 1536 /* Buffer size for each Rx buffer */
262: #define TX_BUFF_SZ 1536 /* Buffer size for each Tx buffer */
263:
264: #define CRC_POLYNOMIAL_BE 0x04c11db7UL /* Ethernet CRC, big endian */
265: #define CRC_POLYNOMIAL_LE 0xedb88320UL /* Ethernet CRC, little endian */
266:
267: /*
268: ** EISA bus defines
269: */
270: #define DEPCA_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
271: #define MAX_EISA_SLOTS 16
272: #define EISA_SLOT_INC 0x1000
273:
274: /*
275: ** ISA Bus defines
276: */
277: #define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
278: #define DEPCA_IO_PORTS {0x300, 0x200, 0}
279: #define DEPCA_TOTAL_SIZE 0x10
280: static short mem_chkd = 0;
281:
282: /*
283: ** Name <-> Adapter mapping
284: */
285: #define DEPCA_SIGNATURE {"DEPCA",\
286: "DE100","DE101",\
287: "DE200","DE201","DE202",\
288: "DE210",\
289: "DE422",\
290: ""}
291: static enum {DEPCA, de100, de101, de200, de201, de202, de210, de422, unknown} adapter;
292:
293: /*
294: ** Miscellaneous info...
295: */
296: #define DEPCA_STRLEN 16
297: #define MAX_NUM_DEPCAS 2
298:
299: /*
300: ** Memory Alignment. Each descriptor is 4 longwords long. To force a
301: ** particular alignment on the TX descriptor, adjust DESC_SKIP_LEN and
302: ** DESC_ALIGN. ALIGN aligns the start address of the private memory area
303: ** and hence the RX descriptor ring's first entry.
304: */
305: #define ALIGN4 ((u_long)4 - 1) /* 1 longword align */
306: #define ALIGN8 ((u_long)8 - 1) /* 2 longword (quadword) align */
307: #define ALIGN ALIGN8 /* Keep the LANCE happy... */
308:
309: /*
310: ** The DEPCA Rx and Tx ring descriptors.
311: */
312: struct depca_rx_desc {
313: volatile s32 base;
314: s16 buf_length; /* This length is negative 2's complement! */
315: s16 msg_length; /* This length is "normal". */
316: };
317:
318: struct depca_tx_desc {
319: volatile s32 base;
320: s16 length; /* This length is negative 2's complement! */
321: s16 misc; /* Errors and TDR info */
322: };
323:
324: #define LA_MASK 0x0000ffff /* LANCE address mask for mapping network RAM
325: to LANCE memory address space */
326:
327: /*
328: ** The Lance initialization block, described in databook, in common memory.
329: */
330: struct depca_init {
331: u16 mode; /* Mode register */
332: u8 phys_addr[ETH_ALEN]; /* Physical ethernet address */
333: u8 mcast_table[8]; /* Multicast Hash Table. */
334: u32 rx_ring; /* Rx ring base pointer & ring length */
335: u32 tx_ring; /* Tx ring base pointer & ring length */
336: };
337:
338: #define DEPCA_PKT_STAT_SZ 16
339: #define DEPCA_PKT_BIN_SZ 128 /* Should be >=100 unless you
340: increase DEPCA_PKT_STAT_SZ */
341: struct depca_private {
342: char devname[DEPCA_STRLEN]; /* Device Product String */
343: char adapter_name[DEPCA_STRLEN];/* /proc/ioports string */
344: char adapter; /* Adapter type */
345: struct depca_rx_desc *rx_ring; /* Pointer to start of RX descriptor ring */
346: struct depca_tx_desc *tx_ring; /* Pointer to start of TX descriptor ring */
347: struct depca_init init_block;/* Shadow Initialization block */
348: char *rx_memcpy[NUM_RX_DESC]; /* CPU virt address of sh'd memory buffs */
349: char *tx_memcpy[NUM_TX_DESC]; /* CPU virt address of sh'd memory buffs */
350: u_long bus_offset; /* (E)ISA bus address offset vs LANCE */
351: u_long sh_mem; /* Physical start addr of shared mem area */
352: u_long dma_buffs; /* LANCE Rx and Tx buffers start address. */
353: int rx_new, tx_new; /* The next free ring entry */
354: int rx_old, tx_old; /* The ring entries to be free()ed. */
355: struct enet_statistics stats;
356: struct { /* Private stats counters */
357: u32 bins[DEPCA_PKT_STAT_SZ];
358: u32 unicast;
359: u32 multicast;
360: u32 broadcast;
361: u32 excessive_collisions;
362: u32 tx_underruns;
363: u32 excessive_underruns;
364: } pktStats;
365: int txRingMask; /* TX ring mask */
366: int rxRingMask; /* RX ring mask */
367: s32 rx_rlen; /* log2(rxRingMask+1) for the descriptors */
368: s32 tx_rlen; /* log2(txRingMask+1) for the descriptors */
369: };
370:
371: /*
372: ** The transmit ring full condition is described by the tx_old and tx_new
373: ** pointers by:
374: ** tx_old = tx_new Empty ring
375: ** tx_old = tx_new+1 Full ring
376: ** tx_old+txRingMask = tx_new Full ring (wrapped condition)
377: */
378: #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
379: lp->tx_old+lp->txRingMask-lp->tx_new:\
380: lp->tx_old -lp->tx_new-1)
381:
382: /*
383: ** Public Functions
384: */
385: static int depca_open(struct device *dev);
386: static int depca_start_xmit(struct sk_buff *skb, struct device *dev);
387: static void depca_interrupt(int irq, void *dev_id, struct pt_regs * regs);
388: static int depca_close(struct device *dev);
389: static int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd);
390: static struct enet_statistics *depca_get_stats(struct device *dev);
391: static void set_multicast_list(struct device *dev);
392:
393: /*
394: ** Private functions
395: */
396: static int depca_hw_init(struct device *dev, u_long ioaddr);
397: static void depca_init_ring(struct device *dev);
398: static int depca_rx(struct device *dev);
399: static int depca_tx(struct device *dev);
400:
401: static void LoadCSRs(struct device *dev);
402: static int InitRestartDepca(struct device *dev);
403: static void DepcaSignature(char *name, u_long paddr);
404: static int DevicePresent(u_long ioaddr);
405: static int get_hw_addr(struct device *dev);
406: static int EISA_signature(char *name, s32 eisa_id);
407: static void SetMulticastFilter(struct device *dev);
408: static void isa_probe(struct device *dev, u_long iobase);
409: static void eisa_probe(struct device *dev, u_long iobase);
410: static struct device *alloc_device(struct device *dev, u_long iobase);
411: static int depca_dev_index(char *s);
412: static struct device *insert_device(struct device *dev, u_long iobase, int (*init)(struct device *));
413: static int load_packet(struct device *dev, struct sk_buff *skb);
414: static void depca_dbg_open(struct device *dev);
415:
416: #ifdef MODULE
417: int init_module(void);
418: void cleanup_module(void);
419: static int autoprobed = 1, loading_module = 1;
420: # else
421: static u_char de1xx_irq[] = {2,3,4,5,7,9,0};
422: static u_char de2xx_irq[] = {5,9,10,11,15,0};
423: static u_char de422_irq[] = {5,9,10,11,0};
424: static u_char *depca_irq;
425: static int autoprobed = 0, loading_module = 0;
426: #endif /* MODULE */
427:
428: static char name[DEPCA_STRLEN];
429: static int num_depcas = 0, num_eth = 0;
430: static int mem=0; /* For loadable module assignment
431: use insmod mem=0x????? .... */
432: static char *adapter_name = '\0'; /* If no PROM when loadable module
433: use insmod adapter_name=DE??? ...
434: */
435: /*
436: ** Miscellaneous defines...
437: */
438: #define STOP_DEPCA \
439: outw(CSR0, DEPCA_ADDR);\
440: outw(STOP, DEPCA_DATA)
441:
442:
443:
444: int depca_probe(struct device *dev)
445: {
446: int tmp = num_depcas, status = -ENODEV;
447: u_long iobase = dev->base_addr;
448:
449: if ((iobase == 0) && loading_module){
450: printk("Autoprobing is not supported when loading a module based driver.\n");
451: status = -EIO;
452: } else {
453: isa_probe(dev, iobase);
454: eisa_probe(dev, iobase);
455:
456: if ((tmp == num_depcas) && (iobase != 0) && loading_module) {
457: printk("%s: depca_probe() cannot find device at 0x%04lx.\n", dev->name,
458: iobase);
459: }
460:
461: /*
462: ** Walk the device list to check that at least one device
463: ** initialised OK
464: */
465: for (; (dev->priv == NULL) && (dev->next != NULL); dev = dev->next);
466:
467: if (dev->priv) status = 0;
468: if (iobase == 0) autoprobed = 1;
469: }
470:
471: return status;
472: }
473:
474: static int
475: depca_hw_init(struct device *dev, u_long ioaddr)
476: {
477: struct depca_private *lp;
478: int i, j, offset, netRAM, mem_len, status=0;
479: s16 nicsr;
480: u_long mem_start=0, mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
481:
482: STOP_DEPCA;
483:
484: nicsr = inb(DEPCA_NICSR);
485: nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
486: outb(nicsr, DEPCA_NICSR);
487:
488: if (inw(DEPCA_DATA) == STOP) {
489: do {
490: strcpy(name, (adapter_name ? adapter_name : ""));
491: mem_start = (mem ? mem & 0xf0000 : mem_base[mem_chkd++]);
492: DepcaSignature(name, mem_start);
493: } while (!mem && mem_base[mem_chkd] && (adapter == unknown));
494:
495: if ((adapter != unknown) && mem_start) { /* found a DEPCA device */
496: dev->base_addr = ioaddr;
497:
498: if ((ioaddr&0x0fff)==DEPCA_EISA_IO_PORTS) {/* EISA slot address */
499: printk("%s: %s at 0x%04lx (EISA slot %d)",
500: dev->name, name, ioaddr, (int)((ioaddr>>12)&0x0f));
501: } else { /* ISA port address */
502: printk("%s: %s at 0x%04lx", dev->name, name, ioaddr);
503: }
504:
505: printk(", h/w address ");
506: status = get_hw_addr(dev);
507: for (i=0; i<ETH_ALEN - 1; i++) { /* get the ethernet address */
508: printk("%2.2x:", dev->dev_addr[i]);
509: }
510: printk("%2.2x", dev->dev_addr[i]);
511:
512: if (status == 0) {
513: /* Set up the maximum amount of network RAM(kB) */
514: netRAM = ((adapter != DEPCA) ? 64 : 48);
515: if ((nicsr & _128KB) && (adapter == de422)) netRAM = 128;
516: offset = 0x0000;
517:
518: /* Shared Memory Base Address */
519: if (nicsr & BUF) {
520: offset = 0x8000; /* 32kbyte RAM offset*/
521: nicsr &= ~BS; /* DEPCA RAM in top 32k */
522: netRAM -= 32;
523: }
524: mem_start += offset; /* (E)ISA start address */
525: if ((mem_len = (NUM_RX_DESC*(sizeof(struct depca_rx_desc)+RX_BUFF_SZ) +
526: NUM_TX_DESC*(sizeof(struct depca_tx_desc)+TX_BUFF_SZ) +
527: sizeof(struct depca_init))) <=
528: (netRAM<<10)) {
529: printk(",\n has %dkB RAM at 0x%.5lx", netRAM, mem_start);
530:
531: /* Enable the shadow RAM. */
532: if (adapter != DEPCA) {
533: nicsr |= SHE;
534: outb(nicsr, DEPCA_NICSR);
535: }
536:
537: /* Define the device private memory */
538: dev->priv = (void *) kmalloc(sizeof(struct depca_private), GFP_KERNEL);
539: if (dev->priv == NULL)
540: return -ENOMEM;
541: lp = (struct depca_private *)dev->priv;
542: memset((char *)dev->priv, 0, sizeof(struct depca_private));
543: lp->adapter = adapter;
544: sprintf(lp->adapter_name,"%s (%s)", name, dev->name);
545: request_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name);
546:
547: /* Initialisation Block */
548: lp->sh_mem = mem_start;
549: mem_start += sizeof(struct depca_init);
550:
551: /* Tx & Rx descriptors (aligned to a quadword boundary) */
552: mem_start = (mem_start + ALIGN) & ~ALIGN;
553: lp->rx_ring = (struct depca_rx_desc *)mem_start;
554:
555: mem_start += (sizeof(struct depca_rx_desc) * NUM_RX_DESC);
556: lp->tx_ring = (struct depca_tx_desc *)mem_start;
557:
558: mem_start += (sizeof(struct depca_tx_desc) * NUM_TX_DESC);
559: lp->bus_offset = mem_start & 0x00ff0000;
560: mem_start &= LA_MASK; /* LANCE re-mapped start address */
561:
562: lp->dma_buffs = mem_start;
563:
564: /* Finish initialising the ring information. */
565: lp->rxRingMask = NUM_RX_DESC - 1;
566: lp->txRingMask = NUM_TX_DESC - 1;
567:
568: /* Calculate Tx/Rx RLEN size for the descriptors. */
569: for (i=0, j = lp->rxRingMask; j>0; i++) {
570: j >>= 1;
571: }
572: lp->rx_rlen = (s32)(i << 29);
573: for (i=0, j = lp->txRingMask; j>0; i++) {
574: j >>= 1;
575: }
576: lp->tx_rlen = (s32)(i << 29);
577:
578: /* Load the initialisation block */
579: depca_init_ring(dev);
580:
581: /* Initialise the control and status registers */
582: LoadCSRs(dev);
583:
584: /* Enable DEPCA board interrupts for autoprobing */
585: nicsr = ((nicsr & ~IM)|IEN);
586: outb(nicsr, DEPCA_NICSR);
587:
588: /* To auto-IRQ we enable the initialization-done and DMA err,
589: interrupts. For now we will always get a DMA error. */
590: if (dev->irq < 2) {
591: #ifndef MODULE
592: unsigned char irqnum;
593: autoirq_setup(0);
594:
595: /* Assign the correct irq list */
596: switch (lp->adapter) {
597: case DEPCA:
598: case de100:
599: case de101:
600: depca_irq = de1xx_irq;
601: break;
602: case de200:
603: case de201:
604: case de202:
605: case de210:
606: depca_irq = de2xx_irq;
607: break;
608: case de422:
609: depca_irq = de422_irq;
610: break;
611: }
612:
613: /* Trigger an initialization just for the interrupt. */
614: outw(INEA | INIT, DEPCA_DATA);
615:
616: irqnum = autoirq_report(1);
617: if (!irqnum) {
618: printk(" and failed to detect IRQ line.\n");
619: status = -ENXIO;
620: } else {
621: for (dev->irq=0,i=0; (depca_irq[i]) && (!dev->irq); i++) {
622: if (irqnum == depca_irq[i]) {
623: dev->irq = irqnum;
624: printk(" and uses IRQ%d.\n", dev->irq);
625: }
626: }
627:
628: if (!dev->irq) {
629: printk(" but incorrect IRQ line detected.\n");
630: status = -ENXIO;
631: }
632: }
633: #endif /* MODULE */
634: } else {
635: printk(" and assigned IRQ%d.\n", dev->irq);
636: }
637: if (status) release_region(ioaddr, DEPCA_TOTAL_SIZE);
638: } else {
639: printk(",\n requests %dkB RAM: only %dkB is available!\n",
640: (mem_len>>10), netRAM);
641: status = -ENXIO;
642: }
643: } else {
644: printk(" which has an Ethernet PROM CRC error.\n");
645: status = -ENXIO;
646: }
647: } else {
648: status = -ENXIO;
649: }
650: if (!status) {
651: if (depca_debug > 1) {
652: printk(version);
653: }
654:
655: /* The DEPCA-specific entries in the device structure. */
656: dev->open = &depca_open;
657: dev->hard_start_xmit = &depca_start_xmit;
658: dev->stop = &depca_close;
659: dev->get_stats = &depca_get_stats;
660: dev->set_multicast_list = &set_multicast_list;
661: dev->do_ioctl = &depca_ioctl;
662:
663: dev->mem_start = 0;
664:
665: /* Fill in the generic field of the device structure. */
666: ether_setup(dev);
667: } else { /* Incorrectly initialised hardware */
668: if (dev->priv) {
669: kfree_s(dev->priv, sizeof(struct depca_private));
670: dev->priv = NULL;
671: }
672: }
673: } else {
674: status = -ENXIO;
675: }
676:
677: return status;
678: }
679:
680:
681: static int
682: depca_open(struct device *dev)
683: {
684: struct depca_private *lp = (struct depca_private *)dev->priv;
685: u_long ioaddr = dev->base_addr;
686: s16 nicsr;
687: int status = 0;
688:
689: irq2dev_map[dev->irq] = dev;
690: STOP_DEPCA;
691: nicsr = inb(DEPCA_NICSR);
692:
693: /* Make sure the shadow RAM is enabled */
694: if (adapter != DEPCA) {
695: nicsr |= SHE;
696: outb(nicsr, DEPCA_NICSR);
697: }
698:
699: /* Re-initialize the DEPCA... */
700: depca_init_ring(dev);
701: LoadCSRs(dev);
702:
703: depca_dbg_open(dev);
704:
705: if (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name, NULL)) {
706: printk("depca_open(): Requested IRQ%d is busy\n",dev->irq);
707: status = -EAGAIN;
708: } else {
709:
710: /* Enable DEPCA board interrupts and turn off LED */
711: nicsr = ((nicsr & ~IM & ~LED)|IEN);
712: outb(nicsr, DEPCA_NICSR);
713: outw(CSR0,DEPCA_ADDR);
714:
715: dev->tbusy = 0;
716: dev->interrupt = 0;
717: dev->start = 1;
718:
719: status = InitRestartDepca(dev);
720:
721: if (depca_debug > 1){
722: printk("CSR0: 0x%4.4x\n",inw(DEPCA_DATA));
723: printk("nicsr: 0x%02x\n",inb(DEPCA_NICSR));
724: }
725: }
726:
727: MOD_INC_USE_COUNT;
728:
729: return status;
730: }
731:
732: /* Initialize the lance Rx and Tx descriptor rings. */
733: static void
734: depca_init_ring(struct device *dev)
735: {
736: struct depca_private *lp = (struct depca_private *)dev->priv;
737: u_int i;
738: u_long p;
739:
740: /* Lock out other processes whilst setting up the hardware */
741: set_bit(0, (void *)&dev->tbusy);
742:
743: lp->rx_new = lp->tx_new = 0;
744: lp->rx_old = lp->tx_old = 0;
745:
746: /* Initialize the base addresses and length of each buffer in the ring */
747: for (i = 0; i <= lp->rxRingMask; i++) {
748: writel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
749: writew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
750: lp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
751: }
752: for (i = 0; i <= lp->txRingMask; i++) {
753: writel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
754: &lp->tx_ring[i].base);
755: lp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
756: }
757:
758: /* Set up the initialization block */
759: lp->init_block.rx_ring = ((u32)((u_long)lp->rx_ring)&LA_MASK) | lp->rx_rlen;
760: lp->init_block.tx_ring = ((u32)((u_long)lp->tx_ring)&LA_MASK) | lp->tx_rlen;
761:
762: SetMulticastFilter(dev);
763:
764: for (i = 0; i < ETH_ALEN; i++) {
765: lp->init_block.phys_addr[i] = dev->dev_addr[i];
766: }
767:
768: lp->init_block.mode = 0x0000; /* Enable the Tx and Rx */
769:
770: return;
771: }
772:
773: /*
774: ** Writes a socket buffer to TX descriptor ring and starts transmission
775: */
776: static int
777: depca_start_xmit(struct sk_buff *skb, struct device *dev)
778: {
779: struct depca_private *lp = (struct depca_private *)dev->priv;
780: u_long ioaddr = dev->base_addr;
781: int status = 0;
782:
783: /* Transmitter timeout, serious problems. */
784: if (dev->tbusy) {
785: int tickssofar = jiffies - dev->trans_start;
786: if (tickssofar < 1*HZ) {
787: status = -1;
788: } else {
789: printk("%s: transmit timed out, status %04x, resetting.\n",
790: dev->name, inw(DEPCA_DATA));
791:
792: STOP_DEPCA;
793: depca_init_ring(dev);
794: LoadCSRs(dev);
795: dev->interrupt = UNMASK_INTERRUPTS;
796: dev->start = 1;
797: dev->tbusy=0;
798: dev->trans_start = jiffies;
799: InitRestartDepca(dev);
800: dev_kfree_skb(skb, FREE_WRITE);
801: }
802: return status;
803: } else if (skb == NULL) {
804: dev_tint(dev);
805: } else if (skb->len > 0) {
806: /* Enforce 1 process per h/w access */
807: if (set_bit(0, (void*)&dev->tbusy) != 0) {
808: printk("%s: Transmitter access conflict.\n", dev->name);
809: status = -1;
810: } else {
811: if (TX_BUFFS_AVAIL) { /* Fill in a Tx ring entry */
812: status = load_packet(dev, skb);
813:
814: if (!status) {
815: /* Trigger an immediate send demand. */
816: outw(CSR0, DEPCA_ADDR);
817: outw(INEA | TDMD, DEPCA_DATA);
818:
819: dev->trans_start = jiffies;
820: dev_kfree_skb(skb, FREE_WRITE);
821: }
822: if (TX_BUFFS_AVAIL) {
823: dev->tbusy=0;
824: }
825: } else {
826: status = -1;
827: }
828: }
829: }
830:
831: return status;
832: }
833:
834: /*
835: ** The DEPCA interrupt handler.
836: */
837: static void
838: depca_interrupt(int irq, void *dev_id, struct pt_regs * regs)
839: {
840: struct device *dev = (struct device *)(irq2dev_map[irq]);
841: struct depca_private *lp;
842: s16 csr0, nicsr;
843: u_long ioaddr;
844:
845: if (dev == NULL) {
846: printk ("depca_interrupt(): irq %d for unknown device.\n", irq);
847: } else {
848: lp = (struct depca_private *)dev->priv;
849: ioaddr = dev->base_addr;
850:
851: if (dev->interrupt)
852: printk("%s: Re-entering the interrupt handler.\n", dev->name);
853:
854: dev->interrupt = MASK_INTERRUPTS;
855:
856: /* mask the DEPCA board interrupts and turn on the LED */
857: nicsr = inb(DEPCA_NICSR);
858: nicsr |= (IM|LED);
859: outb(nicsr, DEPCA_NICSR);
860:
861: outw(CSR0, DEPCA_ADDR);
862: csr0 = inw(DEPCA_DATA);
863:
864: /* Acknowledge all of the current interrupt sources ASAP. */
865: outw(csr0 & INTE, DEPCA_DATA);
866:
867: if (csr0 & RINT) /* Rx interrupt (packet arrived) */
868: depca_rx(dev);
869:
870: if (csr0 & TINT) /* Tx interrupt (packet sent) */
871: depca_tx(dev);
872:
873: if ((TX_BUFFS_AVAIL >= 0) && dev->tbusy) { /* any resources available? */
874: dev->tbusy = 0; /* clear TX busy flag */
875: mark_bh(NET_BH);
876: }
877:
878: /* Unmask the DEPCA board interrupts and turn off the LED */
879: nicsr = (nicsr & ~IM & ~LED);
880: outb(nicsr, DEPCA_NICSR);
881:
882: dev->interrupt = UNMASK_INTERRUPTS;
883: }
884:
885: return;
886: }
887:
888: static int
889: depca_rx(struct device *dev)
890: {
891: struct depca_private *lp = (struct depca_private *)dev->priv;
892: int i, entry;
893: s32 status;
894:
895: for (entry=lp->rx_new;
896: !(readl(&lp->rx_ring[entry].base) & R_OWN);
897: entry=lp->rx_new){
898: status = readl(&lp->rx_ring[entry].base) >> 16 ;
899: if (status & R_STP) { /* Remember start of frame */
900: lp->rx_old = entry;
901: }
902: if (status & R_ENP) { /* Valid frame status */
903: if (status & R_ERR) { /* There was an error. */
904: lp->stats.rx_errors++; /* Update the error stats. */
905: if (status & R_FRAM) lp->stats.rx_frame_errors++;
906: if (status & R_OFLO) lp->stats.rx_over_errors++;
907: if (status & R_CRC) lp->stats.rx_crc_errors++;
908: if (status & R_BUFF) lp->stats.rx_fifo_errors++;
909: } else {
910: short len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
911: struct sk_buff *skb;
912:
913: skb = dev_alloc_skb(pkt_len+2);
914: if (skb != NULL) {
915: unsigned char *buf;
916: skb_reserve(skb,2); /* 16 byte align the IP header */
917: buf = skb_put(skb,pkt_len);
918: skb->dev = dev;
919: if (entry < lp->rx_old) { /* Wrapped buffer */
920: len = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
921: memcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
922: memcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
923: } else { /* Linear buffer */
924: memcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], pkt_len);
925: }
926:
927: /*
928: ** Notify the upper protocol layers that there is another
929: ** packet to handle
930: */
931: skb->protocol=eth_type_trans(skb,dev);
932: netif_rx(skb);
933:
934: /*
935: ** Update stats
936: */
937: lp->stats.rx_packets++;
938: for (i=1; i<DEPCA_PKT_STAT_SZ-1; i++) {
939: if (pkt_len < (i*DEPCA_PKT_BIN_SZ)) {
940: lp->pktStats.bins[i]++;
941: i = DEPCA_PKT_STAT_SZ;
942: }
943: }
944: if (buf[0] & 0x01) { /* Multicast/Broadcast */
945: if ((*(s16 *)&buf[0] == -1) &&
946: (*(s16 *)&buf[2] == -1) &&
947: (*(s16 *)&buf[4] == -1)) {
948: lp->pktStats.broadcast++;
949: } else {
950: lp->pktStats.multicast++;
951: }
952: } else if ((*(s16 *)&buf[0] == *(s16 *)&dev->dev_addr[0]) &&
953: (*(s16 *)&buf[2] == *(s16 *)&dev->dev_addr[2]) &&
954: (*(s16 *)&buf[4] == *(s16 *)&dev->dev_addr[4])) {
955: lp->pktStats.unicast++;
956: }
957:
958: lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
959: if (lp->pktStats.bins[0] == 0) { /* Reset counters */
960: memset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
961: }
962: } else {
963: printk("%s: Memory squeeze, deferring packet.\n", dev->name);
964: lp->stats.rx_dropped++; /* Really, deferred. */
965: break;
966: }
967: }
968: /* Change buffer ownership for this last frame, back to the adapter */
1.1.1.2 ! root 969: for (; lp->rx_old!=entry; lp->rx_old=(lp->rx_old+1)&lp->rxRingMask) {
1.1 root 970: writel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN,
971: &lp->rx_ring[lp->rx_old].base);
972: }
973: writel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
974: }
975:
976: /*
977: ** Update entry information
978: */
1.1.1.2 ! root 979: lp->rx_new = (lp->rx_new + 1) & lp->rxRingMask;
1.1 root 980: }
981:
982: return 0;
983: }
984:
985: /*
986: ** Buffer sent - check for buffer errors.
987: */
988: static int
989: depca_tx(struct device *dev)
990: {
991: struct depca_private *lp = (struct depca_private *)dev->priv;
992: int entry;
993: s32 status;
994: u_long ioaddr = dev->base_addr;
995:
996: for (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
997: status = readl(&lp->tx_ring[entry].base) >> 16 ;
998:
999: if (status < 0) { /* Packet not yet sent! */
1000: break;
1001: } else if (status & T_ERR) { /* An error occurred. */
1002: status = readl(&lp->tx_ring[entry].misc);
1003: lp->stats.tx_errors++;
1004: if (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
1005: if (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
1006: if (status & TMD3_LCOL) lp->stats.tx_window_errors++;
1007: if (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
1008: if (status & (TMD3_BUFF | TMD3_UFLO)) {
1009: /* Trigger an immediate send demand. */
1010: outw(CSR0, DEPCA_ADDR);
1011: outw(INEA | TDMD, DEPCA_DATA);
1012: }
1013: } else if (status & (T_MORE | T_ONE)) {
1014: lp->stats.collisions++;
1015: } else {
1016: lp->stats.tx_packets++;
1017: }
1018:
1019: /* Update all the pointers */
1.1.1.2 ! root 1020: lp->tx_old = (lp->tx_old + 1) & lp->txRingMask;
1.1 root 1021: }
1022:
1023: return 0;
1024: }
1025:
1026: static int
1027: depca_close(struct device *dev)
1028: {
1029: struct depca_private *lp = (struct depca_private *)dev->priv;
1030: s16 nicsr;
1031: u_long ioaddr = dev->base_addr;
1032:
1033: dev->start = 0;
1034: dev->tbusy = 1;
1035:
1036: outw(CSR0, DEPCA_ADDR);
1037:
1038: if (depca_debug > 1) {
1039: printk("%s: Shutting down ethercard, status was %2.2x.\n",
1040: dev->name, inw(DEPCA_DATA));
1041: }
1042:
1043: /*
1044: ** We stop the DEPCA here -- it occasionally polls
1045: ** memory if we don't.
1046: */
1047: outw(STOP, DEPCA_DATA);
1048:
1049: /*
1050: ** Give back the ROM in case the user wants to go to DOS
1051: */
1052: if (lp->adapter != DEPCA) {
1053: nicsr = inb(DEPCA_NICSR);
1054: nicsr &= ~SHE;
1055: outb(nicsr, DEPCA_NICSR);
1056: }
1057:
1058: /*
1059: ** Free the associated irq
1060: */
1061: free_irq(dev->irq, NULL);
1062: irq2dev_map[dev->irq] = NULL;
1063:
1064: MOD_DEC_USE_COUNT;
1065:
1066: return 0;
1067: }
1068:
1069: static void LoadCSRs(struct device *dev)
1070: {
1071: struct depca_private *lp = (struct depca_private *)dev->priv;
1072: u_long ioaddr = dev->base_addr;
1073:
1074: outw(CSR1, DEPCA_ADDR); /* initialisation block address LSW */
1075: outw((u16)(lp->sh_mem & LA_MASK), DEPCA_DATA);
1076: outw(CSR2, DEPCA_ADDR); /* initialisation block address MSW */
1077: outw((u16)((lp->sh_mem & LA_MASK) >> 16), DEPCA_DATA);
1078: outw(CSR3, DEPCA_ADDR); /* ALE control */
1079: outw(ACON, DEPCA_DATA);
1080:
1081: outw(CSR0, DEPCA_ADDR); /* Point back to CSR0 */
1082:
1083: return;
1084: }
1085:
1086: static int InitRestartDepca(struct device *dev)
1087: {
1088: struct depca_private *lp = (struct depca_private *)dev->priv;
1089: u_long ioaddr = dev->base_addr;
1090: int i, status=0;
1091:
1092: /* Copy the shadow init_block to shared memory */
1093: memcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
1094:
1095: outw(CSR0, DEPCA_ADDR); /* point back to CSR0 */
1096: outw(INIT, DEPCA_DATA); /* initialize DEPCA */
1097:
1098: /* wait for lance to complete initialisation */
1099: for (i=0;(i<100) && !(inw(DEPCA_DATA) & IDON); i++);
1100:
1101: if (i!=100) {
1102: /* clear IDON by writing a "1", enable interrupts and start lance */
1103: outw(IDON | INEA | STRT, DEPCA_DATA);
1104: if (depca_debug > 2) {
1105: printk("%s: DEPCA open after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
1106: dev->name, i, lp->sh_mem, inw(DEPCA_DATA));
1107: }
1108: } else {
1109: printk("%s: DEPCA unopen after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
1110: dev->name, i, lp->sh_mem, inw(DEPCA_DATA));
1111: status = -1;
1112: }
1113:
1114: return status;
1115: }
1116:
1117: static struct enet_statistics *
1118: depca_get_stats(struct device *dev)
1119: {
1120: struct depca_private *lp = (struct depca_private *)dev->priv;
1121:
1122: /* Null body since there is no framing error counter */
1123:
1124: return &lp->stats;
1125: }
1126:
1127: /*
1128: ** Set or clear the multicast filter for this adaptor.
1129: */
1130: static void
1131: set_multicast_list(struct device *dev)
1132: {
1133: struct depca_private *lp = (struct depca_private *)dev->priv;
1134: u_long ioaddr = dev->base_addr;
1135:
1136: if (irq2dev_map[dev->irq] != NULL) {
1137: while(dev->tbusy); /* Stop ring access */
1138: set_bit(0, (void*)&dev->tbusy);
1139: while(lp->tx_old != lp->tx_new); /* Wait for the ring to empty */
1140:
1141: STOP_DEPCA; /* Temporarily stop the depca. */
1142: depca_init_ring(dev); /* Initialize the descriptor rings */
1143:
1144: if (dev->flags & IFF_PROMISC) { /* Set promiscuous mode */
1145: lp->init_block.mode |= PROM;
1146: } else {
1147: SetMulticastFilter(dev);
1148: lp->init_block.mode &= ~PROM; /* Unset promiscuous mode */
1149: }
1150:
1151: LoadCSRs(dev); /* Reload CSR3 */
1152: InitRestartDepca(dev); /* Resume normal operation. */
1153: dev->tbusy = 0; /* Unlock the TX ring */
1154: }
1155: }
1156:
1157: /*
1158: ** Calculate the hash code and update the logical address filter
1159: ** from a list of ethernet multicast addresses.
1160: ** Big endian crc one liner is mine, all mine, ha ha ha ha!
1161: ** LANCE calculates its hash codes big endian.
1162: */
1163: static void SetMulticastFilter(struct device *dev)
1164: {
1165: struct depca_private *lp = (struct depca_private *)dev->priv;
1166: struct dev_mc_list *dmi=dev->mc_list;
1167: char *addrs;
1168: int i, j, bit, byte;
1169: u16 hashcode;
1170: s32 crc, poly = CRC_POLYNOMIAL_BE;
1171:
1172: if (dev->flags & IFF_ALLMULTI) { /* Set all multicast bits */
1173: for (i=0; i<(HASH_TABLE_LEN>>3); i++) {
1174: lp->init_block.mcast_table[i] = (char)0xff;
1175: }
1176: } else {
1177: for (i=0; i<(HASH_TABLE_LEN>>3); i++){ /* Clear the multicast table */
1178: lp->init_block.mcast_table[i]=0;
1179: }
1180: /* Add multicast addresses */
1181: for (i=0;i<dev->mc_count;i++) { /* for each address in the list */
1182: addrs=dmi->dmi_addr;
1183: dmi=dmi->next;
1184: if ((*addrs & 0x01) == 1) { /* multicast address? */
1185: crc = 0xffffffff; /* init CRC for each address */
1186: for (byte=0;byte<ETH_ALEN;byte++) {/* for each address byte */
1187: /* process each address bit */
1188: for (bit = *addrs++,j=0;j<8;j++, bit>>=1) {
1189: crc = (crc << 1) ^ ((((crc<0?1:0) ^ bit) & 0x01) ? poly : 0);
1190: }
1191: }
1192: hashcode = (crc & 1); /* hashcode is 6 LSb of CRC ... */
1193: for (j=0;j<5;j++) { /* ... in reverse order. */
1194: hashcode = (hashcode << 1) | ((crc>>=1) & 1);
1195: }
1196:
1197:
1198: byte = hashcode >> 3; /* bit[3-5] -> byte in filter */
1199: bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
1200: lp->init_block.mcast_table[byte] |= bit;
1201: }
1202: }
1203: }
1204:
1205: return;
1206: }
1207:
1208: /*
1209: ** ISA bus I/O device probe
1210: */
1211: static void isa_probe(struct device *dev, u_long ioaddr)
1212: {
1213: int i = num_depcas, maxSlots;
1214: s32 ports[] = DEPCA_IO_PORTS;
1215:
1216: if (!ioaddr && autoprobed) return ; /* Been here before ! */
1217: if (ioaddr > 0x400) return; /* EISA Address */
1218: if (i >= MAX_NUM_DEPCAS) return; /* Too many ISA adapters */
1219:
1220: if (ioaddr == 0) { /* Autoprobing */
1221: maxSlots = MAX_NUM_DEPCAS;
1222: } else { /* Probe a specific location */
1223: ports[i] = ioaddr;
1224: maxSlots = i + 1;
1225: }
1226:
1227: for (; (i<maxSlots) && (dev!=NULL) && ports[i]; i++) {
1228: if (DevicePresent(ports[i]) == 0) {
1229: if (check_region(ports[i], DEPCA_TOTAL_SIZE) == 0) {
1230: if ((dev = alloc_device(dev, ports[i])) != NULL) {
1231: if (depca_hw_init(dev, ports[i]) == 0) {
1232: num_depcas++;
1233: }
1234: num_eth++;
1235: }
1236: } else if (autoprobed) {
1237: printk("%s: region already allocated at 0x%04x.\n", dev->name,ports[i]);
1238: }
1239: }
1240: }
1241:
1242: return;
1243: }
1244:
1245: /*
1246: ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1247: ** the motherboard. Upto 15 EISA devices are supported.
1248: */
1249: static void eisa_probe(struct device *dev, u_long ioaddr)
1250: {
1251: int i, maxSlots;
1252: u_long iobase;
1253: char name[DEPCA_STRLEN];
1254:
1255: if (!ioaddr && autoprobed) return ; /* Been here before ! */
1256: if ((ioaddr < 0x400) && (ioaddr > 0)) return; /* ISA Address */
1257:
1258: if (ioaddr == 0) { /* Autoprobing */
1259: iobase = EISA_SLOT_INC; /* Get the first slot address */
1260: i = 1;
1261: maxSlots = MAX_EISA_SLOTS;
1262: } else { /* Probe a specific location */
1263: iobase = ioaddr;
1264: i = (ioaddr >> 12);
1265: maxSlots = i + 1;
1266: }
1267: if ((iobase & 0x0fff) == 0) iobase += DEPCA_EISA_IO_PORTS;
1268:
1269: for (; (i<maxSlots) && (dev!=NULL); i++, iobase+=EISA_SLOT_INC) {
1270: if (EISA_signature(name, EISA_ID)) {
1271: if (DevicePresent(iobase) == 0) {
1272: if (check_region(iobase, DEPCA_TOTAL_SIZE) == 0) {
1273: if ((dev = alloc_device(dev, iobase)) != NULL) {
1274: if (depca_hw_init(dev, iobase) == 0) {
1275: num_depcas++;
1276: }
1277: num_eth++;
1278: }
1279: } else if (autoprobed) {
1280: printk("%s: region already allocated at 0x%04lx.\n",dev->name,iobase);
1281: }
1282: }
1283: }
1284: }
1285:
1286: return;
1287: }
1288:
1289: /*
1290: ** Search the entire 'eth' device list for a fixed probe. If a match isn't
1291: ** found then check for an autoprobe or unused device location. If they
1292: ** are not available then insert a new device structure at the end of
1293: ** the current list.
1294: */
1295: static struct device *
1296: alloc_device(struct device *dev, u_long iobase)
1297: {
1298: struct device *adev = NULL;
1299: int fixed = 0, new_dev = 0;
1300:
1301: num_eth = depca_dev_index(dev->name);
1302: if (loading_module) return dev;
1303:
1304: while (1) {
1305: if (((dev->base_addr == DEPCA_NDA) || (dev->base_addr==0)) && !adev) {
1306: adev=dev;
1307: } else if ((dev->priv == NULL) && (dev->base_addr==iobase)) {
1308: fixed = 1;
1309: } else {
1310: if (dev->next == NULL) {
1311: new_dev = 1;
1312: } else if (strncmp(dev->next->name, "eth", 3) != 0) {
1313: new_dev = 1;
1314: }
1315: }
1316: if ((dev->next == NULL) || new_dev || fixed) break;
1317: dev = dev->next;
1318: num_eth++;
1319: }
1320: if (adev && !fixed) {
1321: dev = adev;
1322: num_eth = depca_dev_index(dev->name);
1323: new_dev = 0;
1324: }
1325:
1326: if (((dev->next == NULL) &&
1327: ((dev->base_addr != DEPCA_NDA) && (dev->base_addr != 0)) && !fixed) ||
1328: new_dev) {
1329: num_eth++; /* New device */
1330: dev = insert_device(dev, iobase, depca_probe);
1331: }
1332:
1333: return dev;
1334: }
1335:
1336: /*
1337: ** If at end of eth device list and can't use current entry, malloc
1338: ** one up. If memory could not be allocated, print an error message.
1339: */
1340: static struct device *
1341: insert_device(struct device *dev, u_long iobase, int (*init)(struct device *))
1342: {
1343: struct device *new;
1344:
1345: new = (struct device *)kmalloc(sizeof(struct device)+8, GFP_KERNEL);
1346: if (new == NULL) {
1347: printk("eth%d: Device not initialised, insufficient memory\n",num_eth);
1348: return NULL;
1349: } else {
1350: new->next = dev->next;
1351: dev->next = new;
1352: dev = dev->next; /* point to the new device */
1353: dev->name = (char *)(dev + 1);
1354: if (num_eth > 9999) {
1355: sprintf(dev->name,"eth????");/* New device name */
1356: } else {
1357: sprintf(dev->name,"eth%d", num_eth);/* New device name */
1358: }
1359: dev->base_addr = iobase; /* assign the io address */
1360: dev->init = init; /* initialisation routine */
1361: }
1362:
1363: return dev;
1364: }
1365:
1366: static int
1367: depca_dev_index(char *s)
1368: {
1369: int i=0, j=0;
1370:
1371: for (;*s; s++) {
1372: if (isdigit(*s)) {
1373: j=1;
1374: i = (i * 10) + (*s - '0');
1375: } else if (j) break;
1376: }
1377:
1378: return i;
1379: }
1380:
1381: /*
1382: ** Look for a particular board name in the on-board Remote Diagnostics
1383: ** and Boot (readb) ROM. This will also give us a clue to the network RAM
1384: ** base address.
1385: */
1386: static void DepcaSignature(char *name, u_long paddr)
1387: {
1388: u_int i,j,k;
1389: const char *signatures[] = DEPCA_SIGNATURE;
1390: char tmpstr[16];
1391:
1392: /* Copy the first 16 bytes of ROM */
1393: for (i=0;i<16;i++) {
1394: tmpstr[i] = readb(paddr+0xc000+i);
1395: }
1396:
1397: /* Check if PROM contains a valid string */
1398: for (i=0;*signatures[i]!='\0';i++) {
1399: for (j=0,k=0;j<16 && k<strlen(signatures[i]);j++) {
1400: if (signatures[i][k] == tmpstr[j]) { /* track signature */
1401: k++;
1402: } else { /* lost signature; begin search again */
1403: k=0;
1404: }
1405: }
1406: if (k == strlen(signatures[i])) break;
1407: }
1408:
1409: /* Check if name string is valid, provided there's no PROM */
1410: if (*name && (i == unknown)) {
1411: for (i=0;*signatures[i]!='\0';i++) {
1412: if (strcmp(name,signatures[i]) == 0) break;
1413: }
1414: }
1415:
1416: /* Update search results */
1417: strcpy(name,signatures[i]);
1418: adapter = i;
1419:
1420: return;
1421: }
1422:
1423: /*
1424: ** Look for a special sequence in the Ethernet station address PROM that
1425: ** is common across all DEPCA products. Note that the original DEPCA needs
1426: ** its ROM address counter to be initialized and enabled. Only enable
1427: ** if the first address octet is a 0x08 - this minimises the chances of
1428: ** messing around with some other hardware, but it assumes that this DEPCA
1429: ** card initialized itself correctly.
1430: **
1431: ** Search the Ethernet address ROM for the signature. Since the ROM address
1432: ** counter can start at an arbitrary point, the search must include the entire
1433: ** probe sequence length plus the (length_of_the_signature - 1).
1434: ** Stop the search IMMEDIATELY after the signature is found so that the
1435: ** PROM address counter is correctly positioned at the start of the
1436: ** ethernet address for later read out.
1437: */
1438: static int DevicePresent(u_long ioaddr)
1439: {
1440: union {
1441: struct {
1442: u32 a;
1443: u32 b;
1444: } llsig;
1445: char Sig[sizeof(u32) << 1];
1446: } dev;
1447: short sigLength=0;
1448: s8 data;
1449: s16 nicsr;
1450: int i, j, status = 0;
1451:
1452: data = inb(DEPCA_PROM); /* clear counter on DEPCA */
1453: data = inb(DEPCA_PROM); /* read data */
1454:
1455: if (data == 0x08) { /* Enable counter on DEPCA */
1456: nicsr = inb(DEPCA_NICSR);
1457: nicsr |= AAC;
1458: outb(nicsr, DEPCA_NICSR);
1459: }
1460:
1461: dev.llsig.a = ETH_PROM_SIG;
1462: dev.llsig.b = ETH_PROM_SIG;
1463: sigLength = sizeof(u32) << 1;
1464:
1465: for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
1466: data = inb(DEPCA_PROM);
1467: if (dev.Sig[j] == data) { /* track signature */
1468: j++;
1469: } else { /* lost signature; begin search again */
1470: if (data == dev.Sig[0]) { /* rare case.... */
1471: j=1;
1472: } else {
1473: j=0;
1474: }
1475: }
1476: }
1477:
1478: if (j!=sigLength) {
1479: status = -ENODEV; /* search failed */
1480: }
1481:
1482: return status;
1483: }
1484:
1485: /*
1486: ** The DE100 and DE101 PROM accesses were made non-standard for some bizarre
1487: ** reason: access the upper half of the PROM with x=0; access the lower half
1488: ** with x=1.
1489: */
1490: static int get_hw_addr(struct device *dev)
1491: {
1492: u_long ioaddr = dev->base_addr;
1493: int i, k, tmp, status = 0;
1494: u_short j, x, chksum;
1495:
1496: x = (((adapter == de100) || (adapter == de101)) ? 1 : 0);
1497:
1498: for (i=0,k=0,j=0;j<3;j++) {
1499: k <<= 1 ;
1500: if (k > 0xffff) k-=0xffff;
1501:
1502: k += (u_char) (tmp = inb(DEPCA_PROM + x));
1503: dev->dev_addr[i++] = (u_char) tmp;
1504: k += (u_short) ((tmp = inb(DEPCA_PROM + x)) << 8);
1505: dev->dev_addr[i++] = (u_char) tmp;
1506:
1507: if (k > 0xffff) k-=0xffff;
1508: }
1509: if (k == 0xffff) k=0;
1510:
1511: chksum = (u_char) inb(DEPCA_PROM + x);
1512: chksum |= (u_short) (inb(DEPCA_PROM + x) << 8);
1513: if (k != chksum) status = -1;
1514:
1515: return status;
1516: }
1517:
1518: /*
1519: ** Load a packet into the shared memory
1520: */
1521: static int load_packet(struct device *dev, struct sk_buff *skb)
1522: {
1523: struct depca_private *lp = (struct depca_private *)dev->priv;
1524: int i, entry, end, len, status = 0;
1525:
1526: entry = lp->tx_new; /* Ring around buffer number. */
1527: end = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
1528: if (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
1529: /*
1530: ** Caution: the write order is important here... don't set up the
1531: ** ownership rights until all the other information is in place.
1532: */
1533: if (end < entry) { /* wrapped buffer */
1534: len = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
1535: memcpy_toio(lp->tx_memcpy[entry], skb->data, len);
1536: memcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
1537: } else { /* linear buffer */
1538: memcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
1539: }
1540:
1541: /* set up the buffer descriptors */
1542: len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1.1.1.2 ! root 1543: for (i = entry; i != end; i = (i + 1) & lp->txRingMask) {
1.1 root 1544: /* clean out flags */
1545: writel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
1546: writew(0x0000, &lp->tx_ring[i].misc); /* clears other error flags */
1547: writew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
1548: len -= TX_BUFF_SZ;
1549: }
1550: /* clean out flags */
1551: writel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
1552: writew(0x0000, &lp->tx_ring[end].misc); /* clears other error flags */
1553: writew(-len, &lp->tx_ring[end].length); /* packet length in last buff */
1554:
1555: /* start of packet */
1556: writel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
1557: /* end of packet */
1558: writel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
1559:
1560: for (i=end; i!=entry; --i) {
1561: /* ownership of packet */
1562: writel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
1563: if (i == 0) i=lp->txRingMask+1;
1564: }
1565: writel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
1566:
1567: lp->tx_new = (++end) & lp->txRingMask; /* update current pointers */
1568: } else {
1569: status = -1;
1570: }
1571:
1572: return status;
1573: }
1574:
1575: /*
1576: ** Look for a particular board name in the EISA configuration space
1577: */
1578: static int EISA_signature(char *name, s32 eisa_id)
1579: {
1580: u_int i;
1581: const char *signatures[] = DEPCA_SIGNATURE;
1582: char ManCode[DEPCA_STRLEN];
1583: union {
1584: s32 ID;
1585: char Id[4];
1586: } Eisa;
1587: int status = 0;
1588:
1589: *name = '\0';
1590: Eisa.ID = inl(eisa_id);
1591:
1592: ManCode[0]=(((Eisa.Id[0]>>2)&0x1f)+0x40);
1593: ManCode[1]=(((Eisa.Id[1]&0xe0)>>5)+((Eisa.Id[0]&0x03)<<3)+0x40);
1594: ManCode[2]=(((Eisa.Id[2]>>4)&0x0f)+0x30);
1595: ManCode[3]=(( Eisa.Id[2]&0x0f)+0x30);
1596: ManCode[4]=(((Eisa.Id[3]>>4)&0x0f)+0x30);
1597: ManCode[5]='\0';
1598:
1599: for (i=0;(*signatures[i] != '\0') && (*name == '\0');i++) {
1600: if (strstr(ManCode, signatures[i]) != NULL) {
1601: strcpy(name,ManCode);
1602: status = 1;
1603: }
1604: }
1605:
1606: return status;
1607: }
1608:
1609: static void depca_dbg_open(struct device *dev)
1610: {
1611: struct depca_private *lp = (struct depca_private *)dev->priv;
1612: u_long ioaddr = dev->base_addr;
1613: struct depca_init *p = (struct depca_init *)lp->sh_mem;
1614: int i;
1615:
1616: if (depca_debug > 1){
1617: /* Copy the shadow init_block to shared memory */
1618: memcpy_toio((char *)lp->sh_mem,&lp->init_block,sizeof(struct depca_init));
1619:
1620: printk("%s: depca open with irq %d\n",dev->name,dev->irq);
1621: printk("Descriptor head addresses:\n");
1622: printk("\t0x%lx 0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
1623: printk("Descriptor addresses:\nRX: ");
1624: for (i=0;i<lp->rxRingMask;i++){
1625: if (i < 3) {
1626: printk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
1627: }
1628: }
1629: printk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
1630: printk("TX: ");
1631: for (i=0;i<lp->txRingMask;i++){
1632: if (i < 3) {
1633: printk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
1634: }
1635: }
1636: printk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
1637: printk("\nDescriptor buffers:\nRX: ");
1638: for (i=0;i<lp->rxRingMask;i++){
1639: if (i < 3) {
1640: printk("0x%8.8x ", readl(&lp->rx_ring[i].base));
1641: }
1642: }
1643: printk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
1644: printk("TX: ");
1645: for (i=0;i<lp->txRingMask;i++){
1646: if (i < 3) {
1647: printk("0x%8.8x ", readl(&lp->tx_ring[i].base));
1648: }
1649: }
1650: printk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
1651: printk("Initialisation block at 0x%8.8lx\n",lp->sh_mem);
1652: printk("\tmode: 0x%4.4x\n",readw(&p->mode));
1653: printk("\tphysical address: ");
1654: for (i=0;i<ETH_ALEN-1;i++){
1655: printk("%2.2x:",(u_char)readb(&p->phys_addr[i]));
1656: }
1657: printk("%2.2x\n",(u_char)readb(&p->phys_addr[i]));
1658: printk("\tmulticast hash table: ");
1659: for (i=0;i<(HASH_TABLE_LEN >> 3)-1;i++){
1660: printk("%2.2x:",(u_char)readb(&p->mcast_table[i]));
1661: }
1662: printk("%2.2x\n",(u_char)readb(&p->mcast_table[i]));
1663: printk("\trx_ring at: 0x%8.8x\n",readl(&p->rx_ring));
1664: printk("\ttx_ring at: 0x%8.8x\n",readl(&p->tx_ring));
1665: printk("dma_buffs: 0x%8.8lx\n",lp->dma_buffs);
1666: printk("Ring size:\nRX: %d Log2(rxRingMask): 0x%8.8x\n",
1667: (int)lp->rxRingMask + 1,
1668: lp->rx_rlen);
1669: printk("TX: %d Log2(txRingMask): 0x%8.8x\n",
1670: (int)lp->txRingMask + 1,
1671: lp->tx_rlen);
1672: outw(CSR2,DEPCA_ADDR);
1673: printk("CSR2&1: 0x%4.4x",inw(DEPCA_DATA));
1674: outw(CSR1,DEPCA_ADDR);
1675: printk("%4.4x\n",inw(DEPCA_DATA));
1676: outw(CSR3,DEPCA_ADDR);
1677: printk("CSR3: 0x%4.4x\n",inw(DEPCA_DATA));
1678: }
1679:
1680: return;
1681: }
1682:
1683: /*
1684: ** Perform IOCTL call functions here. Some are privileged operations and the
1685: ** effective uid is checked in those cases.
1686: ** All MCA IOCTLs will not work here and are for testing purposes only.
1687: */
1688: static int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd)
1689: {
1690: struct depca_private *lp = (struct depca_private *)dev->priv;
1691: struct depca_ioctl *ioc = (struct depca_ioctl *) &rq->ifr_data;
1692: int i, status = 0;
1693: u_long ioaddr = dev->base_addr;
1694: union {
1695: u8 addr[(HASH_TABLE_LEN * ETH_ALEN)];
1696: u16 sval[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1697: u32 lval[(HASH_TABLE_LEN * ETH_ALEN) >> 2];
1698: } tmp;
1699:
1700: switch(ioc->cmd) {
1701: case DEPCA_GET_HWADDR: /* Get the hardware address */
1702: for (i=0; i<ETH_ALEN; i++) {
1703: tmp.addr[i] = dev->dev_addr[i];
1704: }
1705: ioc->len = ETH_ALEN;
1706: if (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
1707: memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1708: }
1709:
1710: break;
1711: case DEPCA_SET_HWADDR: /* Set the hardware address */
1712: if (suser()) {
1713: if (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN))) {
1714: memcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
1715: for (i=0; i<ETH_ALEN; i++) {
1716: dev->dev_addr[i] = tmp.addr[i];
1717: }
1718: while(dev->tbusy); /* Stop ring access */
1719: set_bit(0, (void*)&dev->tbusy);
1720: while(lp->tx_old != lp->tx_new);/* Wait for the ring to empty */
1721:
1722: STOP_DEPCA; /* Temporarily stop the depca. */
1723: depca_init_ring(dev); /* Initialize the descriptor rings */
1724: LoadCSRs(dev); /* Reload CSR3 */
1725: InitRestartDepca(dev); /* Resume normal operation. */
1726: dev->tbusy = 0; /* Unlock the TX ring */
1727: }
1728: } else {
1729: status = -EPERM;
1730: }
1731:
1732: break;
1733: case DEPCA_SET_PROM: /* Set Promiscuous Mode */
1734: if (suser()) {
1735: while(dev->tbusy); /* Stop ring access */
1736: set_bit(0, (void*)&dev->tbusy);
1737: while(lp->tx_old != lp->tx_new); /* Wait for the ring to empty */
1738:
1739: STOP_DEPCA; /* Temporarily stop the depca. */
1740: depca_init_ring(dev); /* Initialize the descriptor rings */
1741: lp->init_block.mode |= PROM; /* Set promiscuous mode */
1742:
1743: LoadCSRs(dev); /* Reload CSR3 */
1744: InitRestartDepca(dev); /* Resume normal operation. */
1745: dev->tbusy = 0; /* Unlock the TX ring */
1746: } else {
1747: status = -EPERM;
1748: }
1749:
1750: break;
1751: case DEPCA_CLR_PROM: /* Clear Promiscuous Mode */
1752: if (suser()) {
1753: while(dev->tbusy); /* Stop ring access */
1754: set_bit(0, (void*)&dev->tbusy);
1755: while(lp->tx_old != lp->tx_new); /* Wait for the ring to empty */
1756:
1757: STOP_DEPCA; /* Temporarily stop the depca. */
1758: depca_init_ring(dev); /* Initialize the descriptor rings */
1759: lp->init_block.mode &= ~PROM; /* Clear promiscuous mode */
1760:
1761: LoadCSRs(dev); /* Reload CSR3 */
1762: InitRestartDepca(dev); /* Resume normal operation. */
1763: dev->tbusy = 0; /* Unlock the TX ring */
1764: } else {
1765: status = -EPERM;
1766: }
1767:
1768: break;
1769: case DEPCA_SAY_BOO: /* Say "Boo!" to the kernel log file */
1770: printk("%s: Boo!\n", dev->name);
1771:
1772: break;
1773: case DEPCA_GET_MCA: /* Get the multicast address table */
1774: ioc->len = (HASH_TABLE_LEN >> 3);
1775: if (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
1776: memcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len);
1777: }
1778:
1779: break;
1780: case DEPCA_SET_MCA: /* Set a multicast address */
1781: if (suser()) {
1782: if (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
1783: memcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
1784: set_multicast_list(dev);
1785: }
1786: } else {
1787: status = -EPERM;
1788: }
1789:
1790: break;
1791: case DEPCA_CLR_MCA: /* Clear all multicast addresses */
1792: if (suser()) {
1793: set_multicast_list(dev);
1794: } else {
1795: status = -EPERM;
1796: }
1797:
1798: break;
1799: case DEPCA_MCA_EN: /* Enable pass all multicast addressing */
1800: if (suser()) {
1801: set_multicast_list(dev);
1802: } else {
1803: status = -EPERM;
1804: }
1805:
1806: break;
1807: case DEPCA_GET_STATS: /* Get the driver statistics */
1808: cli();
1809: ioc->len = sizeof(lp->pktStats);
1810: if (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
1811: memcpy_tofs(ioc->data, &lp->pktStats, ioc->len);
1812: }
1813: sti();
1814:
1815: break;
1816: case DEPCA_CLR_STATS: /* Zero out the driver statistics */
1817: if (suser()) {
1818: cli();
1819: memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1820: sti();
1821: } else {
1822: status = -EPERM;
1823: }
1824:
1825: break;
1826: case DEPCA_GET_REG: /* Get the DEPCA Registers */
1827: i=0;
1828: tmp.sval[i++] = inw(DEPCA_NICSR);
1829: outw(CSR0, DEPCA_ADDR); /* status register */
1830: tmp.sval[i++] = inw(DEPCA_DATA);
1831: memcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
1832: ioc->len = i+sizeof(struct depca_init);
1833: if (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
1834: memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1835: }
1836:
1837: break;
1838: default:
1839: status = -EOPNOTSUPP;
1840: }
1841:
1842: return status;
1843: }
1844:
1845: #ifdef MODULE
1846: static char devicename[9] = { 0, };
1847: static struct device thisDepca = {
1848: devicename, /* device name is inserted by /linux/drivers/net/net_init.c */
1849: 0, 0, 0, 0,
1850: 0x200, 7, /* I/O address, IRQ */
1851: 0, 0, 0, NULL, depca_probe };
1852:
1853: static int irq=7; /* EDIT THESE LINE FOR YOUR CONFIGURATION */
1854: static int io=0x200; /* Or use the irq= io= options to insmod */
1855:
1856: /* See depca_probe() for autoprobe messages when a module */
1857: int
1858: init_module(void)
1859: {
1860: thisDepca.irq=irq;
1861: thisDepca.base_addr=io;
1862:
1863: if (register_netdev(&thisDepca) != 0)
1864: return -EIO;
1865:
1866: return 0;
1867: }
1868:
1869: void
1870: cleanup_module(void)
1871: {
1872: if (thisDepca.priv) {
1873: kfree(thisDepca.priv);
1874: thisDepca.priv = NULL;
1875: }
1876: thisDepca.irq=0;
1877:
1878: unregister_netdev(&thisDepca);
1879: release_region(thisDepca.base_addr, DEPCA_TOTAL_SIZE);
1880: }
1881: #endif /* MODULE */
1882:
1883:
1884: /*
1885: * Local variables:
1886: * compile-command: "gcc -D__KERNEL__ -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c depca.c"
1887: *
1888: * compile-command: "gcc -D__KERNEL__ -DMODULE -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c depca.c"
1889: * End:
1890: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.