1 | /* |
2 | * Amiga Linux/68k A2065 Ethernet Driver |
3 | * |
4 | * (C) Copyright 1995-2003 by Geert Uytterhoeven <geert@linux-m68k.org> |
5 | * |
6 | * Fixes and tips by: |
7 | * - Janos Farkas (CHEXUM@sparta.banki.hu) |
8 | * - Jes Degn Soerensen (jds@kom.auc.dk) |
9 | * - Matt Domsch (Matt_Domsch@dell.com) |
10 | * |
11 | * ---------------------------------------------------------------------------- |
12 | * |
13 | * This program is based on |
14 | * |
15 | * ariadne.?: Amiga Linux/68k Ariadne Ethernet Driver |
16 | * (C) Copyright 1995 by Geert Uytterhoeven, |
17 | * Peter De Schrijver |
18 | * |
19 | * lance.c: An AMD LANCE ethernet driver for linux. |
20 | * Written 1993-94 by Donald Becker. |
21 | * |
22 | * Am79C960: PCnet(tm)-ISA Single-Chip Ethernet Controller |
23 | * Advanced Micro Devices |
24 | * Publication #16907, Rev. B, Amendment/0, May 1994 |
25 | * |
26 | * ---------------------------------------------------------------------------- |
27 | * |
28 | * This file is subject to the terms and conditions of the GNU General Public |
29 | * License. See the file COPYING in the main directory of the Linux |
30 | * distribution for more details. |
31 | * |
32 | * ---------------------------------------------------------------------------- |
33 | * |
34 | * The A2065 is a Zorro-II board made by Commodore/Ameristar. It contains: |
35 | * |
36 | * - an Am7990 Local Area Network Controller for Ethernet (LANCE) with |
37 | * both 10BASE-2 (thin coax) and AUI (DB-15) connectors |
38 | */ |
39 | |
40 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
41 | |
42 | /*#define DEBUG*/ |
43 | /*#define TEST_HITS*/ |
44 | |
45 | #include <linux/errno.h> |
46 | #include <linux/netdevice.h> |
47 | #include <linux/etherdevice.h> |
48 | #include <linux/module.h> |
49 | #include <linux/stddef.h> |
50 | #include <linux/kernel.h> |
51 | #include <linux/interrupt.h> |
52 | #include <linux/ioport.h> |
53 | #include <linux/skbuff.h> |
54 | #include <linux/string.h> |
55 | #include <linux/init.h> |
56 | #include <linux/crc32.h> |
57 | #include <linux/zorro.h> |
58 | #include <linux/bitops.h> |
59 | |
60 | #include <asm/byteorder.h> |
61 | #include <asm/irq.h> |
62 | #include <asm/amigaints.h> |
63 | #include <asm/amigahw.h> |
64 | |
65 | #include "a2065.h" |
66 | |
67 | /* Transmit/Receive Ring Definitions */ |
68 | |
69 | #define LANCE_LOG_TX_BUFFERS (2) |
70 | #define LANCE_LOG_RX_BUFFERS (4) |
71 | |
72 | #define TX_RING_SIZE (1 << LANCE_LOG_TX_BUFFERS) |
73 | #define RX_RING_SIZE (1 << LANCE_LOG_RX_BUFFERS) |
74 | |
75 | #define TX_RING_MOD_MASK (TX_RING_SIZE - 1) |
76 | #define RX_RING_MOD_MASK (RX_RING_SIZE - 1) |
77 | |
78 | #define PKT_BUF_SIZE (1544) |
79 | #define RX_BUFF_SIZE PKT_BUF_SIZE |
80 | #define TX_BUFF_SIZE PKT_BUF_SIZE |
81 | |
82 | /* Layout of the Lance's RAM Buffer */ |
83 | |
84 | struct lance_init_block { |
85 | unsigned short mode; /* Pre-set mode (reg. 15) */ |
86 | unsigned char phys_addr[6]; /* Physical ethernet address */ |
87 | unsigned filter[2]; /* Multicast filter. */ |
88 | |
89 | /* Receive and transmit ring base, along with extra bits. */ |
90 | unsigned short rx_ptr; /* receive descriptor addr */ |
91 | unsigned short rx_len; /* receive len and high addr */ |
92 | unsigned short tx_ptr; /* transmit descriptor addr */ |
93 | unsigned short tx_len; /* transmit len and high addr */ |
94 | |
95 | /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */ |
96 | struct lance_rx_desc brx_ring[RX_RING_SIZE]; |
97 | struct lance_tx_desc btx_ring[TX_RING_SIZE]; |
98 | |
99 | char rx_buf[RX_RING_SIZE][RX_BUFF_SIZE]; |
100 | char tx_buf[TX_RING_SIZE][TX_BUFF_SIZE]; |
101 | }; |
102 | |
103 | /* Private Device Data */ |
104 | |
105 | struct lance_private { |
106 | char *name; |
107 | volatile struct lance_regs *ll; |
108 | volatile struct lance_init_block *init_block; /* Hosts view */ |
109 | volatile struct lance_init_block *lance_init_block; /* Lance view */ |
110 | |
111 | int rx_new, tx_new; |
112 | int rx_old, tx_old; |
113 | |
114 | int lance_log_rx_bufs, lance_log_tx_bufs; |
115 | int rx_ring_mod_mask, tx_ring_mod_mask; |
116 | |
117 | int tpe; /* cable-selection is TPE */ |
118 | int auto_select; /* cable-selection by carrier */ |
119 | unsigned short busmaster_regval; |
120 | |
121 | struct timer_list multicast_timer; |
122 | struct net_device *dev; |
123 | }; |
124 | |
125 | #define LANCE_ADDR(x) ((int)(x) & ~0xff000000) |
126 | |
127 | /* Load the CSR registers */ |
128 | static void load_csrs(struct lance_private *lp) |
129 | { |
130 | volatile struct lance_regs *ll = lp->ll; |
131 | volatile struct lance_init_block *aib = lp->lance_init_block; |
132 | int leptr = LANCE_ADDR(aib); |
133 | |
134 | ll->rap = LE_CSR1; |
135 | ll->rdp = (leptr & 0xFFFF); |
136 | ll->rap = LE_CSR2; |
137 | ll->rdp = leptr >> 16; |
138 | ll->rap = LE_CSR3; |
139 | ll->rdp = lp->busmaster_regval; |
140 | |
141 | /* Point back to csr0 */ |
142 | ll->rap = LE_CSR0; |
143 | } |
144 | |
145 | /* Setup the Lance Rx and Tx rings */ |
146 | static void lance_init_ring(struct net_device *dev) |
147 | { |
148 | struct lance_private *lp = netdev_priv(dev); |
149 | volatile struct lance_init_block *ib = lp->init_block; |
150 | volatile struct lance_init_block *aib = lp->lance_init_block; |
151 | /* for LANCE_ADDR computations */ |
152 | int leptr; |
153 | int i; |
154 | |
155 | /* Lock out other processes while setting up hardware */ |
156 | netif_stop_queue(dev); |
157 | lp->rx_new = lp->tx_new = 0; |
158 | lp->rx_old = lp->tx_old = 0; |
159 | |
160 | ib->mode = 0; |
161 | |
162 | /* Copy the ethernet address to the lance init block |
163 | * Note that on the sparc you need to swap the ethernet address. |
164 | */ |
165 | ib->phys_addr[0] = dev->dev_addr[1]; |
166 | ib->phys_addr[1] = dev->dev_addr[0]; |
167 | ib->phys_addr[2] = dev->dev_addr[3]; |
168 | ib->phys_addr[3] = dev->dev_addr[2]; |
169 | ib->phys_addr[4] = dev->dev_addr[5]; |
170 | ib->phys_addr[5] = dev->dev_addr[4]; |
171 | |
172 | /* Setup the Tx ring entries */ |
173 | netdev_dbg(dev, "TX rings:\n" ); |
174 | for (i = 0; i <= 1 << lp->lance_log_tx_bufs; i++) { |
175 | leptr = LANCE_ADDR(&aib->tx_buf[i][0]); |
176 | ib->btx_ring[i].tmd0 = leptr; |
177 | ib->btx_ring[i].tmd1_hadr = leptr >> 16; |
178 | ib->btx_ring[i].tmd1_bits = 0; |
179 | ib->btx_ring[i].length = 0xf000; /* The ones required by tmd2 */ |
180 | ib->btx_ring[i].misc = 0; |
181 | if (i < 3) |
182 | netdev_dbg(dev, "%d: 0x%08x\n" , i, leptr); |
183 | } |
184 | |
185 | /* Setup the Rx ring entries */ |
186 | netdev_dbg(dev, "RX rings:\n" ); |
187 | for (i = 0; i < 1 << lp->lance_log_rx_bufs; i++) { |
188 | leptr = LANCE_ADDR(&aib->rx_buf[i][0]); |
189 | |
190 | ib->brx_ring[i].rmd0 = leptr; |
191 | ib->brx_ring[i].rmd1_hadr = leptr >> 16; |
192 | ib->brx_ring[i].rmd1_bits = LE_R1_OWN; |
193 | ib->brx_ring[i].length = -RX_BUFF_SIZE | 0xf000; |
194 | ib->brx_ring[i].mblength = 0; |
195 | if (i < 3) |
196 | netdev_dbg(dev, "%d: 0x%08x\n" , i, leptr); |
197 | } |
198 | |
199 | /* Setup the initialization block */ |
200 | |
201 | /* Setup rx descriptor pointer */ |
202 | leptr = LANCE_ADDR(&aib->brx_ring); |
203 | ib->rx_len = (lp->lance_log_rx_bufs << 13) | (leptr >> 16); |
204 | ib->rx_ptr = leptr; |
205 | netdev_dbg(dev, "RX ptr: %08x\n" , leptr); |
206 | |
207 | /* Setup tx descriptor pointer */ |
208 | leptr = LANCE_ADDR(&aib->btx_ring); |
209 | ib->tx_len = (lp->lance_log_tx_bufs << 13) | (leptr >> 16); |
210 | ib->tx_ptr = leptr; |
211 | netdev_dbg(dev, "TX ptr: %08x\n" , leptr); |
212 | |
213 | /* Clear the multicast filter */ |
214 | ib->filter[0] = 0; |
215 | ib->filter[1] = 0; |
216 | } |
217 | |
218 | static int init_restart_lance(struct lance_private *lp) |
219 | { |
220 | volatile struct lance_regs *ll = lp->ll; |
221 | int i; |
222 | |
223 | ll->rap = LE_CSR0; |
224 | ll->rdp = LE_C0_INIT; |
225 | |
226 | /* Wait for the lance to complete initialization */ |
227 | for (i = 0; (i < 100) && !(ll->rdp & (LE_C0_ERR | LE_C0_IDON)); i++) |
228 | barrier(); |
229 | if ((i == 100) || (ll->rdp & LE_C0_ERR)) { |
230 | pr_err("unopened after %d ticks, csr0=%04x\n" , i, ll->rdp); |
231 | return -EIO; |
232 | } |
233 | |
234 | /* Clear IDON by writing a "1", enable interrupts and start lance */ |
235 | ll->rdp = LE_C0_IDON; |
236 | ll->rdp = LE_C0_INEA | LE_C0_STRT; |
237 | |
238 | return 0; |
239 | } |
240 | |
241 | static int lance_rx(struct net_device *dev) |
242 | { |
243 | struct lance_private *lp = netdev_priv(dev); |
244 | volatile struct lance_init_block *ib = lp->init_block; |
245 | volatile struct lance_regs *ll = lp->ll; |
246 | volatile struct lance_rx_desc *rd; |
247 | unsigned char bits; |
248 | |
249 | #ifdef TEST_HITS |
250 | int i; |
251 | char buf[RX_RING_SIZE + 1]; |
252 | |
253 | for (i = 0; i < RX_RING_SIZE; i++) { |
254 | char r1_own = ib->brx_ring[i].rmd1_bits & LE_R1_OWN; |
255 | if (i == lp->rx_new) |
256 | buf[i] = r1_own ? '_' : 'X'; |
257 | else |
258 | buf[i] = r1_own ? '.' : '1'; |
259 | } |
260 | buf[RX_RING_SIZE] = 0; |
261 | |
262 | pr_debug("RxRing TestHits: [%s]\n" , buf); |
263 | #endif |
264 | |
265 | ll->rdp = LE_C0_RINT | LE_C0_INEA; |
266 | for (rd = &ib->brx_ring[lp->rx_new]; |
267 | !((bits = rd->rmd1_bits) & LE_R1_OWN); |
268 | rd = &ib->brx_ring[lp->rx_new]) { |
269 | |
270 | /* We got an incomplete frame? */ |
271 | if ((bits & LE_R1_POK) != LE_R1_POK) { |
272 | dev->stats.rx_over_errors++; |
273 | dev->stats.rx_errors++; |
274 | continue; |
275 | } else if (bits & LE_R1_ERR) { |
276 | /* Count only the end frame as a rx error, |
277 | * not the beginning |
278 | */ |
279 | if (bits & LE_R1_BUF) |
280 | dev->stats.rx_fifo_errors++; |
281 | if (bits & LE_R1_CRC) |
282 | dev->stats.rx_crc_errors++; |
283 | if (bits & LE_R1_OFL) |
284 | dev->stats.rx_over_errors++; |
285 | if (bits & LE_R1_FRA) |
286 | dev->stats.rx_frame_errors++; |
287 | if (bits & LE_R1_EOP) |
288 | dev->stats.rx_errors++; |
289 | } else { |
290 | int len = (rd->mblength & 0xfff) - 4; |
291 | struct sk_buff *skb = netdev_alloc_skb(dev, length: len + 2); |
292 | |
293 | if (!skb) { |
294 | dev->stats.rx_dropped++; |
295 | rd->mblength = 0; |
296 | rd->rmd1_bits = LE_R1_OWN; |
297 | lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask; |
298 | return 0; |
299 | } |
300 | |
301 | skb_reserve(skb, len: 2); /* 16 byte align */ |
302 | skb_put(skb, len); /* make room */ |
303 | skb_copy_to_linear_data(skb, |
304 | from: (unsigned char *)&ib->rx_buf[lp->rx_new][0], |
305 | len); |
306 | skb->protocol = eth_type_trans(skb, dev); |
307 | netif_rx(skb); |
308 | dev->stats.rx_packets++; |
309 | dev->stats.rx_bytes += len; |
310 | } |
311 | |
312 | /* Return the packet to the pool */ |
313 | rd->mblength = 0; |
314 | rd->rmd1_bits = LE_R1_OWN; |
315 | lp->rx_new = (lp->rx_new + 1) & lp->rx_ring_mod_mask; |
316 | } |
317 | return 0; |
318 | } |
319 | |
320 | static int lance_tx(struct net_device *dev) |
321 | { |
322 | struct lance_private *lp = netdev_priv(dev); |
323 | volatile struct lance_init_block *ib = lp->init_block; |
324 | volatile struct lance_regs *ll = lp->ll; |
325 | volatile struct lance_tx_desc *td; |
326 | int i, j; |
327 | int status; |
328 | |
329 | /* csr0 is 2f3 */ |
330 | ll->rdp = LE_C0_TINT | LE_C0_INEA; |
331 | /* csr0 is 73 */ |
332 | |
333 | j = lp->tx_old; |
334 | for (i = j; i != lp->tx_new; i = j) { |
335 | td = &ib->btx_ring[i]; |
336 | |
337 | /* If we hit a packet not owned by us, stop */ |
338 | if (td->tmd1_bits & LE_T1_OWN) |
339 | break; |
340 | |
341 | if (td->tmd1_bits & LE_T1_ERR) { |
342 | status = td->misc; |
343 | |
344 | dev->stats.tx_errors++; |
345 | if (status & LE_T3_RTY) |
346 | dev->stats.tx_aborted_errors++; |
347 | if (status & LE_T3_LCOL) |
348 | dev->stats.tx_window_errors++; |
349 | |
350 | if (status & LE_T3_CLOS) { |
351 | dev->stats.tx_carrier_errors++; |
352 | if (lp->auto_select) { |
353 | lp->tpe = 1 - lp->tpe; |
354 | netdev_err(dev, format: "Carrier Lost, trying %s\n" , |
355 | lp->tpe ? "TPE" : "AUI" ); |
356 | /* Stop the lance */ |
357 | ll->rap = LE_CSR0; |
358 | ll->rdp = LE_C0_STOP; |
359 | lance_init_ring(dev); |
360 | load_csrs(lp); |
361 | init_restart_lance(lp); |
362 | return 0; |
363 | } |
364 | } |
365 | |
366 | /* buffer errors and underflows turn off |
367 | * the transmitter, so restart the adapter |
368 | */ |
369 | if (status & (LE_T3_BUF | LE_T3_UFL)) { |
370 | dev->stats.tx_fifo_errors++; |
371 | |
372 | netdev_err(dev, format: "Tx: ERR_BUF|ERR_UFL, restarting\n" ); |
373 | /* Stop the lance */ |
374 | ll->rap = LE_CSR0; |
375 | ll->rdp = LE_C0_STOP; |
376 | lance_init_ring(dev); |
377 | load_csrs(lp); |
378 | init_restart_lance(lp); |
379 | return 0; |
380 | } |
381 | } else if ((td->tmd1_bits & LE_T1_POK) == LE_T1_POK) { |
382 | /* So we don't count the packet more than once. */ |
383 | td->tmd1_bits &= ~(LE_T1_POK); |
384 | |
385 | /* One collision before packet was sent. */ |
386 | if (td->tmd1_bits & LE_T1_EONE) |
387 | dev->stats.collisions++; |
388 | |
389 | /* More than one collision, be optimistic. */ |
390 | if (td->tmd1_bits & LE_T1_EMORE) |
391 | dev->stats.collisions += 2; |
392 | |
393 | dev->stats.tx_packets++; |
394 | } |
395 | |
396 | j = (j + 1) & lp->tx_ring_mod_mask; |
397 | } |
398 | lp->tx_old = j; |
399 | ll->rdp = LE_C0_TINT | LE_C0_INEA; |
400 | return 0; |
401 | } |
402 | |
403 | static int lance_tx_buffs_avail(struct lance_private *lp) |
404 | { |
405 | if (lp->tx_old <= lp->tx_new) |
406 | return lp->tx_old + lp->tx_ring_mod_mask - lp->tx_new; |
407 | return lp->tx_old - lp->tx_new - 1; |
408 | } |
409 | |
410 | static irqreturn_t lance_interrupt(int irq, void *dev_id) |
411 | { |
412 | struct net_device *dev = dev_id; |
413 | struct lance_private *lp = netdev_priv(dev); |
414 | volatile struct lance_regs *ll = lp->ll; |
415 | int csr0; |
416 | |
417 | ll->rap = LE_CSR0; /* LANCE Controller Status */ |
418 | csr0 = ll->rdp; |
419 | |
420 | if (!(csr0 & LE_C0_INTR)) /* Check if any interrupt has */ |
421 | return IRQ_NONE; /* been generated by the Lance. */ |
422 | |
423 | /* Acknowledge all the interrupt sources ASAP */ |
424 | ll->rdp = csr0 & ~(LE_C0_INEA | LE_C0_TDMD | LE_C0_STOP | LE_C0_STRT | |
425 | LE_C0_INIT); |
426 | |
427 | if (csr0 & LE_C0_ERR) { |
428 | /* Clear the error condition */ |
429 | ll->rdp = LE_C0_BABL | LE_C0_ERR | LE_C0_MISS | LE_C0_INEA; |
430 | } |
431 | |
432 | if (csr0 & LE_C0_RINT) |
433 | lance_rx(dev); |
434 | |
435 | if (csr0 & LE_C0_TINT) |
436 | lance_tx(dev); |
437 | |
438 | /* Log misc errors. */ |
439 | if (csr0 & LE_C0_BABL) |
440 | dev->stats.tx_errors++; /* Tx babble. */ |
441 | if (csr0 & LE_C0_MISS) |
442 | dev->stats.rx_errors++; /* Missed a Rx frame. */ |
443 | if (csr0 & LE_C0_MERR) { |
444 | netdev_err(dev, format: "Bus master arbitration failure, status %04x\n" , |
445 | csr0); |
446 | /* Restart the chip. */ |
447 | ll->rdp = LE_C0_STRT; |
448 | } |
449 | |
450 | if (netif_queue_stopped(dev) && lance_tx_buffs_avail(lp) > 0) |
451 | netif_wake_queue(dev); |
452 | |
453 | ll->rap = LE_CSR0; |
454 | ll->rdp = (LE_C0_BABL | LE_C0_CERR | LE_C0_MISS | LE_C0_MERR | |
455 | LE_C0_IDON | LE_C0_INEA); |
456 | return IRQ_HANDLED; |
457 | } |
458 | |
459 | static int lance_open(struct net_device *dev) |
460 | { |
461 | struct lance_private *lp = netdev_priv(dev); |
462 | volatile struct lance_regs *ll = lp->ll; |
463 | int ret; |
464 | |
465 | /* Stop the Lance */ |
466 | ll->rap = LE_CSR0; |
467 | ll->rdp = LE_C0_STOP; |
468 | |
469 | /* Install the Interrupt handler */ |
470 | ret = request_irq(irq: IRQ_AMIGA_PORTS, handler: lance_interrupt, IRQF_SHARED, |
471 | name: dev->name, dev); |
472 | if (ret) |
473 | return ret; |
474 | |
475 | load_csrs(lp); |
476 | lance_init_ring(dev); |
477 | |
478 | netif_start_queue(dev); |
479 | |
480 | return init_restart_lance(lp); |
481 | } |
482 | |
483 | static int lance_close(struct net_device *dev) |
484 | { |
485 | struct lance_private *lp = netdev_priv(dev); |
486 | volatile struct lance_regs *ll = lp->ll; |
487 | |
488 | netif_stop_queue(dev); |
489 | del_timer_sync(timer: &lp->multicast_timer); |
490 | |
491 | /* Stop the card */ |
492 | ll->rap = LE_CSR0; |
493 | ll->rdp = LE_C0_STOP; |
494 | |
495 | free_irq(IRQ_AMIGA_PORTS, dev); |
496 | return 0; |
497 | } |
498 | |
499 | static inline int lance_reset(struct net_device *dev) |
500 | { |
501 | struct lance_private *lp = netdev_priv(dev); |
502 | volatile struct lance_regs *ll = lp->ll; |
503 | int status; |
504 | |
505 | /* Stop the lance */ |
506 | ll->rap = LE_CSR0; |
507 | ll->rdp = LE_C0_STOP; |
508 | |
509 | load_csrs(lp); |
510 | |
511 | lance_init_ring(dev); |
512 | netif_trans_update(dev); /* prevent tx timeout */ |
513 | netif_start_queue(dev); |
514 | |
515 | status = init_restart_lance(lp); |
516 | netdev_dbg(dev, "Lance restart=%d\n" , status); |
517 | |
518 | return status; |
519 | } |
520 | |
521 | static void lance_tx_timeout(struct net_device *dev, unsigned int txqueue) |
522 | { |
523 | struct lance_private *lp = netdev_priv(dev); |
524 | volatile struct lance_regs *ll = lp->ll; |
525 | |
526 | netdev_err(dev, format: "transmit timed out, status %04x, reset\n" , ll->rdp); |
527 | lance_reset(dev); |
528 | netif_wake_queue(dev); |
529 | } |
530 | |
531 | static netdev_tx_t lance_start_xmit(struct sk_buff *skb, |
532 | struct net_device *dev) |
533 | { |
534 | struct lance_private *lp = netdev_priv(dev); |
535 | volatile struct lance_regs *ll = lp->ll; |
536 | volatile struct lance_init_block *ib = lp->init_block; |
537 | int entry, skblen; |
538 | int status = NETDEV_TX_OK; |
539 | unsigned long flags; |
540 | |
541 | if (skb_padto(skb, ETH_ZLEN)) |
542 | return NETDEV_TX_OK; |
543 | skblen = max_t(unsigned, skb->len, ETH_ZLEN); |
544 | |
545 | local_irq_save(flags); |
546 | |
547 | if (!lance_tx_buffs_avail(lp)) |
548 | goto out_free; |
549 | |
550 | /* dump the packet */ |
551 | print_hex_dump_debug("skb->data: " , DUMP_PREFIX_NONE, 16, 1, skb->data, |
552 | 64, true); |
553 | |
554 | entry = lp->tx_new & lp->tx_ring_mod_mask; |
555 | ib->btx_ring[entry].length = (-skblen) | 0xf000; |
556 | ib->btx_ring[entry].misc = 0; |
557 | |
558 | skb_copy_from_linear_data(skb, to: (void *)&ib->tx_buf[entry][0], len: skblen); |
559 | |
560 | /* Now, give the packet to the lance */ |
561 | ib->btx_ring[entry].tmd1_bits = (LE_T1_POK | LE_T1_OWN); |
562 | lp->tx_new = (lp->tx_new+1) & lp->tx_ring_mod_mask; |
563 | dev->stats.tx_bytes += skblen; |
564 | |
565 | if (lance_tx_buffs_avail(lp) <= 0) |
566 | netif_stop_queue(dev); |
567 | |
568 | /* Kick the lance: transmit now */ |
569 | ll->rdp = LE_C0_INEA | LE_C0_TDMD; |
570 | out_free: |
571 | dev_kfree_skb(skb); |
572 | |
573 | local_irq_restore(flags); |
574 | |
575 | return status; |
576 | } |
577 | |
578 | /* taken from the depca driver */ |
579 | static void lance_load_multicast(struct net_device *dev) |
580 | { |
581 | struct lance_private *lp = netdev_priv(dev); |
582 | volatile struct lance_init_block *ib = lp->init_block; |
583 | volatile u16 *mcast_table = (u16 *)&ib->filter; |
584 | struct netdev_hw_addr *ha; |
585 | u32 crc; |
586 | |
587 | /* set all multicast bits */ |
588 | if (dev->flags & IFF_ALLMULTI) { |
589 | ib->filter[0] = 0xffffffff; |
590 | ib->filter[1] = 0xffffffff; |
591 | return; |
592 | } |
593 | /* clear the multicast filter */ |
594 | ib->filter[0] = 0; |
595 | ib->filter[1] = 0; |
596 | |
597 | /* Add addresses */ |
598 | netdev_for_each_mc_addr(ha, dev) { |
599 | crc = ether_crc_le(6, ha->addr); |
600 | crc = crc >> 26; |
601 | mcast_table[crc >> 4] |= 1 << (crc & 0xf); |
602 | } |
603 | } |
604 | |
605 | static void lance_set_multicast(struct net_device *dev) |
606 | { |
607 | struct lance_private *lp = netdev_priv(dev); |
608 | volatile struct lance_init_block *ib = lp->init_block; |
609 | volatile struct lance_regs *ll = lp->ll; |
610 | |
611 | if (!netif_running(dev)) |
612 | return; |
613 | |
614 | if (lp->tx_old != lp->tx_new) { |
615 | mod_timer(timer: &lp->multicast_timer, expires: jiffies + 4); |
616 | netif_wake_queue(dev); |
617 | return; |
618 | } |
619 | |
620 | netif_stop_queue(dev); |
621 | |
622 | ll->rap = LE_CSR0; |
623 | ll->rdp = LE_C0_STOP; |
624 | lance_init_ring(dev); |
625 | |
626 | if (dev->flags & IFF_PROMISC) { |
627 | ib->mode |= LE_MO_PROM; |
628 | } else { |
629 | ib->mode &= ~LE_MO_PROM; |
630 | lance_load_multicast(dev); |
631 | } |
632 | load_csrs(lp); |
633 | init_restart_lance(lp); |
634 | netif_wake_queue(dev); |
635 | } |
636 | |
637 | static void lance_set_multicast_retry(struct timer_list *t) |
638 | { |
639 | struct lance_private *lp = from_timer(lp, t, multicast_timer); |
640 | |
641 | lance_set_multicast(dev: lp->dev); |
642 | } |
643 | |
644 | static int a2065_init_one(struct zorro_dev *z, |
645 | const struct zorro_device_id *ent); |
646 | static void a2065_remove_one(struct zorro_dev *z); |
647 | |
648 | |
649 | static const struct zorro_device_id a2065_zorro_tbl[] = { |
650 | { ZORRO_PROD_CBM_A2065_1 }, |
651 | { ZORRO_PROD_CBM_A2065_2 }, |
652 | { ZORRO_PROD_AMERISTAR_A2065 }, |
653 | { 0 } |
654 | }; |
655 | MODULE_DEVICE_TABLE(zorro, a2065_zorro_tbl); |
656 | |
657 | static struct zorro_driver a2065_driver = { |
658 | .name = "a2065" , |
659 | .id_table = a2065_zorro_tbl, |
660 | .probe = a2065_init_one, |
661 | .remove = a2065_remove_one, |
662 | }; |
663 | |
664 | static const struct net_device_ops lance_netdev_ops = { |
665 | .ndo_open = lance_open, |
666 | .ndo_stop = lance_close, |
667 | .ndo_start_xmit = lance_start_xmit, |
668 | .ndo_tx_timeout = lance_tx_timeout, |
669 | .ndo_set_rx_mode = lance_set_multicast, |
670 | .ndo_validate_addr = eth_validate_addr, |
671 | .ndo_set_mac_address = eth_mac_addr, |
672 | }; |
673 | |
674 | static int a2065_init_one(struct zorro_dev *z, |
675 | const struct zorro_device_id *ent) |
676 | { |
677 | struct net_device *dev; |
678 | struct lance_private *priv; |
679 | unsigned long board = z->resource.start; |
680 | unsigned long base_addr = board + A2065_LANCE; |
681 | unsigned long mem_start = board + A2065_RAM; |
682 | struct resource *r1, *r2; |
683 | u8 addr[ETH_ALEN]; |
684 | u32 serial; |
685 | int err; |
686 | |
687 | r1 = request_mem_region(base_addr, sizeof(struct lance_regs), |
688 | "Am7990" ); |
689 | if (!r1) |
690 | return -EBUSY; |
691 | r2 = request_mem_region(mem_start, A2065_RAM_SIZE, "RAM" ); |
692 | if (!r2) { |
693 | release_mem_region(base_addr, sizeof(struct lance_regs)); |
694 | return -EBUSY; |
695 | } |
696 | |
697 | dev = alloc_etherdev(sizeof(struct lance_private)); |
698 | if (!dev) { |
699 | release_mem_region(base_addr, sizeof(struct lance_regs)); |
700 | release_mem_region(mem_start, A2065_RAM_SIZE); |
701 | return -ENOMEM; |
702 | } |
703 | |
704 | priv = netdev_priv(dev); |
705 | |
706 | r1->name = dev->name; |
707 | r2->name = dev->name; |
708 | |
709 | serial = be32_to_cpu(z->rom.er_SerialNumber); |
710 | addr[0] = 0x00; |
711 | if (z->id != ZORRO_PROD_AMERISTAR_A2065) { /* Commodore */ |
712 | addr[1] = 0x80; |
713 | addr[2] = 0x10; |
714 | } else { /* Ameristar */ |
715 | addr[1] = 0x00; |
716 | addr[2] = 0x9f; |
717 | } |
718 | addr[3] = (serial >> 16) & 0xff; |
719 | addr[4] = (serial >> 8) & 0xff; |
720 | addr[5] = serial & 0xff; |
721 | eth_hw_addr_set(dev, addr); |
722 | dev->base_addr = (unsigned long)ZTWO_VADDR(base_addr); |
723 | dev->mem_start = (unsigned long)ZTWO_VADDR(mem_start); |
724 | dev->mem_end = dev->mem_start + A2065_RAM_SIZE; |
725 | |
726 | priv->ll = (volatile struct lance_regs *)dev->base_addr; |
727 | priv->init_block = (struct lance_init_block *)dev->mem_start; |
728 | priv->lance_init_block = (struct lance_init_block *)A2065_RAM; |
729 | priv->auto_select = 0; |
730 | priv->busmaster_regval = LE_C3_BSWP; |
731 | |
732 | priv->lance_log_rx_bufs = LANCE_LOG_RX_BUFFERS; |
733 | priv->lance_log_tx_bufs = LANCE_LOG_TX_BUFFERS; |
734 | priv->rx_ring_mod_mask = RX_RING_MOD_MASK; |
735 | priv->tx_ring_mod_mask = TX_RING_MOD_MASK; |
736 | priv->dev = dev; |
737 | |
738 | dev->netdev_ops = &lance_netdev_ops; |
739 | dev->watchdog_timeo = 5*HZ; |
740 | dev->dma = 0; |
741 | |
742 | timer_setup(&priv->multicast_timer, lance_set_multicast_retry, 0); |
743 | |
744 | err = register_netdev(dev); |
745 | if (err) { |
746 | release_mem_region(base_addr, sizeof(struct lance_regs)); |
747 | release_mem_region(mem_start, A2065_RAM_SIZE); |
748 | free_netdev(dev); |
749 | return err; |
750 | } |
751 | zorro_set_drvdata(z, data: dev); |
752 | |
753 | netdev_info(dev, format: "A2065 at 0x%08lx, Ethernet Address %pM\n" , |
754 | board, dev->dev_addr); |
755 | |
756 | return 0; |
757 | } |
758 | |
759 | |
760 | static void a2065_remove_one(struct zorro_dev *z) |
761 | { |
762 | struct net_device *dev = zorro_get_drvdata(z); |
763 | |
764 | unregister_netdev(dev); |
765 | release_mem_region(ZTWO_PADDR(dev->base_addr), |
766 | sizeof(struct lance_regs)); |
767 | release_mem_region(ZTWO_PADDR(dev->mem_start), A2065_RAM_SIZE); |
768 | free_netdev(dev); |
769 | } |
770 | |
771 | static int __init a2065_init_module(void) |
772 | { |
773 | return zorro_register_driver(&a2065_driver); |
774 | } |
775 | |
776 | static void __exit a2065_cleanup_module(void) |
777 | { |
778 | zorro_unregister_driver(&a2065_driver); |
779 | } |
780 | |
781 | module_init(a2065_init_module); |
782 | module_exit(a2065_cleanup_module); |
783 | |
784 | MODULE_LICENSE("GPL" ); |
785 | |