Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
smc9194.c
Go to the documentation of this file.
1 /*------------------------------------------------------------------------
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 ( [email protected] )
21  . contributors:
22  . Arnaldo Carvalho de Melo <[email protected]>
23  .
24  . Hardware multicast code from Peter Cammaert ( [email protected] )
25  .
26  . Sources:
27  . o SMC databook
28  . o skeleton.c by Donald Becker ( [email protected] )
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 
57 static const char version[] =
58  "smc9194.c:v0.14 12/15/00 by Erik Stahlman ([email protected])\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>
67 #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 
112 struct devlist {
113  unsigned int port;
114  unsigned int irq;
115 };
116 
117 #if defined(CONFIG_H8S_EDOSK2674)
118 static struct devlist smc_devlist[] __initdata = {
119  {.port = 0xf80000, .irq = 16},
120  {.port = 0, .irq = 0 },
121 };
122 #else
123 static 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.. */
191 struct smc_local {
192  /*
193  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  */
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 */
223 struct 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 */
229 static int smc_open(struct net_device *dev);
230 
231 /*
232  . Our watchdog timed out. Called by the networking layer
233 */
234 static 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 */
241 static int smc_close(struct net_device *dev);
242 
243 /*
244  . Finally, a call to set promiscuous mode ( for TCPDUMP and related
245  . programs ) and multicast modes.
246 */
247 static 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 */
259 static irqreturn_t smc_interrupt(int irq, void *);
260 /*
261  . This is a separate procedure to handle the receipt of a packet, to
262  . leave the interrupt code looking slightly cleaner
263 */
264 static 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 */
269 static 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 */
283 static 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
289 static 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 */
295 static 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 */
301 static netdev_tx_t smc_wait_to_send_packet( struct sk_buff * skb,
302  struct net_device *dev );
303 
304 /* this does a soft reset on the device */
305 static void smc_reset( int ioaddr );
306 
307 /* Enable Interrupts, Receive, and Transmit */
308 static void smc_enable( int ioaddr );
309 
310 /* this puts the device in an inactive state */
311 static 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. */
315 static 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 */
334 static 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 */
374 static 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 */
400 static 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, struct net_device *dev )
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 
436 static void smc_setmulticast(int ioaddr, struct net_device *dev)
437 {
438  int i;
439  unsigned char multicast_table[ 8 ];
440  struct netdev_hw_addr *ha;
441  /* 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 
447  netdev_for_each_mc_addr(ha, dev) {
448  int position;
449 
450  /* only use the low order bits */
451  position = ether_crc_le(6, ha->addr) & 0x3f;
452 
453  /* do some messy swapping to put the bit in the right spot */
454  multicast_table[invert3[position&7]] |=
455  (1<<invert3[(position>>3)&7]);
456 
457  }
458  /* now, the table can be loaded into the chipset */
459  SMC_SELECT_BANK( 3 );
460 
461  for ( i = 0; i < 8 ; i++ ) {
462  outb( multicast_table[i], ioaddr + MULTICAST1 + i );
463  }
464 }
465 
466 /*
467  . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
468  . Purpose:
469  . Attempt to allocate memory for a packet, if chip-memory is not
470  . available, then tell the card to generate an interrupt when it
471  . is available.
472  .
473  . Algorithm:
474  .
475  . o if the saved_skb is not currently null, then drop this packet
476  . on the floor. This should never happen, because of TBUSY.
477  . o if the saved_skb is null, then replace it with the current packet,
478  . o See if I can sending it now.
479  . o (NO): Enable interrupts and let the interrupt handler deal with it.
480  . o (YES):Send it now.
481 */
482 static netdev_tx_t smc_wait_to_send_packet(struct sk_buff *skb,
483  struct net_device *dev)
484 {
485  struct smc_local *lp = netdev_priv(dev);
486  unsigned int ioaddr = dev->base_addr;
487  word length;
488  unsigned short numPages;
489  word time_out;
490 
491  netif_stop_queue(dev);
492  /* Well, I want to send the packet.. but I don't know
493  if I can send it right now... */
494 
495  if ( lp->saved_skb) {
496  /* THIS SHOULD NEVER HAPPEN. */
497  dev->stats.tx_aborted_errors++;
498  printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
499  return NETDEV_TX_BUSY;
500  }
501  lp->saved_skb = skb;
502 
503  length = skb->len;
504 
505  if (length < ETH_ZLEN) {
506  if (skb_padto(skb, ETH_ZLEN)) {
507  netif_wake_queue(dev);
508  return NETDEV_TX_OK;
509  }
510  length = ETH_ZLEN;
511  }
512 
513  /*
514  ** The MMU wants the number of pages to be the number of 256 bytes
515  ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
516  **
517  ** Pkt size for allocating is data length +6 (for additional status words,
518  ** length and ctl!) If odd size last byte is included in this header.
519  */
520  numPages = ((length & 0xfffe) + 6) / 256;
521 
522  if (numPages > 7 ) {
523  printk(CARDNAME": Far too big packet error.\n");
524  /* freeing the packet is a good thing here... but should
525  . any packets of this size get down here? */
526  dev_kfree_skb (skb);
527  lp->saved_skb = NULL;
528  /* this IS an error, but, i don't want the skb saved */
529  netif_wake_queue(dev);
530  return NETDEV_TX_OK;
531  }
532  /* either way, a packet is waiting now */
533  lp->packets_waiting++;
534 
535  /* now, try to allocate the memory */
536  SMC_SELECT_BANK( 2 );
537  outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
538  /*
539  . Performance Hack
540  .
541  . wait a short amount of time.. if I can send a packet now, I send
542  . it now. Otherwise, I enable an interrupt and wait for one to be
543  . available.
544  .
545  . I could have handled this a slightly different way, by checking to
546  . see if any memory was available in the FREE MEMORY register. However,
547  . either way, I need to generate an allocation, and the allocation works
548  . no matter what, so I saw no point in checking free memory.
549  */
550  time_out = MEMORY_WAIT_TIME;
551  do {
552  word status;
553 
554  status = inb( ioaddr + INTERRUPT );
555  if ( status & IM_ALLOC_INT ) {
556  /* acknowledge the interrupt */
557  outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
558  break;
559  }
560  } while ( -- time_out );
561 
562  if ( !time_out ) {
563  /* oh well, wait until the chip finds memory later */
565  PRINTK2((CARDNAME": memory allocation deferred.\n"));
566  /* it's deferred, but I'll handle it later */
567  return NETDEV_TX_OK;
568  }
569  /* or YES! I can send the packet now.. */
570  smc_hardware_send_packet(dev);
571  netif_wake_queue(dev);
572  return NETDEV_TX_OK;
573 }
574 
575 /*
576  . Function: smc_hardware_send_packet(struct net_device * )
577  . Purpose:
578  . This sends the actual packet to the SMC9xxx chip.
579  .
580  . Algorithm:
581  . First, see if a saved_skb is available.
582  . ( this should NOT be called if there is no 'saved_skb'
583  . Now, find the packet number that the chip allocated
584  . Point the data pointers at it in memory
585  . Set the length word in the chip's memory
586  . Dump the packet to chip memory
587  . Check if a last byte is needed ( odd length packet )
588  . if so, set the control flag right
589  . Tell the card to send it
590  . Enable the transmit interrupt, so I know if it failed
591  . Free the kernel data if I actually sent it.
592 */
593 static void smc_hardware_send_packet( struct net_device * dev )
594 {
595  struct smc_local *lp = netdev_priv(dev);
596  byte packet_no;
597  struct sk_buff * skb = lp->saved_skb;
598  word length;
599  unsigned int ioaddr;
600  byte * buf;
601 
602  ioaddr = dev->base_addr;
603 
604  if ( !skb ) {
605  PRINTK((CARDNAME": In XMIT with no packet to send\n"));
606  return;
607  }
608  length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
609  buf = skb->data;
610 
611  /* If I get here, I _know_ there is a packet slot waiting for me */
612  packet_no = inb( ioaddr + PNR_ARR + 1 );
613  if ( packet_no & 0x80 ) {
614  /* or isn't there? BAD CHIP! */
615  printk(KERN_DEBUG CARDNAME": Memory allocation failed.\n");
616  dev_kfree_skb_any(skb);
617  lp->saved_skb = NULL;
618  netif_wake_queue(dev);
619  return;
620  }
621 
622  /* we have a packet address, so tell the card to use it */
623  outb( packet_no, ioaddr + PNR_ARR );
624 
625  /* point to the beginning of the packet */
626  outw( PTR_AUTOINC , ioaddr + POINTER );
627 
628  PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
629 #if SMC_DEBUG > 2
630  print_packet( buf, length );
631 #endif
632 
633  /* send the packet length ( +6 for status, length and ctl byte )
634  and the status word ( set to zeros ) */
635 #ifdef USE_32_BIT
636  outl( (length +6 ) << 16 , ioaddr + DATA_1 );
637 #else
638  outw( 0, ioaddr + DATA_1 );
639  /* send the packet length ( +6 for status words, length, and ctl*/
640  outb( (length+6) & 0xFF,ioaddr + DATA_1 );
641  outb( (length+6) >> 8 , ioaddr + DATA_1 );
642 #endif
643 
644  /* send the actual data
645  . I _think_ it's faster to send the longs first, and then
646  . mop up by sending the last word. It depends heavily
647  . on alignment, at least on the 486. Maybe it would be
648  . a good idea to check which is optimal? But that could take
649  . almost as much time as is saved?
650  */
651 #ifdef USE_32_BIT
652  if ( length & 0x2 ) {
653  outsl(ioaddr + DATA_1, buf, length >> 2 );
654 #if !defined(__H8300H__) && !defined(__H8300S__)
655  outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
656 #else
657  ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
658 #endif
659  }
660  else
661  outsl(ioaddr + DATA_1, buf, length >> 2 );
662 #else
663  outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
664 #endif
665  /* Send the last byte, if there is one. */
666 
667  if ( (length & 1) == 0 ) {
668  outw( 0, ioaddr + DATA_1 );
669  } else {
670  outb( buf[length -1 ], ioaddr + DATA_1 );
671  outb( 0x20, ioaddr + DATA_1);
672  }
673 
674  /* enable the interrupts */
676 
677  /* and let the chipset deal with it */
678  outw( MC_ENQUEUE , ioaddr + MMU_CMD );
679 
680  PRINTK2((CARDNAME": Sent packet of length %d\n", length));
681 
682  lp->saved_skb = NULL;
683  dev_kfree_skb_any (skb);
684 
685  dev->trans_start = jiffies;
686 
687  /* we can send another packet */
688  netif_wake_queue(dev);
689 }
690 
691 /*-------------------------------------------------------------------------
692  |
693  | smc_init(int unit)
694  | Input parameters:
695  | dev->base_addr == 0, try to find all possible locations
696  | dev->base_addr == 1, return failure code
697  | dev->base_addr == 2, always allocate space, and return success
698  | dev->base_addr == <anything else> this is the address to check
699  |
700  | Output:
701  | pointer to net_device or ERR_PTR(error)
702  |
703  ---------------------------------------------------------------------------
704 */
705 static int io;
706 static int irq;
707 static int ifport;
708 
710 {
711  struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
712  struct devlist *smcdev = smc_devlist;
713  int err = 0;
714 
715  if (!dev)
716  return ERR_PTR(-ENODEV);
717 
718  if (unit >= 0) {
719  sprintf(dev->name, "eth%d", unit);
721  io = dev->base_addr;
722  irq = dev->irq;
723  }
724 
725  if (io > 0x1ff) { /* Check a single specified location. */
726  err = smc_probe(dev, io);
727  } else if (io != 0) { /* Don't probe at all. */
728  err = -ENXIO;
729  } else {
730  for (;smcdev->port; smcdev++) {
731  if (smc_probe(dev, smcdev->port) == 0)
732  break;
733  }
734  if (!smcdev->port)
735  err = -ENODEV;
736  }
737  if (err)
738  goto out;
739  err = register_netdev(dev);
740  if (err)
741  goto out1;
742  return dev;
743 out1:
744  free_irq(dev->irq, dev);
746 out:
747  free_netdev(dev);
748  return ERR_PTR(err);
749 }
750 
751 /*----------------------------------------------------------------------
752  . smc_findirq
753  .
754  . This routine has a simple purpose -- make the SMC chip generate an
755  . interrupt, so an auto-detect routine can detect it, and find the IRQ,
756  ------------------------------------------------------------------------
757 */
758 static int __init smc_findirq(int ioaddr)
759 {
760 #ifndef NO_AUTOPROBE
761  int timeout = 20;
762  unsigned long cookie;
763 
764 
765  cookie = probe_irq_on();
766 
767  /*
768  * What I try to do here is trigger an ALLOC_INT. This is done
769  * by allocating a small chunk of memory, which will give an interrupt
770  * when done.
771  */
772 
773 
774  SMC_SELECT_BANK(2);
775  /* enable ALLOCation interrupts ONLY */
776  outb( IM_ALLOC_INT, ioaddr + INT_MASK );
777 
778  /*
779  . Allocate 512 bytes of memory. Note that the chip was just
780  . reset so all the memory is available
781  */
782  outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
783 
784  /*
785  . Wait until positive that the interrupt has been generated
786  */
787  while ( timeout ) {
789 
790  int_status = inb( ioaddr + INTERRUPT );
791 
792  if ( int_status & IM_ALLOC_INT )
793  break; /* got the interrupt */
794  timeout--;
795  }
796  /* there is really nothing that I can do here if timeout fails,
797  as probe_irq_off will return a 0 anyway, which is what I
798  want in this case. Plus, the clean up is needed in both
799  cases. */
800 
801  /* DELAY HERE!
802  On a fast machine, the status might change before the interrupt
803  is given to the processor. This means that the interrupt was
804  never detected, and probe_irq_off fails to report anything.
805  This should fix probe_irq_* problems.
806  */
807  SMC_DELAY();
808  SMC_DELAY();
809 
810  /* and disable all interrupts again */
811  outb( 0, ioaddr + INT_MASK );
812 
813  /* and return what I found */
814  return probe_irq_off(cookie);
815 #else /* NO_AUTOPROBE */
816  struct devlist *smcdev;
817  for (smcdev = smc_devlist; smcdev->port; smcdev++) {
818  if (smcdev->port == ioaddr)
819  return smcdev->irq;
820  }
821  return 0;
822 #endif
823 }
824 
825 static const struct net_device_ops smc_netdev_ops = {
826  .ndo_open = smc_open,
827  .ndo_stop = smc_close,
828  .ndo_start_xmit = smc_wait_to_send_packet,
829  .ndo_tx_timeout = smc_timeout,
830  .ndo_set_rx_mode = smc_set_multicast_list,
831  .ndo_change_mtu = eth_change_mtu,
832  .ndo_set_mac_address = eth_mac_addr,
833  .ndo_validate_addr = eth_validate_addr,
834 };
835 
836 /*----------------------------------------------------------------------
837  . Function: smc_probe( int ioaddr )
838  .
839  . Purpose:
840  . Tests to see if a given ioaddr points to an SMC9xxx chip.
841  . Returns a 0 on success
842  .
843  . Algorithm:
844  . (1) see if the high byte of BANK_SELECT is 0x33
845  . (2) compare the ioaddr with the base register's address
846  . (3) see if I recognize the chip ID in the appropriate register
847  .
848  .---------------------------------------------------------------------
849  */
850 
851 /*---------------------------------------------------------------
852  . Here I do typical initialization tasks.
853  .
854  . o Initialize the structure if needed
855  . o print out my vanity message if not done so already
856  . o print out what type of hardware is detected
857  . o print out the ethernet address
858  . o find the IRQ
859  . o set up my private data
860  . o configure the dev structure with my subroutines
861  . o actually GRAB the irq.
862  . o GRAB the region
863  .-----------------------------------------------------------------
864 */
865 static int __init smc_probe(struct net_device *dev, int ioaddr)
866 {
867  int i, memory, retval;
868  static unsigned version_printed;
869  unsigned int bank;
870 
871  const char *version_string;
872  const char *if_string;
873 
874  /* registers */
875  word revision_register;
876  word base_address_register;
877  word configuration_register;
878  word memory_info_register;
879  word memory_cfg_register;
880 
881  /* Grab the region so that no one else tries to probe our ioports. */
882  if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
883  return -EBUSY;
884 
885  dev->irq = irq;
886  dev->if_port = ifport;
887 
888  /* First, see if the high byte is 0x33 */
889  bank = inw( ioaddr + BANK_SELECT );
890  if ( (bank & 0xFF00) != 0x3300 ) {
891  retval = -ENODEV;
892  goto err_out;
893  }
894  /* The above MIGHT indicate a device, but I need to write to further
895  test this. */
896  outw( 0x0, ioaddr + BANK_SELECT );
897  bank = inw( ioaddr + BANK_SELECT );
898  if ( (bank & 0xFF00 ) != 0x3300 ) {
899  retval = -ENODEV;
900  goto err_out;
901  }
902 #if !defined(CONFIG_H8S_EDOSK2674)
903  /* well, we've already written once, so hopefully another time won't
904  hurt. This time, I need to switch the bank register to bank 1,
905  so I can access the base address register */
906  SMC_SELECT_BANK(1);
907  base_address_register = inw( ioaddr + BASE );
908  if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {
909  printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "
910  "Probably not a SMC chip\n",
911  ioaddr, base_address_register >> 3 & 0x3E0 );
912  /* well, the base address register didn't match. Must not have
913  been a SMC chip after all. */
914  retval = -ENODEV;
915  goto err_out;
916  }
917 #else
918  (void)base_address_register; /* Warning suppression */
919 #endif
920 
921 
922  /* check if the revision register is something that I recognize.
923  These might need to be added to later, as future revisions
924  could be added. */
925  SMC_SELECT_BANK(3);
926  revision_register = inw( ioaddr + REVISION );
927  if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {
928  /* I don't recognize this chip, so... */
929  printk(CARDNAME ": IO %x: Unrecognized revision register:"
930  " %x, Contact author.\n", ioaddr, revision_register);
931 
932  retval = -ENODEV;
933  goto err_out;
934  }
935 
936  /* at this point I'll assume that the chip is an SMC9xxx.
937  It might be prudent to check a listing of MAC addresses
938  against the hardware address, or do some other tests. */
939 
940  if (version_printed++ == 0)
941  printk("%s", version);
942 
943  /* fill in some of the fields */
944  dev->base_addr = ioaddr;
945 
946  /*
947  . Get the MAC address ( bank 1, regs 4 - 9 )
948  */
949  SMC_SELECT_BANK( 1 );
950  for ( i = 0; i < 6; i += 2 ) {
951  word address;
952 
953  address = inw( ioaddr + ADDR0 + i );
954  dev->dev_addr[ i + 1] = address >> 8;
955  dev->dev_addr[ i ] = address & 0xFF;
956  }
957 
958  /* get the memory information */
959 
960  SMC_SELECT_BANK( 0 );
961  memory_info_register = inw( ioaddr + MIR );
962  memory_cfg_register = inw( ioaddr + MCR );
963  memory = ( memory_cfg_register >> 9 ) & 0x7; /* multiplier */
964  memory *= 256 * ( memory_info_register & 0xFF );
965 
966  /*
967  Now, I want to find out more about the chip. This is sort of
968  redundant, but it's cleaner to have it in both, rather than having
969  one VERY long probe procedure.
970  */
971  SMC_SELECT_BANK(3);
972  revision_register = inw( ioaddr + REVISION );
973  version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];
974  if ( !version_string ) {
975  /* I shouldn't get here because this call was done before.... */
976  retval = -ENODEV;
977  goto err_out;
978  }
979 
980  /* is it using AUI or 10BaseT ? */
981  if ( dev->if_port == 0 ) {
982  SMC_SELECT_BANK(1);
983  configuration_register = inw( ioaddr + CONFIG );
984  if ( configuration_register & CFG_AUI_SELECT )
985  dev->if_port = 2;
986  else
987  dev->if_port = 1;
988  }
989  if_string = interfaces[ dev->if_port - 1 ];
990 
991  /* now, reset the chip, and put it into a known state */
992  smc_reset( ioaddr );
993 
994  /*
995  . If dev->irq is 0, then the device has to be banged on to see
996  . what the IRQ is.
997  .
998  . This banging doesn't always detect the IRQ, for unknown reasons.
999  . a workaround is to reset the chip and try again.
1000  .
1001  . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
1002  . be what is requested on the command line. I don't do that, mostly
1003  . because the card that I have uses a non-standard method of accessing
1004  . the IRQs, and because this _should_ work in most configurations.
1005  .
1006  . Specifying an IRQ is done with the assumption that the user knows
1007  . what (s)he is doing. No checking is done!!!!
1008  .
1009  */
1010  if ( dev->irq < 2 ) {
1011  int trials;
1012 
1013  trials = 3;
1014  while ( trials-- ) {
1015  dev->irq = smc_findirq( ioaddr );
1016  if ( dev->irq )
1017  break;
1018  /* kick the card and try again */
1019  smc_reset( ioaddr );
1020  }
1021  }
1022  if (dev->irq == 0 ) {
1023  printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1024  retval = -ENODEV;
1025  goto err_out;
1026  }
1027 
1028  /* now, print out the card info, in a short format.. */
1029 
1030  printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1031  version_string, revision_register & 0xF, ioaddr, dev->irq,
1032  if_string, memory );
1033  /*
1034  . Print the Ethernet address
1035  */
1036  printk("ADDR: %pM\n", dev->dev_addr);
1037 
1038  /* Grab the IRQ */
1039  retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);
1040  if (retval) {
1041  printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1042  dev->irq, retval);
1043  goto err_out;
1044  }
1045 
1046  dev->netdev_ops = &smc_netdev_ops;
1047  dev->watchdog_timeo = HZ/20;
1048 
1049  return 0;
1050 
1051 err_out:
1052  release_region(ioaddr, SMC_IO_EXTENT);
1053  return retval;
1054 }
1055 
1056 #if SMC_DEBUG > 2
1057 static void print_packet( byte * buf, int length )
1058 {
1059 #if 0
1060  int i;
1061  int remainder;
1062  int lines;
1063 
1064  printk("Packet of length %d\n", length);
1065  lines = length / 16;
1066  remainder = length % 16;
1067 
1068  for ( i = 0; i < lines ; i ++ ) {
1069  int cur;
1070 
1071  for ( cur = 0; cur < 8; cur ++ ) {
1072  byte a, b;
1073 
1074  a = *(buf ++ );
1075  b = *(buf ++ );
1076  printk("%02x%02x ", a, b );
1077  }
1078  printk("\n");
1079  }
1080  for ( i = 0; i < remainder/2 ; i++ ) {
1081  byte a, b;
1082 
1083  a = *(buf ++ );
1084  b = *(buf ++ );
1085  printk("%02x%02x ", a, b );
1086  }
1087  printk("\n");
1088 #endif
1089 }
1090 #endif
1091 
1092 
1093 /*
1094  * Open and Initialize the board
1095  *
1096  * Set up everything, reset the card, etc ..
1097  *
1098  */
1099 static int smc_open(struct net_device *dev)
1100 {
1101  int ioaddr = dev->base_addr;
1102 
1103  int i; /* used to set hw ethernet address */
1104 
1105  /* clear out all the junk that was put here before... */
1106  memset(netdev_priv(dev), 0, sizeof(struct smc_local));
1107 
1108  /* reset the hardware */
1109 
1110  smc_reset( ioaddr );
1111  smc_enable( ioaddr );
1112 
1113  /* Select which interface to use */
1114 
1115  SMC_SELECT_BANK( 1 );
1116  if ( dev->if_port == 1 ) {
1117  outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1118  ioaddr + CONFIG );
1119  }
1120  else if ( dev->if_port == 2 ) {
1121  outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1122  ioaddr + CONFIG );
1123  }
1124 
1125  /*
1126  According to Becker, I have to set the hardware address
1127  at this point, because the (l)user can set it with an
1128  ioctl. Easily done...
1129  */
1130  SMC_SELECT_BANK( 1 );
1131  for ( i = 0; i < 6; i += 2 ) {
1132  word address;
1133 
1134  address = dev->dev_addr[ i + 1 ] << 8 ;
1135  address |= dev->dev_addr[ i ];
1136  outw( address, ioaddr + ADDR0 + i );
1137  }
1138 
1139  netif_start_queue(dev);
1140  return 0;
1141 }
1142 
1143 /*--------------------------------------------------------
1144  . Called by the kernel to send a packet out into the void
1145  . of the net. This routine is largely based on
1146  . skeleton.c, from Becker.
1147  .--------------------------------------------------------
1148 */
1149 
1150 static void smc_timeout(struct net_device *dev)
1151 {
1152  /* If we get here, some higher level has decided we are broken.
1153  There should really be a "kick me" function call instead. */
1154  printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1155  tx_done(dev) ? "IRQ conflict" :
1156  "network cable problem");
1157  /* "kick" the adaptor */
1158  smc_reset( dev->base_addr );
1159  smc_enable( dev->base_addr );
1160  dev->trans_start = jiffies; /* prevent tx timeout */
1161  /* clear anything saved */
1162  ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;
1163  netif_wake_queue(dev);
1164 }
1165 
1166 /*-------------------------------------------------------------
1167  .
1168  . smc_rcv - receive a packet from the card
1169  .
1170  . There is ( at least ) a packet waiting to be read from
1171  . chip-memory.
1172  .
1173  . o Read the status
1174  . o If an error, record it
1175  . o otherwise, read in the packet
1176  --------------------------------------------------------------
1177 */
1178 static void smc_rcv(struct net_device *dev)
1179 {
1180  int ioaddr = dev->base_addr;
1181  int packet_number;
1182  word status;
1183  word packet_length;
1184 
1185  /* assume bank 2 */
1186 
1187  packet_number = inw( ioaddr + FIFO_PORTS );
1188 
1189  if ( packet_number & FP_RXEMPTY ) {
1190  /* we got called , but nothing was on the FIFO */
1191  PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n"));
1192  /* don't need to restore anything */
1193  return;
1194  }
1195 
1196  /* start reading from the start of the packet */
1197  outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1198 
1199  /* First two words are status and packet_length */
1200  status = inw( ioaddr + DATA_1 );
1201  packet_length = inw( ioaddr + DATA_1 );
1202 
1203  packet_length &= 0x07ff; /* mask off top bits */
1204 
1205  PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1206  /*
1207  . the packet length contains 3 extra words :
1208  . status, length, and an extra word with an odd byte .
1209  */
1210  packet_length -= 6;
1211 
1212  if ( !(status & RS_ERRORS ) ){
1213  /* do stuff to make a new packet */
1214  struct sk_buff * skb;
1215  byte * data;
1216 
1217  /* read one extra byte */
1218  if ( status & RS_ODDFRAME )
1219  packet_length++;
1220 
1221  /* set multicast stats */
1222  if ( status & RS_MULTICAST )
1223  dev->stats.multicast++;
1224 
1225  skb = netdev_alloc_skb(dev, packet_length + 5);
1226 
1227  if ( skb == NULL ) {
1228  printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1229  dev->stats.rx_dropped++;
1230  goto done;
1231  }
1232 
1233  /*
1234  ! This should work without alignment, but it could be
1235  ! in the worse case
1236  */
1237 
1238  skb_reserve( skb, 2 ); /* 16 bit alignment */
1239 
1240  data = skb_put( skb, packet_length);
1241 
1242 #ifdef USE_32_BIT
1243  /* QUESTION: Like in the TX routine, do I want
1244  to send the DWORDs or the bytes first, or some
1245  mixture. A mixture might improve already slow PIO
1246  performance */
1247  PRINTK3((" Reading %d dwords (and %d bytes)\n",
1248  packet_length >> 2, packet_length & 3 ));
1249  insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1250  /* read the left over bytes */
1251  insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1252  packet_length & 0x3 );
1253 #else
1254  PRINTK3((" Reading %d words and %d byte(s)\n",
1255  (packet_length >> 1 ), packet_length & 1 ));
1256  insw(ioaddr + DATA_1 , data, packet_length >> 1);
1257  if ( packet_length & 1 ) {
1258  data += packet_length & ~1;
1259  *(data++) = inb( ioaddr + DATA_1 );
1260  }
1261 #endif
1262 #if SMC_DEBUG > 2
1263  print_packet( data, packet_length );
1264 #endif
1265 
1266  skb->protocol = eth_type_trans(skb, dev );
1267  netif_rx(skb);
1268  dev->stats.rx_packets++;
1269  dev->stats.rx_bytes += packet_length;
1270  } else {
1271  /* error ... */
1272  dev->stats.rx_errors++;
1273 
1274  if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
1275  if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1276  dev->stats.rx_length_errors++;
1277  if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
1278  }
1279 
1280 done:
1281  /* error or good, tell the card to get rid of this packet */
1282  outw( MC_RELEASE, ioaddr + MMU_CMD );
1283 }
1284 
1285 
1286 /*************************************************************************
1287  . smc_tx
1288  .
1289  . Purpose: Handle a transmit error message. This will only be called
1290  . when an error, because of the AUTO_RELEASE mode.
1291  .
1292  . Algorithm:
1293  . Save pointer and packet no
1294  . Get the packet no from the top of the queue
1295  . check if it's valid ( if not, is this an error??? )
1296  . read the status word
1297  . record the error
1298  . ( resend? Not really, since we don't want old packets around )
1299  . Restore saved values
1300  ************************************************************************/
1301 static void smc_tx( struct net_device * dev )
1302 {
1303  int ioaddr = dev->base_addr;
1304  struct smc_local *lp = netdev_priv(dev);
1305  byte saved_packet;
1306  byte packet_no;
1307  word tx_status;
1308 
1309 
1310  /* assume bank 2 */
1311 
1312  saved_packet = inb( ioaddr + PNR_ARR );
1313  packet_no = inw( ioaddr + FIFO_PORTS );
1314  packet_no &= 0x7F;
1315 
1316  /* select this as the packet to read from */
1317  outb( packet_no, ioaddr + PNR_ARR );
1318 
1319  /* read the first word from this packet */
1320  outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1321 
1322  tx_status = inw( ioaddr + DATA_1 );
1323  PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));
1324 
1325  dev->stats.tx_errors++;
1326  if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1327  if ( tx_status & TS_LATCOL ) {
1328  printk(KERN_DEBUG CARDNAME
1329  ": Late collision occurred on last xmit.\n");
1330  dev->stats.tx_window_errors++;
1331  }
1332 #if 0
1333  if ( tx_status & TS_16COL ) { ... }
1334 #endif
1335 
1336  if ( tx_status & TS_SUCCESS ) {
1337  printk(CARDNAME": Successful packet caused interrupt\n");
1338  }
1339  /* re-enable transmit */
1340  SMC_SELECT_BANK( 0 );
1341  outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1342 
1343  /* kill the packet */
1344  SMC_SELECT_BANK( 2 );
1345  outw( MC_FREEPKT, ioaddr + MMU_CMD );
1346 
1347  /* one less packet waiting for me */
1348  lp->packets_waiting--;
1349 
1350  outb( saved_packet, ioaddr + PNR_ARR );
1351 }
1352 
1353 /*--------------------------------------------------------------------
1354  .
1355  . This is the main routine of the driver, to handle the device when
1356  . it needs some attention.
1357  .
1358  . So:
1359  . first, save state of the chipset
1360  . branch off into routines to handle each case, and acknowledge
1361  . each to the interrupt register
1362  . and finally restore state.
1363  .
1364  ---------------------------------------------------------------------*/
1365 
1366 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1367 {
1368  struct net_device *dev = dev_id;
1369  int ioaddr = dev->base_addr;
1370  struct smc_local *lp = netdev_priv(dev);
1371 
1372  byte status;
1373  word card_stats;
1374  byte mask;
1375  int timeout;
1376  /* state registers */
1377  word saved_bank;
1378  word saved_pointer;
1379  int handled = 0;
1380 
1381 
1382  PRINTK3((CARDNAME": SMC interrupt started\n"));
1383 
1384  saved_bank = inw( ioaddr + BANK_SELECT );
1385 
1386  SMC_SELECT_BANK(2);
1387  saved_pointer = inw( ioaddr + POINTER );
1388 
1389  mask = inb( ioaddr + INT_MASK );
1390  /* clear all interrupts */
1391  outb( 0, ioaddr + INT_MASK );
1392 
1393 
1394  /* set a timeout value, so I don't stay here forever */
1395  timeout = 4;
1396 
1397  PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));
1398  do {
1399  /* read the status flag, and mask it */
1400  status = inb( ioaddr + INTERRUPT ) & mask;
1401  if (!status )
1402  break;
1403 
1404  handled = 1;
1405 
1406  PRINTK3((KERN_WARNING CARDNAME
1407  ": Handling interrupt status %x\n", status));
1408 
1409  if (status & IM_RCV_INT) {
1410  /* Got a packet(s). */
1411  PRINTK2((KERN_WARNING CARDNAME
1412  ": Receive Interrupt\n"));
1413  smc_rcv(dev);
1414  } else if (status & IM_TX_INT ) {
1415  PRINTK2((KERN_WARNING CARDNAME
1416  ": TX ERROR handled\n"));
1417  smc_tx(dev);
1418  outb(IM_TX_INT, ioaddr + INTERRUPT );
1419  } else if (status & IM_TX_EMPTY_INT ) {
1420  /* update stats */
1421  SMC_SELECT_BANK( 0 );
1422  card_stats = inw( ioaddr + COUNTER );
1423  /* single collisions */
1424  dev->stats.collisions += card_stats & 0xF;
1425  card_stats >>= 4;
1426  /* multiple collisions */
1427  dev->stats.collisions += card_stats & 0xF;
1428 
1429  /* these are for when linux supports these statistics */
1430 
1431  SMC_SELECT_BANK( 2 );
1432  PRINTK2((KERN_WARNING CARDNAME
1433  ": TX_BUFFER_EMPTY handled\n"));
1434  outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1435  mask &= ~IM_TX_EMPTY_INT;
1436  dev->stats.tx_packets += lp->packets_waiting;
1437  lp->packets_waiting = 0;
1438 
1439  } else if (status & IM_ALLOC_INT ) {
1440  PRINTK2((KERN_DEBUG CARDNAME
1441  ": Allocation interrupt\n"));
1442  /* clear this interrupt so it doesn't happen again */
1443  mask &= ~IM_ALLOC_INT;
1444 
1445  smc_hardware_send_packet( dev );
1446 
1447  /* enable xmit interrupts based on this */
1448  mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1449 
1450  /* and let the card send more packets to me */
1451  netif_wake_queue(dev);
1452 
1453  PRINTK2((CARDNAME": Handoff done successfully.\n"));
1454  } else if (status & IM_RX_OVRN_INT ) {
1455  dev->stats.rx_errors++;
1456  dev->stats.rx_fifo_errors++;
1457  outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1458  } else if (status & IM_EPH_INT ) {
1459  PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));
1460  } else if (status & IM_ERCV_INT ) {
1461  PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));
1462  outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1463  }
1464  } while ( timeout -- );
1465 
1466 
1467  /* restore state register */
1468  SMC_SELECT_BANK( 2 );
1469  outb( mask, ioaddr + INT_MASK );
1470 
1471  PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));
1472  outw( saved_pointer, ioaddr + POINTER );
1473 
1474  SMC_SELECT_BANK( saved_bank );
1475 
1476  PRINTK3((CARDNAME ": Interrupt done\n"));
1477  return IRQ_RETVAL(handled);
1478 }
1479 
1480 
1481 /*----------------------------------------------------
1482  . smc_close
1483  .
1484  . this makes the board clean up everything that it can
1485  . and not talk to the outside world. Caused by
1486  . an 'ifconfig ethX down'
1487  .
1488  -----------------------------------------------------*/
1489 static int smc_close(struct net_device *dev)
1490 {
1491  netif_stop_queue(dev);
1492  /* clear everything */
1493  smc_shutdown( dev->base_addr );
1494 
1495  /* Update the statistics here. */
1496  return 0;
1497 }
1498 
1499 /*-----------------------------------------------------------
1500  . smc_set_multicast_list
1501  .
1502  . This routine will, depending on the values passed to it,
1503  . either make it accept multicast packets, go into
1504  . promiscuous mode ( for TCPDUMP and cousins ) or accept
1505  . a select set of multicast packets
1506 */
1507 static void smc_set_multicast_list(struct net_device *dev)
1508 {
1509  short ioaddr = dev->base_addr;
1510 
1511  SMC_SELECT_BANK(0);
1512  if ( dev->flags & IFF_PROMISC )
1513  outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1514 
1515 /* BUG? I never disable promiscuous mode if multicasting was turned on.
1516  Now, I turn off promiscuous mode, but I don't do anything to multicasting
1517  when promiscuous mode is turned on.
1518 */
1519 
1520  /* Here, I am setting this to accept all multicast packets.
1521  I don't need to zero the multicast table, because the flag is
1522  checked before the table is
1523  */
1524  else if (dev->flags & IFF_ALLMULTI)
1525  outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1526 
1527  /* We just get all multicast packets even if we only want them
1528  . from one source. This will be changed at some future
1529  . point. */
1530  else if (!netdev_mc_empty(dev)) {
1531  /* support hardware multicasting */
1532 
1533  /* be sure I get rid of flags I might have set */
1534  outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1535  ioaddr + RCR );
1536  /* NOTE: this has to set the bank, so make sure it is the
1537  last thing called. The bank is set to zero at the top */
1538  smc_setmulticast(ioaddr, dev);
1539  }
1540  else {
1541  outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1542  ioaddr + RCR );
1543 
1544  /*
1545  since I'm disabling all multicast entirely, I need to
1546  clear the multicast list
1547  */
1548  SMC_SELECT_BANK( 3 );
1549  outw( 0, ioaddr + MULTICAST1 );
1550  outw( 0, ioaddr + MULTICAST2 );
1551  outw( 0, ioaddr + MULTICAST3 );
1552  outw( 0, ioaddr + MULTICAST4 );
1553  }
1554 }
1555 
1556 #ifdef MODULE
1557 
1558 static struct net_device *devSMC9194;
1559 MODULE_LICENSE("GPL");
1560 
1561 module_param(io, int, 0);
1562 module_param(irq, int, 0);
1563 module_param(ifport, int, 0);
1564 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1565 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1566 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1567 
1568 int __init init_module(void)
1569 {
1570  if (io == 0)
1572  CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1573 
1574  /* copy the parameters from insmod into the device structure */
1575  devSMC9194 = smc_init(-1);
1576  if (IS_ERR(devSMC9194))
1577  return PTR_ERR(devSMC9194);
1578  return 0;
1579 }
1580 
1581 void __exit cleanup_module(void)
1582 {
1583  unregister_netdev(devSMC9194);
1584  free_irq(devSMC9194->irq, devSMC9194);
1585  release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1586  free_netdev(devSMC9194);
1587 }
1588 
1589 #endif /* MODULE */