blob: 3f2f7843aa4eacb86fc2923dec080695fd67647c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*------------------------------------------------------------------------
2 . smc9194.c
3 . This is a driver for SMC's 9000 series of Ethernet cards.
4 .
5 . Copyright (C) 1996 by Erik Stahlman
6 . This software may be used and distributed according to the terms
7 . of the GNU General Public License, incorporated herein by reference.
8 .
9 . "Features" of the SMC chip:
10 . 4608 byte packet memory. ( for the 91C92. Others have more )
11 . EEPROM for configuration
12 . AUI/TP selection ( mine has 10Base2/10BaseT select )
13 .
14 . Arguments:
15 . io = for the base address
16 . irq = for the IRQ
17 . ifport = 0 for autodetect, 1 for TP, 2 for AUI ( or 10base2 )
18 .
19 . author:
20 . Erik Stahlman ( erik@vt.edu )
21 . contributors:
22 . Arnaldo Carvalho de Melo <acme@conectiva.com.br>
23 .
24 . Hardware multicast code from Peter Cammaert ( pc@denkart.be )
25 .
26 . Sources:
27 . o SMC databook
28 . o skeleton.c by Donald Becker ( becker@scyld.com )
29 . o ( a LOT of advice from Becker as well )
30 .
31 . History:
32 . 12/07/95 Erik Stahlman written, got receive/xmit handled
33 . 01/03/96 Erik Stahlman worked out some bugs, actually usable!!! :-)
34 . 01/06/96 Erik Stahlman cleaned up some, better testing, etc
35 . 01/29/96 Erik Stahlman fixed autoirq, added multicast
36 . 02/01/96 Erik Stahlman 1. disabled all interrupts in smc_reset
37 . 2. got rid of post-decrementing bug -- UGH.
38 . 02/13/96 Erik Stahlman Tried to fix autoirq failure. Added more
39 . descriptive error messages.
40 . 02/15/96 Erik Stahlman Fixed typo that caused detection failure
41 . 02/23/96 Erik Stahlman Modified it to fit into kernel tree
42 . Added support to change hardware address
43 . Cleared stats on opens
44 . 02/26/96 Erik Stahlman Trial support for Kernel 1.2.13
45 . Kludge for automatic IRQ detection
46 . 03/04/96 Erik Stahlman Fixed kernel 1.3.70 +
47 . Fixed bug reported by Gardner Buchanan in
48 . smc_enable, with outw instead of outb
49 . 03/06/96 Erik Stahlman Added hardware multicast from Peter Cammaert
50 . 04/14/00 Heiko Pruessing (SMA Regelsysteme) Fixed bug in chip memory
51 . allocation
52 . 08/20/00 Arnaldo Melo fix kfree(skb) in smc_hardware_send_packet
53 . 12/15/00 Christian Jullien fix "Warning: kfree_skb on hard IRQ"
54 . 11/08/01 Matt Domsch Use common crc32 function
55 ----------------------------------------------------------------------------*/
56
57static const char version[] =
58 "smc9194.c:v0.14 12/15/00 by Erik Stahlman (erik@vt.edu)\n";
59
60#include <linux/module.h>
61#include <linux/kernel.h>
62#include <linux/types.h>
63#include <linux/fcntl.h>
64#include <linux/interrupt.h>
65#include <linux/ioport.h>
66#include <linux/in.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <linux/string.h>
68#include <linux/init.h>
69#include <linux/crc32.h>
70#include <linux/errno.h>
71#include <linux/netdevice.h>
72#include <linux/etherdevice.h>
73#include <linux/skbuff.h>
74#include <linux/bitops.h>
75
76#include <asm/io.h>
77
78#include "smc9194.h"
79
80#define DRV_NAME "smc9194"
81
82/*------------------------------------------------------------------------
83 .
84 . Configuration options, for the experienced user to change.
85 .
86 -------------------------------------------------------------------------*/
87
88/*
89 . Do you want to use 32 bit xfers? This should work on all chips, as
90 . the chipset is designed to accommodate them.
91*/
92#ifdef __sh__
93#undef USE_32_BIT
94#else
95#define USE_32_BIT 1
96#endif
97
98#if defined(__H8300H__) || defined(__H8300S__)
99#define NO_AUTOPROBE
100#undef insl
101#undef outsl
102#define insl(a,b,l) io_insl_noswap(a,b,l)
103#define outsl(a,b,l) io_outsl_noswap(a,b,l)
104#endif
105
106/*
107 .the SMC9194 can be at any of the following port addresses. To change,
108 .for a slightly different card, you can add it to the array. Keep in
109 .mind that the array must end in zero.
110*/
111
112struct devlist {
113 unsigned int port;
114 unsigned int irq;
115};
116
117#if defined(CONFIG_H8S_EDOSK2674)
118static struct devlist smc_devlist[] __initdata = {
119 {.port = 0xf80000, .irq = 16},
120 {.port = 0, .irq = 0 },
121};
122#else
123static struct devlist smc_devlist[] __initdata = {
124 {.port = 0x200, .irq = 0},
125 {.port = 0x220, .irq = 0},
126 {.port = 0x240, .irq = 0},
127 {.port = 0x260, .irq = 0},
128 {.port = 0x280, .irq = 0},
129 {.port = 0x2A0, .irq = 0},
130 {.port = 0x2C0, .irq = 0},
131 {.port = 0x2E0, .irq = 0},
132 {.port = 0x300, .irq = 0},
133 {.port = 0x320, .irq = 0},
134 {.port = 0x340, .irq = 0},
135 {.port = 0x360, .irq = 0},
136 {.port = 0x380, .irq = 0},
137 {.port = 0x3A0, .irq = 0},
138 {.port = 0x3C0, .irq = 0},
139 {.port = 0x3E0, .irq = 0},
140 {.port = 0, .irq = 0},
141};
142#endif
143/*
144 . Wait time for memory to be free. This probably shouldn't be
145 . tuned that much, as waiting for this means nothing else happens
146 . in the system
147*/
148#define MEMORY_WAIT_TIME 16
149
150/*
151 . DEBUGGING LEVELS
152 .
153 . 0 for normal operation
154 . 1 for slightly more details
155 . >2 for various levels of increasingly useless information
156 . 2 for interrupt tracking, status flags
157 . 3 for packet dumps, etc.
158*/
159#define SMC_DEBUG 0
160
161#if (SMC_DEBUG > 2 )
162#define PRINTK3(x) printk x
163#else
164#define PRINTK3(x)
165#endif
166
167#if SMC_DEBUG > 1
168#define PRINTK2(x) printk x
169#else
170#define PRINTK2(x)
171#endif
172
173#ifdef SMC_DEBUG
174#define PRINTK(x) printk x
175#else
176#define PRINTK(x)
177#endif
178
179
180/*------------------------------------------------------------------------
181 .
182 . The internal workings of the driver. If you are changing anything
183 . here with the SMC stuff, you should have the datasheet and known
184 . what you are doing.
185 .
186 -------------------------------------------------------------------------*/
187#define CARDNAME "SMC9194"
188
189
190/* store this information for the driver.. */
191struct smc_local {
192 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 If I have to wait until memory is available to send
194 a packet, I will store the skbuff here, until I get the
195 desired memory. Then, I'll send it out and free it.
196 */
197 struct sk_buff * saved_skb;
198
199 /*
200 . This keeps track of how many packets that I have
201 . sent out. When an TX_EMPTY interrupt comes, I know
202 . that all of these have been sent.
203 */
204 int packets_waiting;
205};
206
207
208/*-----------------------------------------------------------------
209 .
210 . The driver can be entered at any of the following entry points.
211 .
212 .------------------------------------------------------------------ */
213
214/*
215 . This is called by register_netdev(). It is responsible for
216 . checking the portlist for the SMC9000 series chipset. If it finds
217 . one, then it will initialize the device, find the hardware information,
218 . and sets up the appropriate device parameters.
219 . NOTE: Interrupts are *OFF* when this procedure is called.
220 .
221 . NB:This shouldn't be static since it is referred to externally.
222*/
223struct net_device *smc_init(int unit);
224
225/*
226 . The kernel calls this function when someone wants to use the device,
227 . typically 'ifconfig ethX up'.
228*/
229static int smc_open(struct net_device *dev);
230
231/*
232 . Our watchdog timed out. Called by the networking layer
233*/
234static void smc_timeout(struct net_device *dev);
235
236/*
237 . This is called by the kernel in response to 'ifconfig ethX down'. It
238 . is responsible for cleaning up everything that the open routine
239 . does, and maybe putting the card into a powerdown state.
240*/
241static int smc_close(struct net_device *dev);
242
243/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 . Finally, a call to set promiscuous mode ( for TCPDUMP and related
245 . programs ) and multicast modes.
246*/
247static void smc_set_multicast_list(struct net_device *dev);
248
249
250/*---------------------------------------------------------------
251 .
252 . Interrupt level calls..
253 .
254 ----------------------------------------------------------------*/
255
256/*
257 . Handles the actual interrupt
258*/
David Howells7d12e782006-10-05 14:55:46 +0100259static irqreturn_t smc_interrupt(int irq, void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260/*
261 . This is a separate procedure to handle the receipt of a packet, to
262 . leave the interrupt code looking slightly cleaner
263*/
264static inline void smc_rcv( struct net_device *dev );
265/*
266 . This handles a TX interrupt, which is only called when an error
267 . relating to a packet is sent.
268*/
269static inline void smc_tx( struct net_device * dev );
270
271/*
272 ------------------------------------------------------------
273 .
274 . Internal routines
275 .
276 ------------------------------------------------------------
277*/
278
279/*
280 . Test if a given location contains a chip, trying to cause as
281 . little damage as possible if it's not a SMC chip.
282*/
283static int smc_probe(struct net_device *dev, int ioaddr);
284
285/*
286 . A rather simple routine to print out a packet for debugging purposes.
287*/
288#if SMC_DEBUG > 2
289static void print_packet( byte *, int );
290#endif
291
292#define tx_done(dev) 1
293
294/* this is called to actually send the packet to the chip */
295static void smc_hardware_send_packet( struct net_device * dev );
296
297/* Since I am not sure if I will have enough room in the chip's ram
298 . to store the packet, I call this routine, which either sends it
299 . now, or generates an interrupt when the card is ready for the
300 . packet */
Stephen Hemminger613573252009-08-31 19:50:58 +0000301static netdev_tx_t smc_wait_to_send_packet( struct sk_buff * skb,
302 struct net_device *dev );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304/* this does a soft reset on the device */
305static void smc_reset( int ioaddr );
306
307/* Enable Interrupts, Receive, and Transmit */
308static void smc_enable( int ioaddr );
309
310/* this puts the device in an inactive state */
311static void smc_shutdown( int ioaddr );
312
313/* This routine will find the IRQ of the driver if one is not
314 . specified in the input to the device. */
315static int smc_findirq( int ioaddr );
316
317/*
318 . Function: smc_reset( int ioaddr )
319 . Purpose:
320 . This sets the SMC91xx chip to its normal state, hopefully from whatever
321 . mess that any other DOS driver has put it in.
322 .
323 . Maybe I should reset more registers to defaults in here? SOFTRESET should
324 . do that for me.
325 .
326 . Method:
327 . 1. send a SOFT RESET
328 . 2. wait for it to finish
329 . 3. enable autorelease mode
330 . 4. reset the memory management unit
331 . 5. clear all interrupts
332 .
333*/
334static void smc_reset( int ioaddr )
335{
336 /* This resets the registers mostly to defaults, but doesn't
337 affect EEPROM. That seems unnecessary */
338 SMC_SELECT_BANK( 0 );
339 outw( RCR_SOFTRESET, ioaddr + RCR );
340
341 /* this should pause enough for the chip to be happy */
342 SMC_DELAY( );
343
344 /* Set the transmit and receive configuration registers to
345 default values */
346 outw( RCR_CLEAR, ioaddr + RCR );
347 outw( TCR_CLEAR, ioaddr + TCR );
348
349 /* set the control register to automatically
350 release successfully transmitted packets, to make the best
351 use out of our limited memory */
352 SMC_SELECT_BANK( 1 );
353 outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );
354
355 /* Reset the MMU */
356 SMC_SELECT_BANK( 2 );
357 outw( MC_RESET, ioaddr + MMU_CMD );
358
359 /* Note: It doesn't seem that waiting for the MMU busy is needed here,
360 but this is a place where future chipsets _COULD_ break. Be wary
361 of issuing another MMU command right after this */
362
363 outb( 0, ioaddr + INT_MASK );
364}
365
366/*
367 . Function: smc_enable
368 . Purpose: let the chip talk to the outside work
369 . Method:
370 . 1. Enable the transmitter
371 . 2. Enable the receiver
372 . 3. Enable interrupts
373*/
374static void smc_enable( int ioaddr )
375{
376 SMC_SELECT_BANK( 0 );
377 /* see the header file for options in TCR/RCR NORMAL*/
378 outw( TCR_NORMAL, ioaddr + TCR );
379 outw( RCR_NORMAL, ioaddr + RCR );
380
381 /* now, enable interrupts */
382 SMC_SELECT_BANK( 2 );
383 outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
384}
385
386/*
387 . Function: smc_shutdown
388 . Purpose: closes down the SMC91xxx chip.
389 . Method:
390 . 1. zero the interrupt mask
391 . 2. clear the enable receive flag
392 . 3. clear the enable xmit flags
393 .
394 . TODO:
395 . (1) maybe utilize power down mode.
396 . Why not yet? Because while the chip will go into power down mode,
397 . the manual says that it will wake up in response to any I/O requests
398 . in the register space. Empirical results do not show this working.
399*/
400static void smc_shutdown( int ioaddr )
401{
402 /* no more interrupts for me */
403 SMC_SELECT_BANK( 2 );
404 outb( 0, ioaddr + INT_MASK );
405
406 /* and tell the card to stay away from that nasty outside world */
407 SMC_SELECT_BANK( 0 );
408 outb( RCR_CLEAR, ioaddr + RCR );
409 outb( TCR_CLEAR, ioaddr + TCR );
410#if 0
411 /* finally, shut the chip down */
412 SMC_SELECT_BANK( 1 );
413 outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL );
414#endif
415}
416
417
418/*
419 . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )
420 . Purpose:
421 . This sets the internal hardware table to filter out unwanted multicast
422 . packets before they take up memory.
423 .
424 . The SMC chip uses a hash table where the high 6 bits of the CRC of
425 . address are the offset into the table. If that bit is 1, then the
426 . multicast packet is accepted. Otherwise, it's dropped silently.
427 .
428 . To use the 6 bits as an offset into the table, the high 3 bits are the
429 . number of the 8 bit register, while the low 3 bits are the bit within
430 . that register.
431 .
432 . This routine is based very heavily on the one provided by Peter Cammaert.
433*/
434
435
Jiri Pirko567ec872010-02-23 23:17:07 +0000436static void smc_setmulticast(int ioaddr, struct net_device *dev)
437{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 int i;
439 unsigned char multicast_table[ 8 ];
Jiri Pirko567ec872010-02-23 23:17:07 +0000440 struct dev_mc_list *cur_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /* table for flipping the order of 3 bits */
442 unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
443
444 /* start with a table of all zeros: reject all */
445 memset( multicast_table, 0, sizeof( multicast_table ) );
446
Jiri Pirko567ec872010-02-23 23:17:07 +0000447 netdev_for_each_mc_addr(cur_addr, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 int position;
449
450 /* do we have a pointer here? */
451 if ( !cur_addr )
452 break;
453 /* make sure this is a multicast address - shouldn't this
454 be a given if we have it here ? */
455 if ( !( *cur_addr->dmi_addr & 1 ) )
456 continue;
457
458 /* only use the low order bits */
459 position = ether_crc_le(6, cur_addr->dmi_addr) & 0x3f;
460
461 /* do some messy swapping to put the bit in the right spot */
462 multicast_table[invert3[position&7]] |=
463 (1<<invert3[(position>>3)&7]);
464
465 }
466 /* now, the table can be loaded into the chipset */
467 SMC_SELECT_BANK( 3 );
468
469 for ( i = 0; i < 8 ; i++ ) {
470 outb( multicast_table[i], ioaddr + MULTICAST1 + i );
471 }
472}
473
474/*
475 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
476 . Purpose:
477 . Attempt to allocate memory for a packet, if chip-memory is not
478 . available, then tell the card to generate an interrupt when it
479 . is available.
480 .
481 . Algorithm:
482 .
483 . o if the saved_skb is not currently null, then drop this packet
484 . on the floor. This should never happen, because of TBUSY.
485 . o if the saved_skb is null, then replace it with the current packet,
486 . o See if I can sending it now.
487 . o (NO): Enable interrupts and let the interrupt handler deal with it.
488 . o (YES):Send it now.
489*/
Stephen Hemminger613573252009-08-31 19:50:58 +0000490static netdev_tx_t smc_wait_to_send_packet(struct sk_buff *skb,
491 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
493 struct smc_local *lp = netdev_priv(dev);
494 unsigned int ioaddr = dev->base_addr;
495 word length;
496 unsigned short numPages;
497 word time_out;
498
499 netif_stop_queue(dev);
500 /* Well, I want to send the packet.. but I don't know
501 if I can send it right now... */
502
503 if ( lp->saved_skb) {
504 /* THIS SHOULD NEVER HAPPEN. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700505 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
Patrick McHardy5b548142009-06-12 06:22:29 +0000507 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
509 lp->saved_skb = skb;
510
511 length = skb->len;
512
513 if (length < ETH_ZLEN) {
Herbert Xu5b057c62006-06-23 02:06:41 -0700514 if (skb_padto(skb, ETH_ZLEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 netif_wake_queue(dev);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000516 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 }
518 length = ETH_ZLEN;
519 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 /*
522 ** The MMU wants the number of pages to be the number of 256 bytes
523 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
524 **
525 ** Pkt size for allocating is data length +6 (for additional status words,
526 ** length and ctl!) If odd size last byte is included in this header.
527 */
528 numPages = ((length & 0xfffe) + 6) / 256;
529
530 if (numPages > 7 ) {
531 printk(CARDNAME": Far too big packet error. \n");
532 /* freeing the packet is a good thing here... but should
533 . any packets of this size get down here? */
534 dev_kfree_skb (skb);
535 lp->saved_skb = NULL;
536 /* this IS an error, but, i don't want the skb saved */
537 netif_wake_queue(dev);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000538 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 }
540 /* either way, a packet is waiting now */
541 lp->packets_waiting++;
542
543 /* now, try to allocate the memory */
544 SMC_SELECT_BANK( 2 );
545 outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
546 /*
547 . Performance Hack
548 .
549 . wait a short amount of time.. if I can send a packet now, I send
550 . it now. Otherwise, I enable an interrupt and wait for one to be
551 . available.
552 .
553 . I could have handled this a slightly different way, by checking to
554 . see if any memory was available in the FREE MEMORY register. However,
555 . either way, I need to generate an allocation, and the allocation works
556 . no matter what, so I saw no point in checking free memory.
557 */
558 time_out = MEMORY_WAIT_TIME;
559 do {
560 word status;
561
562 status = inb( ioaddr + INTERRUPT );
563 if ( status & IM_ALLOC_INT ) {
564 /* acknowledge the interrupt */
565 outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
566 break;
567 }
568 } while ( -- time_out );
569
570 if ( !time_out ) {
571 /* oh well, wait until the chip finds memory later */
572 SMC_ENABLE_INT( IM_ALLOC_INT );
573 PRINTK2((CARDNAME": memory allocation deferred. \n"));
574 /* it's deferred, but I'll handle it later */
Patrick McHardy6ed10652009-06-23 06:03:08 +0000575 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577 /* or YES! I can send the packet now.. */
578 smc_hardware_send_packet(dev);
579 netif_wake_queue(dev);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000580 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581}
582
583/*
584 . Function: smc_hardware_send_packet(struct net_device * )
585 . Purpose:
586 . This sends the actual packet to the SMC9xxx chip.
587 .
588 . Algorithm:
589 . First, see if a saved_skb is available.
590 . ( this should NOT be called if there is no 'saved_skb'
591 . Now, find the packet number that the chip allocated
592 . Point the data pointers at it in memory
593 . Set the length word in the chip's memory
594 . Dump the packet to chip memory
595 . Check if a last byte is needed ( odd length packet )
596 . if so, set the control flag right
597 . Tell the card to send it
598 . Enable the transmit interrupt, so I know if it failed
599 . Free the kernel data if I actually sent it.
600*/
601static void smc_hardware_send_packet( struct net_device * dev )
602{
603 struct smc_local *lp = netdev_priv(dev);
604 byte packet_no;
605 struct sk_buff * skb = lp->saved_skb;
606 word length;
607 unsigned int ioaddr;
608 byte * buf;
609
610 ioaddr = dev->base_addr;
611
612 if ( !skb ) {
613 PRINTK((CARDNAME": In XMIT with no packet to send \n"));
614 return;
615 }
616 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
617 buf = skb->data;
618
619 /* If I get here, I _know_ there is a packet slot waiting for me */
620 packet_no = inb( ioaddr + PNR_ARR + 1 );
621 if ( packet_no & 0x80 ) {
622 /* or isn't there? BAD CHIP! */
623 printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
624 dev_kfree_skb_any(skb);
625 lp->saved_skb = NULL;
626 netif_wake_queue(dev);
627 return;
628 }
629
630 /* we have a packet address, so tell the card to use it */
631 outb( packet_no, ioaddr + PNR_ARR );
632
633 /* point to the beginning of the packet */
634 outw( PTR_AUTOINC , ioaddr + POINTER );
635
636 PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
637#if SMC_DEBUG > 2
638 print_packet( buf, length );
639#endif
640
641 /* send the packet length ( +6 for status, length and ctl byte )
642 and the status word ( set to zeros ) */
643#ifdef USE_32_BIT
644 outl( (length +6 ) << 16 , ioaddr + DATA_1 );
645#else
646 outw( 0, ioaddr + DATA_1 );
647 /* send the packet length ( +6 for status words, length, and ctl*/
648 outb( (length+6) & 0xFF,ioaddr + DATA_1 );
649 outb( (length+6) >> 8 , ioaddr + DATA_1 );
650#endif
651
652 /* send the actual data
653 . I _think_ it's faster to send the longs first, and then
654 . mop up by sending the last word. It depends heavily
655 . on alignment, at least on the 486. Maybe it would be
656 . a good idea to check which is optimal? But that could take
657 . almost as much time as is saved?
658 */
659#ifdef USE_32_BIT
660 if ( length & 0x2 ) {
661 outsl(ioaddr + DATA_1, buf, length >> 2 );
662#if !defined(__H8300H__) && !defined(__H8300S__)
663 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
664#else
665 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
666#endif
667 }
668 else
669 outsl(ioaddr + DATA_1, buf, length >> 2 );
670#else
671 outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
672#endif
673 /* Send the last byte, if there is one. */
674
675 if ( (length & 1) == 0 ) {
676 outw( 0, ioaddr + DATA_1 );
677 } else {
678 outb( buf[length -1 ], ioaddr + DATA_1 );
679 outb( 0x20, ioaddr + DATA_1);
680 }
681
682 /* enable the interrupts */
683 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
684
685 /* and let the chipset deal with it */
686 outw( MC_ENQUEUE , ioaddr + MMU_CMD );
687
688 PRINTK2((CARDNAME": Sent packet of length %d \n",length));
689
690 lp->saved_skb = NULL;
691 dev_kfree_skb_any (skb);
692
693 dev->trans_start = jiffies;
694
695 /* we can send another packet */
696 netif_wake_queue(dev);
697
698 return;
699}
700
701/*-------------------------------------------------------------------------
702 |
703 | smc_init(int unit)
704 | Input parameters:
705 | dev->base_addr == 0, try to find all possible locations
706 | dev->base_addr == 1, return failure code
707 | dev->base_addr == 2, always allocate space, and return success
708 | dev->base_addr == <anything else> this is the address to check
709 |
710 | Output:
711 | pointer to net_device or ERR_PTR(error)
712 |
713 ---------------------------------------------------------------------------
714*/
715static int io;
716static int irq;
717static int ifport;
718
719struct net_device * __init smc_init(int unit)
720{
721 struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
Randy Dunlapa2bd2ec2006-06-10 13:30:10 -0700722 struct devlist *smcdev = smc_devlist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 int err = 0;
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (!dev)
726 return ERR_PTR(-ENODEV);
727
728 if (unit >= 0) {
729 sprintf(dev->name, "eth%d", unit);
730 netdev_boot_setup_check(dev);
731 io = dev->base_addr;
732 irq = dev->irq;
733 }
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (io > 0x1ff) { /* Check a single specified location. */
736 err = smc_probe(dev, io);
737 } else if (io != 0) { /* Don't probe at all. */
738 err = -ENXIO;
739 } else {
740 for (;smcdev->port; smcdev++) {
741 if (smc_probe(dev, smcdev->port) == 0)
742 break;
743 }
744 if (!smcdev->port)
745 err = -ENODEV;
746 }
747 if (err)
748 goto out;
749 err = register_netdev(dev);
750 if (err)
751 goto out1;
752 return dev;
753out1:
754 free_irq(dev->irq, dev);
755 release_region(dev->base_addr, SMC_IO_EXTENT);
756out:
757 free_netdev(dev);
758 return ERR_PTR(err);
759}
760
761/*----------------------------------------------------------------------
762 . smc_findirq
763 .
764 . This routine has a simple purpose -- make the SMC chip generate an
765 . interrupt, so an auto-detect routine can detect it, and find the IRQ,
766 ------------------------------------------------------------------------
767*/
Hannes Ederdac499f2008-12-25 23:56:45 -0800768static int __init smc_findirq(int ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770#ifndef NO_AUTOPROBE
771 int timeout = 20;
772 unsigned long cookie;
773
774
775 cookie = probe_irq_on();
776
777 /*
778 * What I try to do here is trigger an ALLOC_INT. This is done
779 * by allocating a small chunk of memory, which will give an interrupt
780 * when done.
781 */
782
783
784 SMC_SELECT_BANK(2);
785 /* enable ALLOCation interrupts ONLY */
786 outb( IM_ALLOC_INT, ioaddr + INT_MASK );
787
788 /*
789 . Allocate 512 bytes of memory. Note that the chip was just
790 . reset so all the memory is available
791 */
792 outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
793
794 /*
795 . Wait until positive that the interrupt has been generated
796 */
797 while ( timeout ) {
798 byte int_status;
799
800 int_status = inb( ioaddr + INTERRUPT );
801
802 if ( int_status & IM_ALLOC_INT )
803 break; /* got the interrupt */
804 timeout--;
805 }
806 /* there is really nothing that I can do here if timeout fails,
807 as probe_irq_off will return a 0 anyway, which is what I
808 want in this case. Plus, the clean up is needed in both
809 cases. */
810
811 /* DELAY HERE!
812 On a fast machine, the status might change before the interrupt
813 is given to the processor. This means that the interrupt was
814 never detected, and probe_irq_off fails to report anything.
815 This should fix probe_irq_* problems.
816 */
817 SMC_DELAY();
818 SMC_DELAY();
819
820 /* and disable all interrupts again */
821 outb( 0, ioaddr + INT_MASK );
822
823 /* and return what I found */
824 return probe_irq_off(cookie);
825#else /* NO_AUTOPROBE */
826 struct devlist *smcdev;
827 for (smcdev = smc_devlist; smcdev->port; smcdev++) {
828 if (smcdev->port == ioaddr)
829 return smcdev->irq;
830 }
831 return 0;
832#endif
833}
834
Stephen Hemminger32670c32009-03-26 15:11:29 +0000835static const struct net_device_ops smc_netdev_ops = {
836 .ndo_open = smc_open,
837 .ndo_stop = smc_close,
838 .ndo_start_xmit = smc_wait_to_send_packet,
839 .ndo_tx_timeout = smc_timeout,
840 .ndo_set_multicast_list = smc_set_multicast_list,
841 .ndo_change_mtu = eth_change_mtu,
842 .ndo_set_mac_address = eth_mac_addr,
843 .ndo_validate_addr = eth_validate_addr,
844};
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846/*----------------------------------------------------------------------
847 . Function: smc_probe( int ioaddr )
848 .
849 . Purpose:
850 . Tests to see if a given ioaddr points to an SMC9xxx chip.
851 . Returns a 0 on success
852 .
853 . Algorithm:
854 . (1) see if the high byte of BANK_SELECT is 0x33
855 . (2) compare the ioaddr with the base register's address
856 . (3) see if I recognize the chip ID in the appropriate register
857 .
858 .---------------------------------------------------------------------
859 */
860
861/*---------------------------------------------------------------
862 . Here I do typical initialization tasks.
863 .
864 . o Initialize the structure if needed
865 . o print out my vanity message if not done so already
866 . o print out what type of hardware is detected
867 . o print out the ethernet address
868 . o find the IRQ
869 . o set up my private data
870 . o configure the dev structure with my subroutines
871 . o actually GRAB the irq.
872 . o GRAB the region
873 .-----------------------------------------------------------------
874*/
875static int __init smc_probe(struct net_device *dev, int ioaddr)
876{
877 int i, memory, retval;
878 static unsigned version_printed;
879 unsigned int bank;
880
881 const char *version_string;
882 const char *if_string;
883
884 /* registers */
885 word revision_register;
886 word base_address_register;
887 word configuration_register;
888 word memory_info_register;
889 word memory_cfg_register;
890
891 /* Grab the region so that no one else tries to probe our ioports. */
892 if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
893 return -EBUSY;
894
895 dev->irq = irq;
896 dev->if_port = ifport;
897
898 /* First, see if the high byte is 0x33 */
899 bank = inw( ioaddr + BANK_SELECT );
900 if ( (bank & 0xFF00) != 0x3300 ) {
901 retval = -ENODEV;
902 goto err_out;
903 }
904 /* The above MIGHT indicate a device, but I need to write to further
905 test this. */
906 outw( 0x0, ioaddr + BANK_SELECT );
907 bank = inw( ioaddr + BANK_SELECT );
908 if ( (bank & 0xFF00 ) != 0x3300 ) {
909 retval = -ENODEV;
910 goto err_out;
911 }
912#if !defined(CONFIG_H8S_EDOSK2674)
913 /* well, we've already written once, so hopefully another time won't
914 hurt. This time, I need to switch the bank register to bank 1,
915 so I can access the base address register */
916 SMC_SELECT_BANK(1);
917 base_address_register = inw( ioaddr + BASE );
918 if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {
Joe Perches24500222007-11-19 17:48:28 -0800919 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 "Probably not a SMC chip\n",
921 ioaddr, base_address_register >> 3 & 0x3E0 );
922 /* well, the base address register didn't match. Must not have
923 been a SMC chip after all. */
924 retval = -ENODEV;
925 goto err_out;
926 }
927#else
928 (void)base_address_register; /* Warning suppression */
929#endif
930
931
932 /* check if the revision register is something that I recognize.
933 These might need to be added to later, as future revisions
934 could be added. */
935 SMC_SELECT_BANK(3);
936 revision_register = inw( ioaddr + REVISION );
937 if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {
938 /* I don't recognize this chip, so... */
939 printk(CARDNAME ": IO %x: Unrecognized revision register:"
940 " %x, Contact author. \n", ioaddr, revision_register );
941
942 retval = -ENODEV;
943 goto err_out;
944 }
945
946 /* at this point I'll assume that the chip is an SMC9xxx.
947 It might be prudent to check a listing of MAC addresses
948 against the hardware address, or do some other tests. */
949
950 if (version_printed++ == 0)
951 printk("%s", version);
952
953 /* fill in some of the fields */
954 dev->base_addr = ioaddr;
955
956 /*
957 . Get the MAC address ( bank 1, regs 4 - 9 )
958 */
959 SMC_SELECT_BANK( 1 );
960 for ( i = 0; i < 6; i += 2 ) {
961 word address;
962
963 address = inw( ioaddr + ADDR0 + i );
964 dev->dev_addr[ i + 1] = address >> 8;
965 dev->dev_addr[ i ] = address & 0xFF;
966 }
967
968 /* get the memory information */
969
970 SMC_SELECT_BANK( 0 );
971 memory_info_register = inw( ioaddr + MIR );
972 memory_cfg_register = inw( ioaddr + MCR );
973 memory = ( memory_cfg_register >> 9 ) & 0x7; /* multiplier */
974 memory *= 256 * ( memory_info_register & 0xFF );
975
976 /*
977 Now, I want to find out more about the chip. This is sort of
978 redundant, but it's cleaner to have it in both, rather than having
979 one VERY long probe procedure.
980 */
981 SMC_SELECT_BANK(3);
982 revision_register = inw( ioaddr + REVISION );
983 version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];
984 if ( !version_string ) {
985 /* I shouldn't get here because this call was done before.... */
986 retval = -ENODEV;
987 goto err_out;
988 }
989
990 /* is it using AUI or 10BaseT ? */
991 if ( dev->if_port == 0 ) {
992 SMC_SELECT_BANK(1);
993 configuration_register = inw( ioaddr + CONFIG );
994 if ( configuration_register & CFG_AUI_SELECT )
995 dev->if_port = 2;
996 else
997 dev->if_port = 1;
998 }
999 if_string = interfaces[ dev->if_port - 1 ];
1000
1001 /* now, reset the chip, and put it into a known state */
1002 smc_reset( ioaddr );
1003
1004 /*
1005 . If dev->irq is 0, then the device has to be banged on to see
1006 . what the IRQ is.
1007 .
1008 . This banging doesn't always detect the IRQ, for unknown reasons.
1009 . a workaround is to reset the chip and try again.
1010 .
1011 . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
1012 . be what is requested on the command line. I don't do that, mostly
1013 . because the card that I have uses a non-standard method of accessing
1014 . the IRQs, and because this _should_ work in most configurations.
1015 .
1016 . Specifying an IRQ is done with the assumption that the user knows
1017 . what (s)he is doing. No checking is done!!!!
1018 .
1019 */
1020 if ( dev->irq < 2 ) {
1021 int trials;
1022
1023 trials = 3;
1024 while ( trials-- ) {
1025 dev->irq = smc_findirq( ioaddr );
1026 if ( dev->irq )
1027 break;
1028 /* kick the card and try again */
1029 smc_reset( ioaddr );
1030 }
1031 }
1032 if (dev->irq == 0 ) {
1033 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1034 retval = -ENODEV;
1035 goto err_out;
1036 }
1037
1038 /* now, print out the card info, in a short format.. */
1039
1040 printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1041 version_string, revision_register & 0xF, ioaddr, dev->irq,
1042 if_string, memory );
1043 /*
1044 . Print the Ethernet address
1045 */
Johannes Berge1749612008-10-27 15:59:26 -07001046 printk("ADDR: %pM\n", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 /* set the private data to zero by default */
Wang Chen8f15ea42008-11-12 23:38:36 -08001049 memset(netdev_priv(dev), 0, sizeof(struct smc_local));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
1051 /* Grab the IRQ */
Joe Perchesa0607fd2009-11-18 23:29:17 -08001052 retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (retval) {
1054 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1055 dev->irq, retval);
1056 goto err_out;
1057 }
1058
Stephen Hemminger32670c32009-03-26 15:11:29 +00001059 dev->netdev_ops = &smc_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 dev->watchdog_timeo = HZ/20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
1062 return 0;
1063
1064err_out:
1065 release_region(ioaddr, SMC_IO_EXTENT);
1066 return retval;
1067}
1068
1069#if SMC_DEBUG > 2
1070static void print_packet( byte * buf, int length )
1071{
1072#if 0
1073 int i;
1074 int remainder;
1075 int lines;
1076
1077 printk("Packet of length %d \n", length );
1078 lines = length / 16;
1079 remainder = length % 16;
1080
1081 for ( i = 0; i < lines ; i ++ ) {
1082 int cur;
1083
1084 for ( cur = 0; cur < 8; cur ++ ) {
1085 byte a, b;
1086
1087 a = *(buf ++ );
1088 b = *(buf ++ );
1089 printk("%02x%02x ", a, b );
1090 }
1091 printk("\n");
1092 }
1093 for ( i = 0; i < remainder/2 ; i++ ) {
1094 byte a, b;
1095
1096 a = *(buf ++ );
1097 b = *(buf ++ );
1098 printk("%02x%02x ", a, b );
1099 }
1100 printk("\n");
1101#endif
1102}
1103#endif
1104
1105
1106/*
1107 * Open and Initialize the board
1108 *
1109 * Set up everything, reset the card, etc ..
1110 *
1111 */
1112static int smc_open(struct net_device *dev)
1113{
1114 int ioaddr = dev->base_addr;
1115
1116 int i; /* used to set hw ethernet address */
1117
1118 /* clear out all the junk that was put here before... */
Wang Chen8f15ea42008-11-12 23:38:36 -08001119 memset(netdev_priv(dev), 0, sizeof(struct smc_local));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 /* reset the hardware */
1122
1123 smc_reset( ioaddr );
1124 smc_enable( ioaddr );
1125
1126 /* Select which interface to use */
1127
1128 SMC_SELECT_BANK( 1 );
1129 if ( dev->if_port == 1 ) {
1130 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1131 ioaddr + CONFIG );
1132 }
1133 else if ( dev->if_port == 2 ) {
1134 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1135 ioaddr + CONFIG );
1136 }
1137
1138 /*
1139 According to Becker, I have to set the hardware address
1140 at this point, because the (l)user can set it with an
1141 ioctl. Easily done...
1142 */
1143 SMC_SELECT_BANK( 1 );
1144 for ( i = 0; i < 6; i += 2 ) {
1145 word address;
1146
1147 address = dev->dev_addr[ i + 1 ] << 8 ;
1148 address |= dev->dev_addr[ i ];
1149 outw( address, ioaddr + ADDR0 + i );
1150 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 netif_start_queue(dev);
1153 return 0;
1154}
1155
1156/*--------------------------------------------------------
1157 . Called by the kernel to send a packet out into the void
1158 . of the net. This routine is largely based on
1159 . skeleton.c, from Becker.
1160 .--------------------------------------------------------
1161*/
1162
1163static void smc_timeout(struct net_device *dev)
1164{
1165 /* If we get here, some higher level has decided we are broken.
1166 There should really be a "kick me" function call instead. */
1167 printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1168 tx_done(dev) ? "IRQ conflict" :
1169 "network cable problem");
1170 /* "kick" the adaptor */
1171 smc_reset( dev->base_addr );
1172 smc_enable( dev->base_addr );
1173 dev->trans_start = jiffies;
1174 /* clear anything saved */
Wang Chen8f15ea42008-11-12 23:38:36 -08001175 ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 netif_wake_queue(dev);
1177}
1178
1179/*-------------------------------------------------------------
1180 .
1181 . smc_rcv - receive a packet from the card
1182 .
1183 . There is ( at least ) a packet waiting to be read from
1184 . chip-memory.
1185 .
1186 . o Read the status
1187 . o If an error, record it
1188 . o otherwise, read in the packet
1189 --------------------------------------------------------------
1190*/
1191static void smc_rcv(struct net_device *dev)
1192{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 int ioaddr = dev->base_addr;
1194 int packet_number;
1195 word status;
1196 word packet_length;
1197
1198 /* assume bank 2 */
1199
1200 packet_number = inw( ioaddr + FIFO_PORTS );
1201
1202 if ( packet_number & FP_RXEMPTY ) {
1203 /* we got called , but nothing was on the FIFO */
1204 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
1205 /* don't need to restore anything */
1206 return;
1207 }
1208
1209 /* start reading from the start of the packet */
1210 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1211
1212 /* First two words are status and packet_length */
1213 status = inw( ioaddr + DATA_1 );
1214 packet_length = inw( ioaddr + DATA_1 );
1215
1216 packet_length &= 0x07ff; /* mask off top bits */
1217
1218 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1219 /*
1220 . the packet length contains 3 extra words :
1221 . status, length, and an extra word with an odd byte .
1222 */
1223 packet_length -= 6;
1224
1225 if ( !(status & RS_ERRORS ) ){
1226 /* do stuff to make a new packet */
1227 struct sk_buff * skb;
1228 byte * data;
1229
1230 /* read one extra byte */
1231 if ( status & RS_ODDFRAME )
1232 packet_length++;
1233
1234 /* set multicast stats */
1235 if ( status & RS_MULTICAST )
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001236 dev->stats.multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
1238 skb = dev_alloc_skb( packet_length + 5);
1239
1240 if ( skb == NULL ) {
1241 printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001242 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 goto done;
1244 }
1245
1246 /*
1247 ! This should work without alignment, but it could be
1248 ! in the worse case
1249 */
1250
1251 skb_reserve( skb, 2 ); /* 16 bit alignment */
1252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 data = skb_put( skb, packet_length);
1254
1255#ifdef USE_32_BIT
1256 /* QUESTION: Like in the TX routine, do I want
1257 to send the DWORDs or the bytes first, or some
1258 mixture. A mixture might improve already slow PIO
1259 performance */
1260 PRINTK3((" Reading %d dwords (and %d bytes) \n",
1261 packet_length >> 2, packet_length & 3 ));
1262 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1263 /* read the left over bytes */
1264 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1265 packet_length & 0x3 );
1266#else
1267 PRINTK3((" Reading %d words and %d byte(s) \n",
1268 (packet_length >> 1 ), packet_length & 1 ));
1269 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1270 if ( packet_length & 1 ) {
1271 data += packet_length & ~1;
1272 *(data++) = inb( ioaddr + DATA_1 );
1273 }
1274#endif
1275#if SMC_DEBUG > 2
1276 print_packet( data, packet_length );
1277#endif
1278
1279 skb->protocol = eth_type_trans(skb, dev );
1280 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001281 dev->stats.rx_packets++;
1282 dev->stats.rx_bytes += packet_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 } else {
1284 /* error ... */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001285 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001287 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001289 dev->stats.rx_length_errors++;
1290 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 }
1292
1293done:
1294 /* error or good, tell the card to get rid of this packet */
1295 outw( MC_RELEASE, ioaddr + MMU_CMD );
1296}
1297
1298
1299/*************************************************************************
1300 . smc_tx
1301 .
1302 . Purpose: Handle a transmit error message. This will only be called
1303 . when an error, because of the AUTO_RELEASE mode.
1304 .
1305 . Algorithm:
1306 . Save pointer and packet no
1307 . Get the packet no from the top of the queue
1308 . check if it's valid ( if not, is this an error??? )
1309 . read the status word
1310 . record the error
1311 . ( resend? Not really, since we don't want old packets around )
1312 . Restore saved values
1313 ************************************************************************/
1314static void smc_tx( struct net_device * dev )
1315{
1316 int ioaddr = dev->base_addr;
1317 struct smc_local *lp = netdev_priv(dev);
1318 byte saved_packet;
1319 byte packet_no;
1320 word tx_status;
1321
1322
1323 /* assume bank 2 */
1324
1325 saved_packet = inb( ioaddr + PNR_ARR );
1326 packet_no = inw( ioaddr + FIFO_PORTS );
1327 packet_no &= 0x7F;
1328
1329 /* select this as the packet to read from */
1330 outb( packet_no, ioaddr + PNR_ARR );
1331
1332 /* read the first word from this packet */
1333 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1334
1335 tx_status = inw( ioaddr + DATA_1 );
1336 PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
1337
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001338 dev->stats.tx_errors++;
1339 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if ( tx_status & TS_LATCOL ) {
1341 printk(KERN_DEBUG CARDNAME
1342 ": Late collision occurred on last xmit.\n");
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001343 dev->stats.tx_window_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345#if 0
1346 if ( tx_status & TS_16COL ) { ... }
1347#endif
1348
1349 if ( tx_status & TS_SUCCESS ) {
1350 printk(CARDNAME": Successful packet caused interrupt \n");
1351 }
1352 /* re-enable transmit */
1353 SMC_SELECT_BANK( 0 );
1354 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1355
1356 /* kill the packet */
1357 SMC_SELECT_BANK( 2 );
1358 outw( MC_FREEPKT, ioaddr + MMU_CMD );
1359
1360 /* one less packet waiting for me */
1361 lp->packets_waiting--;
1362
1363 outb( saved_packet, ioaddr + PNR_ARR );
1364 return;
1365}
1366
1367/*--------------------------------------------------------------------
1368 .
1369 . This is the main routine of the driver, to handle the device when
1370 . it needs some attention.
1371 .
1372 . So:
1373 . first, save state of the chipset
1374 . branch off into routines to handle each case, and acknowledge
1375 . each to the interrupt register
1376 . and finally restore state.
1377 .
1378 ---------------------------------------------------------------------*/
1379
David Howells7d12e782006-10-05 14:55:46 +01001380static irqreturn_t smc_interrupt(int irq, void * dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
1382 struct net_device *dev = dev_id;
1383 int ioaddr = dev->base_addr;
1384 struct smc_local *lp = netdev_priv(dev);
1385
1386 byte status;
1387 word card_stats;
1388 byte mask;
1389 int timeout;
1390 /* state registers */
1391 word saved_bank;
1392 word saved_pointer;
1393 int handled = 0;
1394
1395
1396 PRINTK3((CARDNAME": SMC interrupt started \n"));
1397
1398 saved_bank = inw( ioaddr + BANK_SELECT );
1399
1400 SMC_SELECT_BANK(2);
1401 saved_pointer = inw( ioaddr + POINTER );
1402
1403 mask = inb( ioaddr + INT_MASK );
1404 /* clear all interrupts */
1405 outb( 0, ioaddr + INT_MASK );
1406
1407
1408 /* set a timeout value, so I don't stay here forever */
1409 timeout = 4;
1410
1411 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
1412 do {
1413 /* read the status flag, and mask it */
1414 status = inb( ioaddr + INTERRUPT ) & mask;
1415 if (!status )
1416 break;
1417
1418 handled = 1;
1419
1420 PRINTK3((KERN_WARNING CARDNAME
1421 ": Handling interrupt status %x \n", status ));
1422
1423 if (status & IM_RCV_INT) {
1424 /* Got a packet(s). */
1425 PRINTK2((KERN_WARNING CARDNAME
1426 ": Receive Interrupt\n"));
1427 smc_rcv(dev);
1428 } else if (status & IM_TX_INT ) {
1429 PRINTK2((KERN_WARNING CARDNAME
1430 ": TX ERROR handled\n"));
1431 smc_tx(dev);
1432 outb(IM_TX_INT, ioaddr + INTERRUPT );
1433 } else if (status & IM_TX_EMPTY_INT ) {
1434 /* update stats */
1435 SMC_SELECT_BANK( 0 );
1436 card_stats = inw( ioaddr + COUNTER );
1437 /* single collisions */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001438 dev->stats.collisions += card_stats & 0xF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 card_stats >>= 4;
1440 /* multiple collisions */
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001441 dev->stats.collisions += card_stats & 0xF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
1443 /* these are for when linux supports these statistics */
1444
1445 SMC_SELECT_BANK( 2 );
1446 PRINTK2((KERN_WARNING CARDNAME
1447 ": TX_BUFFER_EMPTY handled\n"));
1448 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1449 mask &= ~IM_TX_EMPTY_INT;
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001450 dev->stats.tx_packets += lp->packets_waiting;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451 lp->packets_waiting = 0;
1452
1453 } else if (status & IM_ALLOC_INT ) {
1454 PRINTK2((KERN_DEBUG CARDNAME
1455 ": Allocation interrupt \n"));
1456 /* clear this interrupt so it doesn't happen again */
1457 mask &= ~IM_ALLOC_INT;
1458
1459 smc_hardware_send_packet( dev );
1460
1461 /* enable xmit interrupts based on this */
1462 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1463
1464 /* and let the card send more packets to me */
1465 netif_wake_queue(dev);
1466
1467 PRINTK2((CARDNAME": Handoff done successfully.\n"));
1468 } else if (status & IM_RX_OVRN_INT ) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -07001469 dev->stats.rx_errors++;
1470 dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1472 } else if (status & IM_EPH_INT ) {
1473 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
1474 } else if (status & IM_ERCV_INT ) {
1475 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
1476 outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1477 }
1478 } while ( timeout -- );
1479
1480
1481 /* restore state register */
1482 SMC_SELECT_BANK( 2 );
1483 outb( mask, ioaddr + INT_MASK );
1484
1485 PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
1486 outw( saved_pointer, ioaddr + POINTER );
1487
1488 SMC_SELECT_BANK( saved_bank );
1489
1490 PRINTK3((CARDNAME ": Interrupt done\n"));
1491 return IRQ_RETVAL(handled);
1492}
1493
1494
1495/*----------------------------------------------------
1496 . smc_close
1497 .
1498 . this makes the board clean up everything that it can
1499 . and not talk to the outside world. Caused by
1500 . an 'ifconfig ethX down'
1501 .
1502 -----------------------------------------------------*/
1503static int smc_close(struct net_device *dev)
1504{
1505 netif_stop_queue(dev);
1506 /* clear everything */
1507 smc_shutdown( dev->base_addr );
1508
1509 /* Update the statistics here. */
1510 return 0;
1511}
1512
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513/*-----------------------------------------------------------
1514 . smc_set_multicast_list
1515 .
1516 . This routine will, depending on the values passed to it,
1517 . either make it accept multicast packets, go into
1518 . promiscuous mode ( for TCPDUMP and cousins ) or accept
1519 . a select set of multicast packets
1520*/
1521static void smc_set_multicast_list(struct net_device *dev)
1522{
1523 short ioaddr = dev->base_addr;
1524
1525 SMC_SELECT_BANK(0);
1526 if ( dev->flags & IFF_PROMISC )
1527 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1528
1529/* BUG? I never disable promiscuous mode if multicasting was turned on.
1530 Now, I turn off promiscuous mode, but I don't do anything to multicasting
1531 when promiscuous mode is turned on.
1532*/
1533
1534 /* Here, I am setting this to accept all multicast packets.
1535 I don't need to zero the multicast table, because the flag is
1536 checked before the table is
1537 */
1538 else if (dev->flags & IFF_ALLMULTI)
1539 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1540
1541 /* We just get all multicast packets even if we only want them
1542 . from one source. This will be changed at some future
1543 . point. */
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001544 else if (!netdev_mc_empty(dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 /* support hardware multicasting */
1546
1547 /* be sure I get rid of flags I might have set */
1548 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1549 ioaddr + RCR );
1550 /* NOTE: this has to set the bank, so make sure it is the
1551 last thing called. The bank is set to zero at the top */
Jiri Pirko567ec872010-02-23 23:17:07 +00001552 smc_setmulticast(ioaddr, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 }
1554 else {
1555 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1556 ioaddr + RCR );
1557
1558 /*
1559 since I'm disabling all multicast entirely, I need to
1560 clear the multicast list
1561 */
1562 SMC_SELECT_BANK( 3 );
1563 outw( 0, ioaddr + MULTICAST1 );
1564 outw( 0, ioaddr + MULTICAST2 );
1565 outw( 0, ioaddr + MULTICAST3 );
1566 outw( 0, ioaddr + MULTICAST4 );
1567 }
1568}
1569
1570#ifdef MODULE
1571
1572static struct net_device *devSMC9194;
1573MODULE_LICENSE("GPL");
1574
1575module_param(io, int, 0);
1576module_param(irq, int, 0);
1577module_param(ifport, int, 0);
1578MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1579MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1580MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1581
Randy Dunlapa2bd2ec2006-06-10 13:30:10 -07001582int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583{
1584 if (io == 0)
1585 printk(KERN_WARNING
1586 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1587
1588 /* copy the parameters from insmod into the device structure */
1589 devSMC9194 = smc_init(-1);
1590 if (IS_ERR(devSMC9194))
1591 return PTR_ERR(devSMC9194);
1592 return 0;
1593}
1594
Al Viroafc8eb42006-06-14 18:50:53 -04001595void __exit cleanup_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596{
1597 unregister_netdev(devSMC9194);
1598 free_irq(devSMC9194->irq, devSMC9194);
1599 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1600 free_netdev(devSMC9194);
1601}
1602
1603#endif /* MODULE */