blob: c771de71612a8f75d82dc11e2ca629015c7c78da [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -04007 and
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 United States Government
Jeff Garzik6aa20a22006-09-13 13:24:59 -04009 (as represented by the Director, National Security Agency).
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11 Copyright 1995 Digital Equipment Corporation.
12
13
14 This software may be used and distributed according to the terms of
15 the GNU General 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 davies@maniac.ultranet.com
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040064
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
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]
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400138 6) run the net startup bits for your eth?? interface manually
139 (usually /etc/rc.inet[12] at boot time).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400145 To unload a module, turn off the associated interface
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 '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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400151 option will not work with kernel built-in depca's.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
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 ************************************************************************
Paul Gortmakera5e371f2012-05-16 19:48:42 -0400158 Support for MCA EtherWORKS cards added 11-3-98. (MCA since deleted)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 Verified to work with up to 2 DE212 cards in a system (although not
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400160 fully stress-tested).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 Revision History
163 ----------------
164
165 Version Date Description
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 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 murf@perftech.com
174 and becker@super.org
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400180 0.38 15-aug-94 Added DBR ROM switch in depca_close().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 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 <bkm@star.rl.ac.uk>.
185 0.383 22-feb-95 Fix for conflict with VESA SCSI reported by
186 <stromain@alf.dec.com>
187 0.384 17-mar-95 Fix a ring full bug reported by <bkm@star.rl.ac.uk>
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400188 0.385 3-apr-95 Fix a recognition bug reported by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 <ryan.niemi@lastfrontier.com>
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 <jestabro@amt.tay1.dec.com>
193 0.41 26-Jun-95 Added verify_area() calls in depca_ioctl() from
194 suggestion by <heiko@colossus.escape.de>
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400195 0.42 27-Dec-95 Add 'mem' shared memory assignment for loadable
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 modules.
197 Add 'adapter_name' for loadable modules when no PROM.
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400198 Both above from a suggestion by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 <pchen@woodruffs121.residence.gatech.edu>.
200 Add new multicasting code.
201 0.421 22-Apr-96 Fix alloc_device() bug <jari@markkus2.fimr.fi>
202 0.422 29-Apr-96 Fix depca_hw_init() bug <jari@markkus2.fimr.fi>
203 0.423 7-Jun-96 Fix module load bug <kmg@barco.be>
204 0.43 16-Aug-96 Update alloc_device() to conform to de4x5.c
205 0.44 1-Sep-97 Fix *_probe() to test check_region() first - bug
206 reported by <mmogilvi@elbert.uccs.edu>
207 0.45 3-Nov-98 Added support for MCA EtherWORKS (DE210/DE212) cards
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400208 by <tymm@computer.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 0.451 5-Nov-98 Fixed mca stuff cuz I'm a dummy. <tymm@computer.org>
210 0.5 14-Nov-98 Re-spin for 2.1.x kernels.
211 0.51 27-Jun-99 Correct received packet length for CRC from
212 report by <worm@dkik.dk>
213 0.52 16-Oct-00 Fixes for 2.3 io memory accesses
214 Fix show-stopper (ints left masked) in depca_interrupt
215 by <peterd@pnd-pc.demon.co.uk>
216 0.53 12-Jan-01 Release resources on failure, bss tidbits
217 by acme@conectiva.com.br
218 0.54 08-Nov-01 use library crc32 functions
219 by Matt_Domsch@dell.com
220 0.55 01-Mar-03 Use EISA/sysfs framework <maz@wild-wind.fr.eu.org>
221
222 =========================================================================
223*/
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225#include <linux/module.h>
226#include <linux/kernel.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +0400227#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228#include <linux/string.h>
229#include <linux/errno.h>
230#include <linux/ioport.h>
231#include <linux/slab.h>
232#include <linux/interrupt.h>
233#include <linux/delay.h>
234#include <linux/init.h>
235#include <linux/crc32.h>
236#include <linux/netdevice.h>
237#include <linux/etherdevice.h>
238#include <linux/skbuff.h>
239#include <linux/time.h>
240#include <linux/types.h>
241#include <linux/unistd.h>
242#include <linux/ctype.h>
243#include <linux/moduleparam.h>
Russell Kingd052d1b2005-10-29 19:07:23 +0100244#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245#include <linux/bitops.h>
246
247#include <asm/uaccess.h>
248#include <asm/io.h>
249#include <asm/dma.h>
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251#ifdef CONFIG_EISA
252#include <linux/eisa.h>
253#endif
254
255#include "depca.h"
256
257static char version[] __initdata = "depca.c:v0.53 2001/1/12 davies@maniac.ultranet.com\n";
258
259#ifdef DEPCA_DEBUG
260static int depca_debug = DEPCA_DEBUG;
261#else
262static int depca_debug = 1;
263#endif
264
265#define DEPCA_NDA 0xffe0 /* No Device Address */
266
267#define TX_TIMEOUT (1*HZ)
268
269/*
270** Ethernet PROM defines
271*/
272#define PROBE_LENGTH 32
273#define ETH_PROM_SIG 0xAA5500FFUL
274
275/*
276** Set the number of Tx and Rx buffers. Ensure that the memory requested
277** here is <= to the amount of shared memory set up by the board switches.
278** The number of descriptors MUST BE A POWER OF 2.
279**
280** total_memory = NUM_RX_DESC*(8+RX_BUFF_SZ) + NUM_TX_DESC*(8+TX_BUFF_SZ)
281*/
282#define NUM_RX_DESC 8 /* Number of RX descriptors */
283#define NUM_TX_DESC 8 /* Number of TX descriptors */
284#define RX_BUFF_SZ 1536 /* Buffer size for each Rx buffer */
285#define TX_BUFF_SZ 1536 /* Buffer size for each Tx buffer */
286
287/*
288** EISA bus defines
289*/
290#define DEPCA_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
291
292/*
293** ISA Bus defines
294*/
295#define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
296#define DEPCA_TOTAL_SIZE 0x10
297
298static struct {
299 u_long iobase;
300 struct platform_device *device;
301} depca_io_ports[] = {
302 { 0x300, NULL },
303 { 0x200, NULL },
304 { 0 , NULL },
305};
306
307/*
308** Name <-> Adapter mapping
309*/
310#define DEPCA_SIGNATURE {"DEPCA",\
311 "DE100","DE101",\
312 "DE200","DE201","DE202",\
313 "DE210","DE212",\
314 "DE422",\
315 ""}
316
David S. Miller948252c2011-05-31 19:27:48 -0700317static char* __initdata depca_signature[] = DEPCA_SIGNATURE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319enum depca_type {
320 DEPCA, de100, de101, de200, de201, de202, de210, de212, de422, unknown
321};
322
David S. Miller948252c2011-05-31 19:27:48 -0700323static char depca_string[] = "depca";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325static int depca_device_remove (struct device *device);
326
327#ifdef CONFIG_EISA
David S. Miller948252c2011-05-31 19:27:48 -0700328static struct eisa_device_id depca_eisa_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 { "DEC4220", de422 },
330 { "" }
331};
332MODULE_DEVICE_TABLE(eisa, depca_eisa_ids);
333
334static int depca_eisa_probe (struct device *device);
335
336static struct eisa_driver depca_eisa_driver = {
337 .id_table = depca_eisa_ids,
338 .driver = {
339 .name = depca_string,
340 .probe = depca_eisa_probe,
341 .remove = __devexit_p (depca_device_remove)
342 }
343};
344#endif
345
Russell King3ae5eae2005-11-09 22:32:44 +0000346static int depca_isa_probe (struct platform_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Russell King3ae5eae2005-11-09 22:32:44 +0000348static int __devexit depca_isa_remove(struct platform_device *pdev)
349{
350 return depca_device_remove(&pdev->dev);
351}
352
353static struct platform_driver depca_isa_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 .probe = depca_isa_probe,
Russell King3ae5eae2005-11-09 22:32:44 +0000355 .remove = __devexit_p(depca_isa_remove),
356 .driver = {
357 .name = depca_string,
358 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359};
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361/*
362** Miscellaneous info...
363*/
364#define DEPCA_STRLEN 16
365
366/*
367** Memory Alignment. Each descriptor is 4 longwords long. To force a
368** particular alignment on the TX descriptor, adjust DESC_SKIP_LEN and
369** DESC_ALIGN. DEPCA_ALIGN aligns the start address of the private memory area
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400370** and hence the RX descriptor ring's first entry.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371*/
372#define DEPCA_ALIGN4 ((u_long)4 - 1) /* 1 longword align */
373#define DEPCA_ALIGN8 ((u_long)8 - 1) /* 2 longword (quadword) align */
374#define DEPCA_ALIGN DEPCA_ALIGN8 /* Keep the LANCE happy... */
375
376/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400377** The DEPCA Rx and Tx ring descriptors.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378*/
379struct depca_rx_desc {
380 volatile s32 base;
381 s16 buf_length; /* This length is negative 2's complement! */
382 s16 msg_length; /* This length is "normal". */
383};
384
385struct depca_tx_desc {
386 volatile s32 base;
387 s16 length; /* This length is negative 2's complement! */
388 s16 misc; /* Errors and TDR info */
389};
390
391#define LA_MASK 0x0000ffff /* LANCE address mask for mapping network RAM
392 to LANCE memory address space */
393
394/*
395** The Lance initialization block, described in databook, in common memory.
396*/
397struct depca_init {
398 u16 mode; /* Mode register */
399 u8 phys_addr[ETH_ALEN]; /* Physical ethernet address */
400 u8 mcast_table[8]; /* Multicast Hash Table. */
401 u32 rx_ring; /* Rx ring base pointer & ring length */
402 u32 tx_ring; /* Tx ring base pointer & ring length */
403};
404
405#define DEPCA_PKT_STAT_SZ 16
406#define DEPCA_PKT_BIN_SZ 128 /* Should be >=100 unless you
407 increase DEPCA_PKT_STAT_SZ */
408struct depca_private {
409 char adapter_name[DEPCA_STRLEN]; /* /proc/ioports string */
410 enum depca_type adapter; /* Adapter type */
411 enum {
Paul Gortmakera5e371f2012-05-16 19:48:42 -0400412 DEPCA_BUS_ISA = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 DEPCA_BUS_EISA,
414 } depca_bus; /* type of bus */
415 struct depca_init init_block; /* Shadow Initialization block */
416/* CPU address space fields */
417 struct depca_rx_desc __iomem *rx_ring; /* Pointer to start of RX descriptor ring */
418 struct depca_tx_desc __iomem *tx_ring; /* Pointer to start of TX descriptor ring */
419 void __iomem *rx_buff[NUM_RX_DESC]; /* CPU virt address of sh'd memory buffs */
420 void __iomem *tx_buff[NUM_TX_DESC]; /* CPU virt address of sh'd memory buffs */
421 void __iomem *sh_mem; /* CPU mapped virt address of device RAM */
422 u_long mem_start; /* Bus address of device RAM (before remap) */
423 u_long mem_len; /* device memory size */
424/* Device address space fields */
425 u_long device_ram_start; /* Start of RAM in device addr space */
426/* Offsets used in both address spaces */
427 u_long rx_ring_offset; /* Offset from start of RAM to rx_ring */
428 u_long tx_ring_offset; /* Offset from start of RAM to tx_ring */
429 u_long buffs_offset; /* LANCE Rx and Tx buffers start address. */
430/* Kernel-only (not device) fields */
431 int rx_new, tx_new; /* The next free ring entry */
432 int rx_old, tx_old; /* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 spinlock_t lock;
434 struct { /* Private stats counters */
435 u32 bins[DEPCA_PKT_STAT_SZ];
436 u32 unicast;
437 u32 multicast;
438 u32 broadcast;
439 u32 excessive_collisions;
440 u32 tx_underruns;
441 u32 excessive_underruns;
442 } pktStats;
443 int txRingMask; /* TX ring mask */
444 int rxRingMask; /* RX ring mask */
445 s32 rx_rlen; /* log2(rxRingMask+1) for the descriptors */
446 s32 tx_rlen; /* log2(txRingMask+1) for the descriptors */
447};
448
449/*
450** The transmit ring full condition is described by the tx_old and tx_new
451** pointers by:
452** tx_old = tx_new Empty ring
453** tx_old = tx_new+1 Full ring
454** tx_old+txRingMask = tx_new Full ring (wrapped condition)
455*/
456#define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
457 lp->tx_old+lp->txRingMask-lp->tx_new:\
458 lp->tx_old -lp->tx_new-1)
459
460/*
461** Public Functions
462*/
463static int depca_open(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000464static netdev_tx_t depca_start_xmit(struct sk_buff *skb,
465 struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100466static irqreturn_t depca_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467static int depca_close(struct net_device *dev);
468static int depca_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
469static void depca_tx_timeout(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470static void set_multicast_list(struct net_device *dev);
471
472/*
473** Private functions
474*/
475static void depca_init_ring(struct net_device *dev);
476static int depca_rx(struct net_device *dev);
477static int depca_tx(struct net_device *dev);
478
479static void LoadCSRs(struct net_device *dev);
480static int InitRestartDepca(struct net_device *dev);
481static int DepcaSignature(char *name, u_long paddr);
482static int DevicePresent(u_long ioaddr);
483static int get_hw_addr(struct net_device *dev);
484static void SetMulticastFilter(struct net_device *dev);
485static int load_packet(struct net_device *dev, struct sk_buff *skb);
486static void depca_dbg_open(struct net_device *dev);
487
David S. Miller948252c2011-05-31 19:27:48 -0700488static u_char de1xx_irq[] __initdata = { 2, 3, 4, 5, 7, 9, 0 };
489static u_char de2xx_irq[] __initdata = { 5, 9, 10, 11, 15, 0 };
490static u_char de422_irq[] __initdata = { 5, 9, 10, 11, 0 };
491static u_char *depca_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493static int irq;
494static int io;
495static char *adapter_name;
496static int mem; /* For loadable module assignment
497 use insmod mem=0x????? .... */
498module_param (irq, int, 0);
499module_param (io, int, 0);
500module_param (adapter_name, charp, 0);
501module_param (mem, int, 0);
502MODULE_PARM_DESC(irq, "DEPCA IRQ number");
503MODULE_PARM_DESC(io, "DEPCA I/O base address");
504MODULE_PARM_DESC(adapter_name, "DEPCA adapter name");
505MODULE_PARM_DESC(mem, "DEPCA shared memory address");
506MODULE_LICENSE("GPL");
507
508/*
509** Miscellaneous defines...
510*/
511#define STOP_DEPCA \
512 outw(CSR0, DEPCA_ADDR);\
513 outw(STOP, DEPCA_DATA)
514
Stephen Hemminger361bc032009-03-26 15:11:37 +0000515static const struct net_device_ops depca_netdev_ops = {
516 .ndo_open = depca_open,
517 .ndo_start_xmit = depca_start_xmit,
518 .ndo_stop = depca_close,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000519 .ndo_set_rx_mode = set_multicast_list,
Stephen Hemminger361bc032009-03-26 15:11:37 +0000520 .ndo_do_ioctl = depca_ioctl,
521 .ndo_tx_timeout = depca_tx_timeout,
522 .ndo_change_mtu = eth_change_mtu,
523 .ndo_set_mac_address = eth_mac_addr,
524 .ndo_validate_addr = eth_validate_addr,
525};
526
David S. Miller948252c2011-05-31 19:27:48 -0700527static int __init depca_hw_init (struct net_device *dev, struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
529 struct depca_private *lp;
530 int i, j, offset, netRAM, mem_len, status = 0;
531 s16 nicsr;
532 u_long ioaddr;
533 u_long mem_start;
534
535 /*
536 * We are now supposed to enter this function with the
537 * following fields filled with proper values :
538 *
539 * dev->base_addr
540 * lp->mem_start
541 * lp->depca_bus
542 * lp->adapter
543 *
544 * dev->irq can be set if known from device configuration (on
545 * MCA or EISA) or module option. Otherwise, it will be auto
546 * detected.
547 */
548
549 ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 STOP_DEPCA;
552
553 nicsr = inb(DEPCA_NICSR);
554 nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
555 outb(nicsr, DEPCA_NICSR);
556
557 if (inw(DEPCA_DATA) != STOP) {
558 return -ENXIO;
559 }
560
Wang Chen4cf16532008-11-12 23:38:14 -0800561 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 mem_start = lp->mem_start;
563
564 if (!mem_start || lp->adapter < DEPCA || lp->adapter >=unknown)
565 return -ENXIO;
566
Kay Sieversc2313552009-03-24 16:38:22 -0700567 printk("%s: %s at 0x%04lx",
568 dev_name(device), depca_signature[lp->adapter], ioaddr);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 switch (lp->depca_bus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571#ifdef CONFIG_EISA
572 case DEPCA_BUS_EISA:
573 printk(" (EISA slot %d)", to_eisa_device(device)->slot);
574 break;
575#endif
576
577 case DEPCA_BUS_ISA:
578 break;
579
580 default:
581 printk("Unknown DEPCA bus %d\n", lp->depca_bus);
582 return -ENXIO;
583 }
584
585 printk(", h/w address ");
586 status = get_hw_addr(dev);
Johannes Berge1749612008-10-27 15:59:26 -0700587 printk("%pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (status != 0) {
589 printk(" which has an Ethernet PROM CRC error.\n");
590 return -ENXIO;
591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 /* Set up the maximum amount of network RAM(kB) */
594 netRAM = ((lp->adapter != DEPCA) ? 64 : 48);
595 if ((nicsr & _128KB) && (lp->adapter == de422))
596 netRAM = 128;
597
598 /* Shared Memory Base Address */
599 if (nicsr & BUF) {
600 nicsr &= ~BS; /* DEPCA RAM in top 32k */
601 netRAM -= 32;
Paul Gortmakera5e371f2012-05-16 19:48:42 -0400602 mem_start += 0x8000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if ((mem_len = (NUM_RX_DESC * (sizeof(struct depca_rx_desc) + RX_BUFF_SZ) + NUM_TX_DESC * (sizeof(struct depca_tx_desc) + TX_BUFF_SZ) + sizeof(struct depca_init)))
606 > (netRAM << 10)) {
607 printk(",\n requests %dkB RAM: only %dkB is available!\n", (mem_len >> 10), netRAM);
608 return -ENXIO;
609 }
610
611 printk(",\n has %dkB RAM at 0x%.5lx", netRAM, mem_start);
612
613 /* Enable the shadow RAM. */
614 if (lp->adapter != DEPCA) {
615 nicsr |= SHE;
616 outb(nicsr, DEPCA_NICSR);
617 }
618
619 spin_lock_init(&lp->lock);
620 sprintf(lp->adapter_name, "%s (%s)",
Kay Sieversc2313552009-03-24 16:38:22 -0700621 depca_signature[lp->adapter], dev_name(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 status = -EBUSY;
623
624 /* Initialisation Block */
625 if (!request_mem_region (mem_start, mem_len, lp->adapter_name)) {
626 printk(KERN_ERR "depca: cannot request ISA memory, aborting\n");
627 goto out_priv;
628 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 status = -EIO;
631 lp->sh_mem = ioremap(mem_start, mem_len);
632 if (lp->sh_mem == NULL) {
633 printk(KERN_ERR "depca: cannot remap ISA memory, aborting\n");
634 goto out1;
635 }
636
637 lp->mem_start = mem_start;
638 lp->mem_len = mem_len;
639 lp->device_ram_start = mem_start & LA_MASK;
640
641 offset = 0;
642 offset += sizeof(struct depca_init);
643
644 /* Tx & Rx descriptors (aligned to a quadword boundary) */
645 offset = (offset + DEPCA_ALIGN) & ~DEPCA_ALIGN;
Joe Perches43d620c2011-06-16 19:08:06 +0000646 lp->rx_ring = lp->sh_mem + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 lp->rx_ring_offset = offset;
648
649 offset += (sizeof(struct depca_rx_desc) * NUM_RX_DESC);
Joe Perches43d620c2011-06-16 19:08:06 +0000650 lp->tx_ring = lp->sh_mem + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 lp->tx_ring_offset = offset;
652
653 offset += (sizeof(struct depca_tx_desc) * NUM_TX_DESC);
654
655 lp->buffs_offset = offset;
656
657 /* Finish initialising the ring information. */
658 lp->rxRingMask = NUM_RX_DESC - 1;
659 lp->txRingMask = NUM_TX_DESC - 1;
660
661 /* Calculate Tx/Rx RLEN size for the descriptors. */
662 for (i = 0, j = lp->rxRingMask; j > 0; i++) {
663 j >>= 1;
664 }
665 lp->rx_rlen = (s32) (i << 29);
666 for (i = 0, j = lp->txRingMask; j > 0; i++) {
667 j >>= 1;
668 }
669 lp->tx_rlen = (s32) (i << 29);
670
671 /* Load the initialisation block */
672 depca_init_ring(dev);
673
674 /* Initialise the control and status registers */
675 LoadCSRs(dev);
676
677 /* Enable DEPCA board interrupts for autoprobing */
678 nicsr = ((nicsr & ~IM) | IEN);
679 outb(nicsr, DEPCA_NICSR);
680
681 /* To auto-IRQ we enable the initialization-done and DMA err,
682 interrupts. For now we will always get a DMA error. */
683 if (dev->irq < 2) {
684 unsigned char irqnum;
685 unsigned long irq_mask, delay;
686
687 irq_mask = probe_irq_on();
688
689 /* Assign the correct irq list */
690 switch (lp->adapter) {
691 case DEPCA:
692 case de100:
693 case de101:
694 depca_irq = de1xx_irq;
695 break;
696 case de200:
697 case de201:
698 case de202:
699 case de210:
700 case de212:
701 depca_irq = de2xx_irq;
702 break;
703 case de422:
704 depca_irq = de422_irq;
705 break;
706
707 default:
708 break; /* Not reached */
709 }
710
711 /* Trigger an initialization just for the interrupt. */
712 outw(INEA | INIT, DEPCA_DATA);
713
714 delay = jiffies + HZ/50;
715 while (time_before(jiffies, delay))
716 yield();
717
718 irqnum = probe_irq_off(irq_mask);
719
720 status = -ENXIO;
721 if (!irqnum) {
722 printk(" and failed to detect IRQ line.\n");
723 goto out2;
724 } else {
725 for (dev->irq = 0, i = 0; (depca_irq[i]) && (!dev->irq); i++)
726 if (irqnum == depca_irq[i]) {
727 dev->irq = irqnum;
728 printk(" and uses IRQ%d.\n", dev->irq);
729 }
730
731 if (!dev->irq) {
732 printk(" but incorrect IRQ line detected.\n");
733 goto out2;
734 }
735 }
736 } else {
737 printk(" and assigned IRQ%d.\n", dev->irq);
738 }
739
740 if (depca_debug > 1) {
741 printk(version);
742 }
743
744 /* The DEPCA-specific entries in the device structure. */
Stephen Hemminger361bc032009-03-26 15:11:37 +0000745 dev->netdev_ops = &depca_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 dev->watchdog_timeo = TX_TIMEOUT;
747
748 dev->mem_start = 0;
749
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000750 dev_set_drvdata(device, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 SET_NETDEV_DEV (dev, device);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400752
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 status = register_netdev(dev);
754 if (status == 0)
755 return 0;
756out2:
757 iounmap(lp->sh_mem);
758out1:
759 release_mem_region (mem_start, mem_len);
760out_priv:
761 return status;
762}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765static int depca_open(struct net_device *dev)
766{
Wang Chen4cf16532008-11-12 23:38:14 -0800767 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 u_long ioaddr = dev->base_addr;
769 s16 nicsr;
770 int status = 0;
771
772 STOP_DEPCA;
773 nicsr = inb(DEPCA_NICSR);
774
775 /* Make sure the shadow RAM is enabled */
776 if (lp->adapter != DEPCA) {
777 nicsr |= SHE;
778 outb(nicsr, DEPCA_NICSR);
779 }
780
781 /* Re-initialize the DEPCA... */
782 depca_init_ring(dev);
783 LoadCSRs(dev);
784
785 depca_dbg_open(dev);
786
Joe Perchesa0607fd2009-11-18 23:29:17 -0800787 if (request_irq(dev->irq, depca_interrupt, 0, lp->adapter_name, dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 printk("depca_open(): Requested IRQ%d is busy\n", dev->irq);
789 status = -EAGAIN;
790 } else {
791
792 /* Enable DEPCA board interrupts and turn off LED */
793 nicsr = ((nicsr & ~IM & ~LED) | IEN);
794 outb(nicsr, DEPCA_NICSR);
795 outw(CSR0, DEPCA_ADDR);
796
797 netif_start_queue(dev);
798
799 status = InitRestartDepca(dev);
800
801 if (depca_debug > 1) {
802 printk("CSR0: 0x%4.4x\n", inw(DEPCA_DATA));
803 printk("nicsr: 0x%02x\n", inb(DEPCA_NICSR));
804 }
805 }
806 return status;
807}
808
809/* Initialize the lance Rx and Tx descriptor rings. */
810static void depca_init_ring(struct net_device *dev)
811{
Wang Chen4cf16532008-11-12 23:38:14 -0800812 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 u_int i;
814 u_long offset;
815
816 /* Lock out other processes whilst setting up the hardware */
817 netif_stop_queue(dev);
818
819 lp->rx_new = lp->tx_new = 0;
820 lp->rx_old = lp->tx_old = 0;
821
822 /* Initialize the base address and length of each buffer in the ring */
823 for (i = 0; i <= lp->rxRingMask; i++) {
824 offset = lp->buffs_offset + i * RX_BUFF_SZ;
825 writel((lp->device_ram_start + offset) | R_OWN, &lp->rx_ring[i].base);
826 writew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
827 lp->rx_buff[i] = lp->sh_mem + offset;
828 }
829
830 for (i = 0; i <= lp->txRingMask; i++) {
831 offset = lp->buffs_offset + (i + lp->rxRingMask + 1) * TX_BUFF_SZ;
832 writel((lp->device_ram_start + offset) & 0x00ffffff, &lp->tx_ring[i].base);
833 lp->tx_buff[i] = lp->sh_mem + offset;
834 }
835
836 /* Set up the initialization block */
837 lp->init_block.rx_ring = (lp->device_ram_start + lp->rx_ring_offset) | lp->rx_rlen;
838 lp->init_block.tx_ring = (lp->device_ram_start + lp->tx_ring_offset) | lp->tx_rlen;
839
840 SetMulticastFilter(dev);
841
842 for (i = 0; i < ETH_ALEN; i++) {
843 lp->init_block.phys_addr[i] = dev->dev_addr[i];
844 }
845
846 lp->init_block.mode = 0x0000; /* Enable the Tx and Rx */
847}
848
849
850static void depca_tx_timeout(struct net_device *dev)
851{
852 u_long ioaddr = dev->base_addr;
853
854 printk("%s: transmit timed out, status %04x, resetting.\n", dev->name, inw(DEPCA_DATA));
855
856 STOP_DEPCA;
857 depca_init_ring(dev);
858 LoadCSRs(dev);
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700859 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 netif_wake_queue(dev);
861 InitRestartDepca(dev);
862}
863
864
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400865/*
866** Writes a socket buffer to TX descriptor ring and starts transmission
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867*/
Stephen Hemminger613573252009-08-31 19:50:58 +0000868static netdev_tx_t depca_start_xmit(struct sk_buff *skb,
869 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
Wang Chen4cf16532008-11-12 23:38:14 -0800871 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 u_long ioaddr = dev->base_addr;
873 int status = 0;
874
875 /* Transmitter timeout, serious problems. */
876 if (skb->len < 1)
877 goto out;
878
Herbert Xu5b057c62006-06-23 02:06:41 -0700879 if (skb_padto(skb, ETH_ZLEN))
880 goto out;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400881
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 netif_stop_queue(dev);
883
884 if (TX_BUFFS_AVAIL) { /* Fill in a Tx ring entry */
885 status = load_packet(dev, skb);
886
887 if (!status) {
888 /* Trigger an immediate send demand. */
889 outw(CSR0, DEPCA_ADDR);
890 outw(INEA | TDMD, DEPCA_DATA);
891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 dev_kfree_skb(skb);
893 }
894 if (TX_BUFFS_AVAIL)
895 netif_start_queue(dev);
896 } else
Patrick McHardy5b548142009-06-12 06:22:29 +0000897 status = NETDEV_TX_LOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899 out:
900 return status;
901}
902
903/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400904** The DEPCA interrupt handler.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905*/
David Howells7d12e782006-10-05 14:55:46 +0100906static irqreturn_t depca_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907{
908 struct net_device *dev = dev_id;
909 struct depca_private *lp;
910 s16 csr0, nicsr;
911 u_long ioaddr;
912
913 if (dev == NULL) {
914 printk("depca_interrupt(): irq %d for unknown device.\n", irq);
915 return IRQ_NONE;
916 }
917
Wang Chen4cf16532008-11-12 23:38:14 -0800918 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 ioaddr = dev->base_addr;
920
921 spin_lock(&lp->lock);
922
923 /* mask the DEPCA board interrupts and turn on the LED */
924 nicsr = inb(DEPCA_NICSR);
925 nicsr |= (IM | LED);
926 outb(nicsr, DEPCA_NICSR);
927
928 outw(CSR0, DEPCA_ADDR);
929 csr0 = inw(DEPCA_DATA);
930
931 /* Acknowledge all of the current interrupt sources ASAP. */
932 outw(csr0 & INTE, DEPCA_DATA);
933
934 if (csr0 & RINT) /* Rx interrupt (packet arrived) */
935 depca_rx(dev);
936
937 if (csr0 & TINT) /* Tx interrupt (packet sent) */
938 depca_tx(dev);
939
940 /* Any resources available? */
941 if ((TX_BUFFS_AVAIL >= 0) && netif_queue_stopped(dev)) {
942 netif_wake_queue(dev);
943 }
944
945 /* Unmask the DEPCA board interrupts and turn off the LED */
946 nicsr = (nicsr & ~IM & ~LED);
947 outb(nicsr, DEPCA_NICSR);
948
949 spin_unlock(&lp->lock);
950 return IRQ_HANDLED;
951}
952
953/* Called with lp->lock held */
954static int depca_rx(struct net_device *dev)
955{
Wang Chen4cf16532008-11-12 23:38:14 -0800956 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 int i, entry;
958 s32 status;
959
960 for (entry = lp->rx_new; !(readl(&lp->rx_ring[entry].base) & R_OWN); entry = lp->rx_new) {
961 status = readl(&lp->rx_ring[entry].base) >> 16;
962 if (status & R_STP) { /* Remember start of frame */
963 lp->rx_old = entry;
964 }
965 if (status & R_ENP) { /* Valid frame status */
966 if (status & R_ERR) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700967 dev->stats.rx_errors++; /* Update the error stats. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 if (status & R_FRAM)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700969 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 if (status & R_OFLO)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700971 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 if (status & R_CRC)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700973 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 if (status & R_BUFF)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700975 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 } else {
977 short len, pkt_len = readw(&lp->rx_ring[entry].msg_length) - 4;
978 struct sk_buff *skb;
979
Pradeep A Dalvi1d266432012-02-05 02:49:09 +0000980 skb = netdev_alloc_skb(dev, pkt_len + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 if (skb != NULL) {
982 unsigned char *buf;
983 skb_reserve(skb, 2); /* 16 byte align the IP header */
984 buf = skb_put(skb, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 if (entry < lp->rx_old) { /* Wrapped buffer */
986 len = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
987 memcpy_fromio(buf, lp->rx_buff[lp->rx_old], len);
988 memcpy_fromio(buf + len, lp->rx_buff[0], pkt_len - len);
989 } else { /* Linear buffer */
990 memcpy_fromio(buf, lp->rx_buff[lp->rx_old], pkt_len);
991 }
992
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400993 /*
994 ** Notify the upper protocol layers that there is another
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 ** packet to handle
996 */
997 skb->protocol = eth_type_trans(skb, dev);
998 netif_rx(skb);
999
1000 /*
1001 ** Update stats
1002 */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001003 dev->stats.rx_packets++;
1004 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 for (i = 1; i < DEPCA_PKT_STAT_SZ - 1; i++) {
1006 if (pkt_len < (i * DEPCA_PKT_BIN_SZ)) {
1007 lp->pktStats.bins[i]++;
1008 i = DEPCA_PKT_STAT_SZ;
1009 }
1010 }
Tobias Klauser2effca32011-07-03 23:55:53 +00001011 if (is_multicast_ether_addr(buf)) {
1012 if (is_broadcast_ether_addr(buf)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 lp->pktStats.broadcast++;
1014 } else {
1015 lp->pktStats.multicast++;
1016 }
Joe Perches2e42e472012-05-09 17:17:46 +00001017 } else if (ether_addr_equal(buf,
1018 dev->dev_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 lp->pktStats.unicast++;
1020 }
1021
1022 lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
1023 if (lp->pktStats.bins[0] == 0) { /* Reset counters */
1024 memset((char *) &lp->pktStats, 0, sizeof(lp->pktStats));
1025 }
1026 } else {
1027 printk("%s: Memory squeeze, deferring packet.\n", dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001028 dev->stats.rx_dropped++; /* Really, deferred. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 break;
1030 }
1031 }
1032 /* Change buffer ownership for this last frame, back to the adapter */
Alan Coxf97f3052011-02-01 13:19:07 -08001033 for (; lp->rx_old != entry; lp->rx_old = (lp->rx_old + 1) & lp->rxRingMask) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 writel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, &lp->rx_ring[lp->rx_old].base);
1035 }
1036 writel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
1037 }
1038
1039 /*
1040 ** Update entry information
1041 */
Alan Coxf97f3052011-02-01 13:19:07 -08001042 lp->rx_new = (lp->rx_new + 1) & lp->rxRingMask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 }
1044
1045 return 0;
1046}
1047
1048/*
1049** Buffer sent - check for buffer errors.
1050** Called with lp->lock held
1051*/
1052static int depca_tx(struct net_device *dev)
1053{
Wang Chen4cf16532008-11-12 23:38:14 -08001054 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 int entry;
1056 s32 status;
1057 u_long ioaddr = dev->base_addr;
1058
1059 for (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
1060 status = readl(&lp->tx_ring[entry].base) >> 16;
1061
1062 if (status < 0) { /* Packet not yet sent! */
1063 break;
1064 } else if (status & T_ERR) { /* An error occurred. */
1065 status = readl(&lp->tx_ring[entry].misc);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001066 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 if (status & TMD3_RTRY)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001068 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (status & TMD3_LCAR)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001070 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 if (status & TMD3_LCOL)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001072 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 if (status & TMD3_UFLO)
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001074 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (status & (TMD3_BUFF | TMD3_UFLO)) {
1076 /* Trigger an immediate send demand. */
1077 outw(CSR0, DEPCA_ADDR);
1078 outw(INEA | TDMD, DEPCA_DATA);
1079 }
1080 } else if (status & (T_MORE | T_ONE)) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001081 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 } else {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001083 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 }
1085
1086 /* Update all the pointers */
Alan Coxf97f3052011-02-01 13:19:07 -08001087 lp->tx_old = (lp->tx_old + 1) & lp->txRingMask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 }
1089
1090 return 0;
1091}
1092
1093static int depca_close(struct net_device *dev)
1094{
Wang Chen4cf16532008-11-12 23:38:14 -08001095 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 s16 nicsr;
1097 u_long ioaddr = dev->base_addr;
1098
1099 netif_stop_queue(dev);
1100
1101 outw(CSR0, DEPCA_ADDR);
1102
1103 if (depca_debug > 1) {
1104 printk("%s: Shutting down ethercard, status was %2.2x.\n", dev->name, inw(DEPCA_DATA));
1105 }
1106
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001107 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 ** We stop the DEPCA here -- it occasionally polls
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001109 ** memory if we don't.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 */
1111 outw(STOP, DEPCA_DATA);
1112
1113 /*
1114 ** Give back the ROM in case the user wants to go to DOS
1115 */
1116 if (lp->adapter != DEPCA) {
1117 nicsr = inb(DEPCA_NICSR);
1118 nicsr &= ~SHE;
1119 outb(nicsr, DEPCA_NICSR);
1120 }
1121
1122 /*
1123 ** Free the associated irq
1124 */
1125 free_irq(dev->irq, dev);
1126 return 0;
1127}
1128
1129static void LoadCSRs(struct net_device *dev)
1130{
Wang Chen4cf16532008-11-12 23:38:14 -08001131 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 u_long ioaddr = dev->base_addr;
1133
1134 outw(CSR1, DEPCA_ADDR); /* initialisation block address LSW */
1135 outw((u16) lp->device_ram_start, DEPCA_DATA);
1136 outw(CSR2, DEPCA_ADDR); /* initialisation block address MSW */
1137 outw((u16) (lp->device_ram_start >> 16), DEPCA_DATA);
1138 outw(CSR3, DEPCA_ADDR); /* ALE control */
1139 outw(ACON, DEPCA_DATA);
1140
1141 outw(CSR0, DEPCA_ADDR); /* Point back to CSR0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142}
1143
1144static int InitRestartDepca(struct net_device *dev)
1145{
Wang Chen4cf16532008-11-12 23:38:14 -08001146 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 u_long ioaddr = dev->base_addr;
1148 int i, status = 0;
1149
1150 /* Copy the shadow init_block to shared memory */
1151 memcpy_toio(lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
1152
1153 outw(CSR0, DEPCA_ADDR); /* point back to CSR0 */
1154 outw(INIT, DEPCA_DATA); /* initialize DEPCA */
1155
1156 /* wait for lance to complete initialisation */
1157 for (i = 0; (i < 100) && !(inw(DEPCA_DATA) & IDON); i++);
1158
1159 if (i != 100) {
1160 /* clear IDON by writing a "1", enable interrupts and start lance */
1161 outw(IDON | INEA | STRT, DEPCA_DATA);
1162 if (depca_debug > 2) {
1163 printk("%s: DEPCA open after %d ticks, init block 0x%08lx csr0 %4.4x.\n", dev->name, i, lp->mem_start, inw(DEPCA_DATA));
1164 }
1165 } else {
1166 printk("%s: DEPCA unopen after %d ticks, init block 0x%08lx csr0 %4.4x.\n", dev->name, i, lp->mem_start, inw(DEPCA_DATA));
1167 status = -1;
1168 }
1169
1170 return status;
1171}
1172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173/*
1174** Set or clear the multicast filter for this adaptor.
1175*/
1176static void set_multicast_list(struct net_device *dev)
1177{
Wang Chen4cf16532008-11-12 23:38:14 -08001178 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 u_long ioaddr = dev->base_addr;
1180
Eric Sesterhenn107ce6d2006-10-10 14:33:28 -07001181 netif_stop_queue(dev);
1182 while (lp->tx_old != lp->tx_new); /* Wait for the ring to empty */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183
Eric Sesterhenn107ce6d2006-10-10 14:33:28 -07001184 STOP_DEPCA; /* Temporarily stop the depca. */
1185 depca_init_ring(dev); /* Initialize the descriptor rings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Eric Sesterhenn107ce6d2006-10-10 14:33:28 -07001187 if (dev->flags & IFF_PROMISC) { /* Set promiscuous mode */
1188 lp->init_block.mode |= PROM;
1189 } else {
1190 SetMulticastFilter(dev);
1191 lp->init_block.mode &= ~PROM; /* Unset promiscuous mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 }
Eric Sesterhenn107ce6d2006-10-10 14:33:28 -07001193
1194 LoadCSRs(dev); /* Reload CSR3 */
1195 InitRestartDepca(dev); /* Resume normal operation. */
1196 netif_start_queue(dev); /* Unlock the TX ring */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}
1198
1199/*
1200** Calculate the hash code and update the logical address filter
1201** from a list of ethernet multicast addresses.
1202** Big endian crc one liner is mine, all mine, ha ha ha ha!
1203** LANCE calculates its hash codes big endian.
1204*/
1205static void SetMulticastFilter(struct net_device *dev)
1206{
Wang Chen4cf16532008-11-12 23:38:14 -08001207 struct depca_private *lp = netdev_priv(dev);
Jiri Pirko22bedad32010-04-01 21:22:57 +00001208 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 int i, j, bit, byte;
1210 u16 hashcode;
1211 u32 crc;
1212
1213 if (dev->flags & IFF_ALLMULTI) { /* Set all multicast bits */
1214 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1215 lp->init_block.mcast_table[i] = (char) 0xff;
1216 }
1217 } else {
1218 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) { /* Clear the multicast table */
1219 lp->init_block.mcast_table[i] = 0;
1220 }
1221 /* Add multicast addresses */
Jiri Pirko22bedad32010-04-01 21:22:57 +00001222 netdev_for_each_mc_addr(ha, dev) {
Tobias Klauser3170ff52011-06-29 02:15:15 +00001223 crc = ether_crc(ETH_ALEN, ha->addr);
1224 hashcode = (crc & 1); /* hashcode is 6 LSb of CRC ... */
1225 for (j = 0; j < 5; j++) { /* ... in reverse order. */
1226 hashcode = (hashcode << 1) | ((crc >>= 1) & 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 }
Tobias Klauser3170ff52011-06-29 02:15:15 +00001228
1229 byte = hashcode >> 3; /* bit[3-5] -> byte in filter */
1230 bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
1231 lp->init_block.mcast_table[byte] |= bit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 }
1233 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234}
1235
David S. Miller948252c2011-05-31 19:27:48 -07001236static int __init depca_common_init (u_long ioaddr, struct net_device **devp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237{
1238 int status = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001239
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 if (!request_region (ioaddr, DEPCA_TOTAL_SIZE, depca_string)) {
1241 status = -EBUSY;
1242 goto out;
1243 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 if (DevicePresent(ioaddr)) {
1246 status = -ENODEV;
1247 goto out_release;
1248 }
1249
1250 if (!(*devp = alloc_etherdev (sizeof (struct depca_private)))) {
1251 status = -ENOMEM;
1252 goto out_release;
1253 }
1254
1255 return 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 out_release:
1258 release_region (ioaddr, DEPCA_TOTAL_SIZE);
1259 out:
1260 return status;
1261}
1262
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263/*
1264** ISA bus I/O device probe
1265*/
1266
David S. Miller948252c2011-05-31 19:27:48 -07001267static void __init depca_platform_probe (void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
1269 int i;
1270 struct platform_device *pldev;
1271
1272 for (i = 0; depca_io_ports[i].iobase; i++) {
1273 depca_io_ports[i].device = NULL;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 /* if an address has been specified on the command
1276 * line, use it (if valid) */
1277 if (io && io != depca_io_ports[i].iobase)
1278 continue;
Russell King5d994b72005-11-05 21:20:21 +00001279
1280 pldev = platform_device_alloc(depca_string, i);
1281 if (!pldev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 continue;
1283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 pldev->dev.platform_data = (void *) depca_io_ports[i].iobase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 depca_io_ports[i].device = pldev;
1286
Russell King5d994b72005-11-05 21:20:21 +00001287 if (platform_device_add(pldev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 depca_io_ports[i].device = NULL;
Andrea Righid91c0882007-04-24 12:40:57 -04001289 pldev->dev.platform_data = NULL;
1290 platform_device_put(pldev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 continue;
1292 }
1293
1294 if (!pldev->dev.driver) {
1295 /* The driver was not bound to this device, there was
1296 * no hardware at this address. Unregister it, as the
Stefan Weileef35c22010-08-06 21:11:15 +02001297 * release function will take care of freeing the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 * allocated structure */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001299
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 depca_io_ports[i].device = NULL;
Russell King5d994b72005-11-05 21:20:21 +00001301 pldev->dev.platform_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 platform_device_unregister (pldev);
1303 }
1304 }
1305}
1306
David S. Miller948252c2011-05-31 19:27:48 -07001307static enum depca_type __init depca_shmem_probe (ulong *mem_start)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
1309 u_long mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
1310 enum depca_type adapter = unknown;
1311 int i;
1312
1313 for (i = 0; mem_base[i]; i++) {
1314 *mem_start = mem ? mem : mem_base[i];
1315 adapter = DepcaSignature (adapter_name, *mem_start);
1316 if (adapter != unknown)
1317 break;
1318 }
1319
1320 return adapter;
1321}
1322
Sedat Dilekebd80882011-01-03 11:22:15 +00001323static int __devinit depca_isa_probe (struct platform_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324{
1325 struct net_device *dev;
1326 struct depca_private *lp;
1327 u_long ioaddr, mem_start = 0;
1328 enum depca_type adapter = unknown;
1329 int status = 0;
1330
Russell King3ae5eae2005-11-09 22:32:44 +00001331 ioaddr = (u_long) device->dev.platform_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 if ((status = depca_common_init (ioaddr, &dev)))
1334 goto out;
1335
1336 adapter = depca_shmem_probe (&mem_start);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001337
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 if (adapter == unknown) {
1339 status = -ENODEV;
1340 goto out_free;
1341 }
1342
1343 dev->base_addr = ioaddr;
1344 dev->irq = irq; /* Use whatever value the user gave
1345 * us, and 0 if he didn't. */
Wang Chen4cf16532008-11-12 23:38:14 -08001346 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 lp->depca_bus = DEPCA_BUS_ISA;
1348 lp->adapter = adapter;
1349 lp->mem_start = mem_start;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001350
Russell King3ae5eae2005-11-09 22:32:44 +00001351 if ((status = depca_hw_init(dev, &device->dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 goto out_free;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001353
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 return 0;
1355
1356 out_free:
1357 free_netdev (dev);
1358 release_region (ioaddr, DEPCA_TOTAL_SIZE);
1359 out:
1360 return status;
1361}
1362
1363/*
1364** EISA callbacks from sysfs.
1365*/
1366
1367#ifdef CONFIG_EISA
David S. Miller948252c2011-05-31 19:27:48 -07001368static int __init depca_eisa_probe (struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369{
Ingo Molnar99da1a82008-11-25 17:00:39 -08001370 enum depca_type adapter = unknown;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 struct eisa_device *edev;
1372 struct net_device *dev;
1373 struct depca_private *lp;
1374 u_long ioaddr, mem_start;
1375 int status = 0;
1376
1377 edev = to_eisa_device (device);
1378 ioaddr = edev->base_addr + DEPCA_EISA_IO_PORTS;
1379
1380 if ((status = depca_common_init (ioaddr, &dev)))
1381 goto out;
1382
1383 /* It would have been nice to get card configuration from the
1384 * card. Unfortunately, this register is write-only (shares
1385 * it's address with the ethernet prom)... As we don't parse
1386 * the EISA configuration structures (yet... :-), just rely on
1387 * the ISA probing to sort it out... */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001388
Ingo Molnar99da1a82008-11-25 17:00:39 -08001389 adapter = depca_shmem_probe (&mem_start);
1390 if (adapter == unknown) {
1391 status = -ENODEV;
1392 goto out_free;
1393 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394
1395 dev->base_addr = ioaddr;
1396 dev->irq = irq;
Wang Chen4cf16532008-11-12 23:38:14 -08001397 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 lp->depca_bus = DEPCA_BUS_EISA;
1399 lp->adapter = edev->id.driver_data;
1400 lp->mem_start = mem_start;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if ((status = depca_hw_init(dev, device)))
1403 goto out_free;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001404
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return 0;
1406
1407 out_free:
1408 free_netdev (dev);
1409 release_region (ioaddr, DEPCA_TOTAL_SIZE);
1410 out:
1411 return status;
1412}
1413#endif
1414
1415static int __devexit depca_device_remove (struct device *device)
1416{
1417 struct net_device *dev;
1418 struct depca_private *lp;
1419 int bus;
1420
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +00001421 dev = dev_get_drvdata(device);
Wang Chen4cf16532008-11-12 23:38:14 -08001422 lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424 unregister_netdev (dev);
1425 iounmap (lp->sh_mem);
1426 release_mem_region (lp->mem_start, lp->mem_len);
1427 release_region (dev->base_addr, DEPCA_TOTAL_SIZE);
1428 bus = lp->depca_bus;
1429 free_netdev (dev);
1430
1431 return 0;
1432}
1433
1434/*
1435** Look for a particular board name in the on-board Remote Diagnostics
1436** and Boot (readb) ROM. This will also give us a clue to the network RAM
1437** base address.
1438*/
David S. Miller948252c2011-05-31 19:27:48 -07001439static int __init DepcaSignature(char *name, u_long base_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440{
1441 u_int i, j, k;
1442 void __iomem *ptr;
1443 char tmpstr[16];
1444 u_long prom_addr = base_addr + 0xc000;
1445 u_long mem_addr = base_addr + 0x8000; /* 32KB */
1446
1447 /* Can't reserve the prom region, it is already marked as
1448 * used, at least on x86. Instead, reserve a memory region a
1449 * board would certainly use. If it works, go ahead. If not,
1450 * run like hell... */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001451
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 if (!request_mem_region (mem_addr, 16, depca_string))
1453 return unknown;
1454
1455 /* Copy the first 16 bytes of ROM */
1456
1457 ptr = ioremap(prom_addr, 16);
1458 if (ptr == NULL) {
1459 printk(KERN_ERR "depca: I/O remap failed at %lx\n", prom_addr);
1460 return unknown;
1461 }
1462 for (i = 0; i < 16; i++) {
1463 tmpstr[i] = readb(ptr + i);
1464 }
1465 iounmap(ptr);
1466
1467 release_mem_region (mem_addr, 16);
1468
1469 /* Check if PROM contains a valid string */
1470 for (i = 0; *depca_signature[i] != '\0'; i++) {
1471 for (j = 0, k = 0; j < 16 && k < strlen(depca_signature[i]); j++) {
1472 if (depca_signature[i][k] == tmpstr[j]) { /* track signature */
1473 k++;
1474 } else { /* lost signature; begin search again */
1475 k = 0;
1476 }
1477 }
1478 if (k == strlen(depca_signature[i]))
1479 break;
1480 }
1481
1482 /* Check if name string is valid, provided there's no PROM */
1483 if (name && *name && (i == unknown)) {
1484 for (i = 0; *depca_signature[i] != '\0'; i++) {
1485 if (strcmp(name, depca_signature[i]) == 0)
1486 break;
1487 }
1488 }
1489
1490 return i;
1491}
1492
1493/*
1494** Look for a special sequence in the Ethernet station address PROM that
1495** is common across all DEPCA products. Note that the original DEPCA needs
1496** its ROM address counter to be initialized and enabled. Only enable
1497** if the first address octet is a 0x08 - this minimises the chances of
1498** messing around with some other hardware, but it assumes that this DEPCA
1499** card initialized itself correctly.
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001500**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501** Search the Ethernet address ROM for the signature. Since the ROM address
1502** counter can start at an arbitrary point, the search must include the entire
1503** probe sequence length plus the (length_of_the_signature - 1).
1504** Stop the search IMMEDIATELY after the signature is found so that the
1505** PROM address counter is correctly positioned at the start of the
1506** ethernet address for later read out.
1507*/
1508static int __init DevicePresent(u_long ioaddr)
1509{
1510 union {
1511 struct {
1512 u32 a;
1513 u32 b;
1514 } llsig;
1515 char Sig[sizeof(u32) << 1];
1516 }
1517 dev;
1518 short sigLength = 0;
1519 s8 data;
1520 s16 nicsr;
1521 int i, j, status = 0;
1522
1523 data = inb(DEPCA_PROM); /* clear counter on DEPCA */
1524 data = inb(DEPCA_PROM); /* read data */
1525
1526 if (data == 0x08) { /* Enable counter on DEPCA */
1527 nicsr = inb(DEPCA_NICSR);
1528 nicsr |= AAC;
1529 outb(nicsr, DEPCA_NICSR);
1530 }
1531
1532 dev.llsig.a = ETH_PROM_SIG;
1533 dev.llsig.b = ETH_PROM_SIG;
1534 sigLength = sizeof(u32) << 1;
1535
1536 for (i = 0, j = 0; j < sigLength && i < PROBE_LENGTH + sigLength - 1; i++) {
1537 data = inb(DEPCA_PROM);
1538 if (dev.Sig[j] == data) { /* track signature */
1539 j++;
1540 } else { /* lost signature; begin search again */
1541 if (data == dev.Sig[0]) { /* rare case.... */
1542 j = 1;
1543 } else {
1544 j = 0;
1545 }
1546 }
1547 }
1548
1549 if (j != sigLength) {
1550 status = -ENODEV; /* search failed */
1551 }
1552
1553 return status;
1554}
1555
1556/*
1557** The DE100 and DE101 PROM accesses were made non-standard for some bizarre
1558** reason: access the upper half of the PROM with x=0; access the lower half
1559** with x=1.
1560*/
1561static int __init get_hw_addr(struct net_device *dev)
1562{
1563 u_long ioaddr = dev->base_addr;
Wang Chen4cf16532008-11-12 23:38:14 -08001564 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 int i, k, tmp, status = 0;
1566 u_short j, x, chksum;
1567
1568 x = (((lp->adapter == de100) || (lp->adapter == de101)) ? 1 : 0);
1569
1570 for (i = 0, k = 0, j = 0; j < 3; j++) {
1571 k <<= 1;
1572 if (k > 0xffff)
1573 k -= 0xffff;
1574
1575 k += (u_char) (tmp = inb(DEPCA_PROM + x));
1576 dev->dev_addr[i++] = (u_char) tmp;
1577 k += (u_short) ((tmp = inb(DEPCA_PROM + x)) << 8);
1578 dev->dev_addr[i++] = (u_char) tmp;
1579
1580 if (k > 0xffff)
1581 k -= 0xffff;
1582 }
1583 if (k == 0xffff)
1584 k = 0;
1585
1586 chksum = (u_char) inb(DEPCA_PROM + x);
1587 chksum |= (u_short) (inb(DEPCA_PROM + x) << 8);
1588 if (k != chksum)
1589 status = -1;
1590
1591 return status;
1592}
1593
1594/*
1595** Load a packet into the shared memory
1596*/
1597static int load_packet(struct net_device *dev, struct sk_buff *skb)
1598{
Wang Chen4cf16532008-11-12 23:38:14 -08001599 struct depca_private *lp = netdev_priv(dev);
Patrick McHardyec634fe2009-07-05 19:23:38 -07001600 int i, entry, end, len, status = NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601
1602 entry = lp->tx_new; /* Ring around buffer number. */
1603 end = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
1604 if (!(readl(&lp->tx_ring[end].base) & T_OWN)) { /* Enough room? */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001605 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 ** Caution: the write order is important here... don't set up the
1607 ** ownership rights until all the other information is in place.
1608 */
1609 if (end < entry) { /* wrapped buffer */
1610 len = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
1611 memcpy_toio(lp->tx_buff[entry], skb->data, len);
1612 memcpy_toio(lp->tx_buff[0], skb->data + len, skb->len - len);
1613 } else { /* linear buffer */
1614 memcpy_toio(lp->tx_buff[entry], skb->data, skb->len);
1615 }
1616
1617 /* set up the buffer descriptors */
1618 len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1619 for (i = entry; i != end; i = (i+1) & lp->txRingMask) {
1620 /* clean out flags */
1621 writel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
1622 writew(0x0000, &lp->tx_ring[i].misc); /* clears other error flags */
1623 writew(-TX_BUFF_SZ, &lp->tx_ring[i].length); /* packet length in buffer */
1624 len -= TX_BUFF_SZ;
1625 }
1626 /* clean out flags */
1627 writel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
1628 writew(0x0000, &lp->tx_ring[end].misc); /* clears other error flags */
1629 writew(-len, &lp->tx_ring[end].length); /* packet length in last buff */
1630
1631 /* start of packet */
1632 writel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
1633 /* end of packet */
1634 writel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
1635
1636 for (i = end; i != entry; --i) {
1637 /* ownership of packet */
1638 writel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
1639 if (i == 0)
1640 i = lp->txRingMask + 1;
1641 }
1642 writel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
1643
1644 lp->tx_new = (++end) & lp->txRingMask; /* update current pointers */
1645 } else {
Patrick McHardy5b548142009-06-12 06:22:29 +00001646 status = NETDEV_TX_LOCKED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 }
1648
1649 return status;
1650}
1651
1652static void depca_dbg_open(struct net_device *dev)
1653{
Wang Chen4cf16532008-11-12 23:38:14 -08001654 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 u_long ioaddr = dev->base_addr;
1656 struct depca_init *p = &lp->init_block;
1657 int i;
1658
1659 if (depca_debug > 1) {
1660 /* Do not copy the shadow init block into shared memory */
1661 /* Debugging should not affect normal operation! */
1662 /* The shadow init block will get copied across during InitRestartDepca */
1663 printk("%s: depca open with irq %d\n", dev->name, dev->irq);
1664 printk("Descriptor head addresses (CPU):\n");
1665 printk(" 0x%lx 0x%lx\n", (u_long) lp->rx_ring, (u_long) lp->tx_ring);
1666 printk("Descriptor addresses (CPU):\nRX: ");
1667 for (i = 0; i < lp->rxRingMask; i++) {
1668 if (i < 3) {
1669 printk("%p ", &lp->rx_ring[i].base);
1670 }
1671 }
1672 printk("...%p\n", &lp->rx_ring[i].base);
1673 printk("TX: ");
1674 for (i = 0; i < lp->txRingMask; i++) {
1675 if (i < 3) {
1676 printk("%p ", &lp->tx_ring[i].base);
1677 }
1678 }
1679 printk("...%p\n", &lp->tx_ring[i].base);
1680 printk("\nDescriptor buffers (Device):\nRX: ");
1681 for (i = 0; i < lp->rxRingMask; i++) {
1682 if (i < 3) {
1683 printk("0x%8.8x ", readl(&lp->rx_ring[i].base));
1684 }
1685 }
1686 printk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
1687 printk("TX: ");
1688 for (i = 0; i < lp->txRingMask; i++) {
1689 if (i < 3) {
1690 printk("0x%8.8x ", readl(&lp->tx_ring[i].base));
1691 }
1692 }
1693 printk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
1694 printk("Initialisation block at 0x%8.8lx(Phys)\n", lp->mem_start);
1695 printk(" mode: 0x%4.4x\n", p->mode);
Johannes Berge1749612008-10-27 15:59:26 -07001696 printk(" physical address: %pM\n", p->phys_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 printk(" multicast hash table: ");
1698 for (i = 0; i < (HASH_TABLE_LEN >> 3) - 1; i++) {
1699 printk("%2.2x:", p->mcast_table[i]);
1700 }
1701 printk("%2.2x\n", p->mcast_table[i]);
1702 printk(" rx_ring at: 0x%8.8x\n", p->rx_ring);
1703 printk(" tx_ring at: 0x%8.8x\n", p->tx_ring);
1704 printk("buffers (Phys): 0x%8.8lx\n", lp->mem_start + lp->buffs_offset);
1705 printk("Ring size:\nRX: %d Log2(rxRingMask): 0x%8.8x\n", (int) lp->rxRingMask + 1, lp->rx_rlen);
1706 printk("TX: %d Log2(txRingMask): 0x%8.8x\n", (int) lp->txRingMask + 1, lp->tx_rlen);
1707 outw(CSR2, DEPCA_ADDR);
1708 printk("CSR2&1: 0x%4.4x", inw(DEPCA_DATA));
1709 outw(CSR1, DEPCA_ADDR);
1710 printk("%4.4x\n", inw(DEPCA_DATA));
1711 outw(CSR3, DEPCA_ADDR);
1712 printk("CSR3: 0x%4.4x\n", inw(DEPCA_DATA));
1713 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714}
1715
1716/*
1717** Perform IOCTL call functions here. Some are privileged operations and the
1718** effective uid is checked in those cases.
1719** All multicast IOCTLs will not work here and are for testing purposes only.
1720*/
1721static int depca_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1722{
Wang Chen4cf16532008-11-12 23:38:14 -08001723 struct depca_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 struct depca_ioctl *ioc = (struct depca_ioctl *) &rq->ifr_ifru;
1725 int i, status = 0;
1726 u_long ioaddr = dev->base_addr;
1727 union {
1728 u8 addr[(HASH_TABLE_LEN * ETH_ALEN)];
1729 u16 sval[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1730 u32 lval[(HASH_TABLE_LEN * ETH_ALEN) >> 2];
1731 } tmp;
1732 unsigned long flags;
1733 void *buf;
1734
1735 switch (ioc->cmd) {
1736 case DEPCA_GET_HWADDR: /* Get the hardware address */
1737 for (i = 0; i < ETH_ALEN; i++) {
1738 tmp.addr[i] = dev->dev_addr[i];
1739 }
1740 ioc->len = ETH_ALEN;
1741 if (copy_to_user(ioc->data, tmp.addr, ioc->len))
1742 return -EFAULT;
1743 break;
1744
1745 case DEPCA_SET_HWADDR: /* Set the hardware address */
1746 if (!capable(CAP_NET_ADMIN))
1747 return -EPERM;
1748 if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN))
1749 return -EFAULT;
1750 for (i = 0; i < ETH_ALEN; i++) {
1751 dev->dev_addr[i] = tmp.addr[i];
1752 }
1753 netif_stop_queue(dev);
1754 while (lp->tx_old != lp->tx_new)
1755 cpu_relax(); /* Wait for the ring to empty */
1756
1757 STOP_DEPCA; /* Temporarily stop the depca. */
1758 depca_init_ring(dev); /* Initialize the descriptor rings */
1759 LoadCSRs(dev); /* Reload CSR3 */
1760 InitRestartDepca(dev); /* Resume normal operation. */
1761 netif_start_queue(dev); /* Unlock the TX ring */
1762 break;
1763
1764 case DEPCA_SET_PROM: /* Set Promiscuous Mode */
1765 if (!capable(CAP_NET_ADMIN))
1766 return -EPERM;
1767 netif_stop_queue(dev);
1768 while (lp->tx_old != lp->tx_new)
1769 cpu_relax(); /* Wait for the ring to empty */
1770
1771 STOP_DEPCA; /* Temporarily stop the depca. */
1772 depca_init_ring(dev); /* Initialize the descriptor rings */
1773 lp->init_block.mode |= PROM; /* Set promiscuous mode */
1774
1775 LoadCSRs(dev); /* Reload CSR3 */
1776 InitRestartDepca(dev); /* Resume normal operation. */
1777 netif_start_queue(dev); /* Unlock the TX ring */
1778 break;
1779
1780 case DEPCA_CLR_PROM: /* Clear Promiscuous Mode */
1781 if (!capable(CAP_NET_ADMIN))
1782 return -EPERM;
1783 netif_stop_queue(dev);
1784 while (lp->tx_old != lp->tx_new)
1785 cpu_relax(); /* Wait for the ring to empty */
1786
1787 STOP_DEPCA; /* Temporarily stop the depca. */
1788 depca_init_ring(dev); /* Initialize the descriptor rings */
1789 lp->init_block.mode &= ~PROM; /* Clear promiscuous mode */
1790
1791 LoadCSRs(dev); /* Reload CSR3 */
1792 InitRestartDepca(dev); /* Resume normal operation. */
1793 netif_start_queue(dev); /* Unlock the TX ring */
1794 break;
1795
1796 case DEPCA_SAY_BOO: /* Say "Boo!" to the kernel log file */
1797 if(!capable(CAP_NET_ADMIN))
1798 return -EPERM;
1799 printk("%s: Boo!\n", dev->name);
1800 break;
1801
1802 case DEPCA_GET_MCA: /* Get the multicast address table */
1803 ioc->len = (HASH_TABLE_LEN >> 3);
1804 if (copy_to_user(ioc->data, lp->init_block.mcast_table, ioc->len))
1805 return -EFAULT;
1806 break;
1807
1808 case DEPCA_SET_MCA: /* Set a multicast address */
1809 if (!capable(CAP_NET_ADMIN))
1810 return -EPERM;
1811 if (ioc->len >= HASH_TABLE_LEN)
1812 return -EINVAL;
1813 if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN * ioc->len))
1814 return -EFAULT;
1815 set_multicast_list(dev);
1816 break;
1817
1818 case DEPCA_CLR_MCA: /* Clear all multicast addresses */
1819 if (!capable(CAP_NET_ADMIN))
1820 return -EPERM;
1821 set_multicast_list(dev);
1822 break;
1823
1824 case DEPCA_MCA_EN: /* Enable pass all multicast addressing */
1825 if (!capable(CAP_NET_ADMIN))
1826 return -EPERM;
1827 set_multicast_list(dev);
1828 break;
1829
1830 case DEPCA_GET_STATS: /* Get the driver statistics */
1831 ioc->len = sizeof(lp->pktStats);
1832 buf = kmalloc(ioc->len, GFP_KERNEL);
1833 if(!buf)
1834 return -ENOMEM;
1835 spin_lock_irqsave(&lp->lock, flags);
1836 memcpy(buf, &lp->pktStats, ioc->len);
1837 spin_unlock_irqrestore(&lp->lock, flags);
1838 if (copy_to_user(ioc->data, buf, ioc->len))
1839 status = -EFAULT;
1840 kfree(buf);
1841 break;
1842
1843 case DEPCA_CLR_STATS: /* Zero out the driver statistics */
1844 if (!capable(CAP_NET_ADMIN))
1845 return -EPERM;
1846 spin_lock_irqsave(&lp->lock, flags);
1847 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1848 spin_unlock_irqrestore(&lp->lock, flags);
1849 break;
1850
1851 case DEPCA_GET_REG: /* Get the DEPCA Registers */
1852 i = 0;
1853 tmp.sval[i++] = inw(DEPCA_NICSR);
1854 outw(CSR0, DEPCA_ADDR); /* status register */
1855 tmp.sval[i++] = inw(DEPCA_DATA);
1856 memcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
1857 ioc->len = i + sizeof(struct depca_init);
1858 if (copy_to_user(ioc->data, tmp.addr, ioc->len))
1859 return -EFAULT;
1860 break;
1861
1862 default:
1863 return -EOPNOTSUPP;
1864 }
1865
1866 return status;
1867}
1868
1869static int __init depca_module_init (void)
1870{
Kulikov Vasiliy84c3b9722010-07-12 04:52:33 +00001871 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873#ifdef CONFIG_EISA
Kulikov Vasiliy84c3b9722010-07-12 04:52:33 +00001874 err = eisa_driver_register(&depca_eisa_driver);
1875 if (err)
Paul Gortmakera5e371f2012-05-16 19:48:42 -04001876 goto err_eisa;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877#endif
Kulikov Vasiliy84c3b9722010-07-12 04:52:33 +00001878 err = platform_driver_register(&depca_isa_driver);
1879 if (err)
1880 goto err_eisa;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001881
Kulikov Vasiliy84c3b9722010-07-12 04:52:33 +00001882 depca_platform_probe();
1883 return 0;
1884
1885err_eisa:
1886#ifdef CONFIG_EISA
1887 eisa_driver_unregister(&depca_eisa_driver);
Kulikov Vasiliy84c3b9722010-07-12 04:52:33 +00001888#endif
1889 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}
1891
1892static void __exit depca_module_exit (void)
1893{
1894 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895#ifdef CONFIG_EISA
1896 eisa_driver_unregister (&depca_eisa_driver);
1897#endif
Russell King3ae5eae2005-11-09 22:32:44 +00001898 platform_driver_unregister (&depca_isa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
1900 for (i = 0; depca_io_ports[i].iobase; i++) {
1901 if (depca_io_ports[i].device) {
Russell King5d994b72005-11-05 21:20:21 +00001902 depca_io_ports[i].device->dev.platform_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 platform_device_unregister (depca_io_ports[i].device);
1904 depca_io_ports[i].device = NULL;
1905 }
1906 }
1907}
1908
1909module_init (depca_module_init);
1910module_exit (depca_module_exit);