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 ( 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
57 static 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>
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 */
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 */
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 */
smc_reset(int ioaddr)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 */
smc_enable(int ioaddr)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 */
smc_shutdown(int ioaddr)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
smc_setmulticast(int ioaddr,struct net_device * dev)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 */
smc_wait_to_send_packet(struct sk_buff * skb,struct net_device * dev)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 */
564 SMC_ENABLE_INT( IM_ALLOC_INT );
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 */
smc_hardware_send_packet(struct net_device * dev)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 */
675 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
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
smc_init(int unit)709 struct net_device * __init smc_init(int unit)
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);
720 netdev_boot_setup_check(dev);
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);
745 release_region(dev->base_addr, SMC_IO_EXTENT);
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 */
smc_findirq(int ioaddr)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 ) {
788 byte int_status;
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 */
smc_probe(struct net_device * dev,int ioaddr)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
print_packet(byte * buf,int length)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 */
smc_open(struct net_device * dev)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
smc_timeout(struct net_device * dev)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 */
smc_rcv(struct net_device * dev)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 if ( skb == NULL ) {
1227 dev->stats.rx_dropped++;
1228 goto done;
1229 }
1230
1231 /*
1232 ! This should work without alignment, but it could be
1233 ! in the worse case
1234 */
1235
1236 skb_reserve( skb, 2 ); /* 16 bit alignment */
1237
1238 data = skb_put( skb, packet_length);
1239
1240 #ifdef USE_32_BIT
1241 /* QUESTION: Like in the TX routine, do I want
1242 to send the DWORDs or the bytes first, or some
1243 mixture. A mixture might improve already slow PIO
1244 performance */
1245 PRINTK3((" Reading %d dwords (and %d bytes)\n",
1246 packet_length >> 2, packet_length & 3 ));
1247 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1248 /* read the left over bytes */
1249 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1250 packet_length & 0x3 );
1251 #else
1252 PRINTK3((" Reading %d words and %d byte(s)\n",
1253 (packet_length >> 1 ), packet_length & 1 ));
1254 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1255 if ( packet_length & 1 ) {
1256 data += packet_length & ~1;
1257 *(data++) = inb( ioaddr + DATA_1 );
1258 }
1259 #endif
1260 #if SMC_DEBUG > 2
1261 print_packet( data, packet_length );
1262 #endif
1263
1264 skb->protocol = eth_type_trans(skb, dev );
1265 netif_rx(skb);
1266 dev->stats.rx_packets++;
1267 dev->stats.rx_bytes += packet_length;
1268 } else {
1269 /* error ... */
1270 dev->stats.rx_errors++;
1271
1272 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
1273 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1274 dev->stats.rx_length_errors++;
1275 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
1276 }
1277
1278 done:
1279 /* error or good, tell the card to get rid of this packet */
1280 outw( MC_RELEASE, ioaddr + MMU_CMD );
1281 }
1282
1283
1284 /*************************************************************************
1285 . smc_tx
1286 .
1287 . Purpose: Handle a transmit error message. This will only be called
1288 . when an error, because of the AUTO_RELEASE mode.
1289 .
1290 . Algorithm:
1291 . Save pointer and packet no
1292 . Get the packet no from the top of the queue
1293 . check if it's valid ( if not, is this an error??? )
1294 . read the status word
1295 . record the error
1296 . ( resend? Not really, since we don't want old packets around )
1297 . Restore saved values
1298 ************************************************************************/
smc_tx(struct net_device * dev)1299 static void smc_tx( struct net_device * dev )
1300 {
1301 int ioaddr = dev->base_addr;
1302 struct smc_local *lp = netdev_priv(dev);
1303 byte saved_packet;
1304 byte packet_no;
1305 word tx_status;
1306
1307
1308 /* assume bank 2 */
1309
1310 saved_packet = inb( ioaddr + PNR_ARR );
1311 packet_no = inw( ioaddr + FIFO_PORTS );
1312 packet_no &= 0x7F;
1313
1314 /* select this as the packet to read from */
1315 outb( packet_no, ioaddr + PNR_ARR );
1316
1317 /* read the first word from this packet */
1318 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1319
1320 tx_status = inw( ioaddr + DATA_1 );
1321 PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));
1322
1323 dev->stats.tx_errors++;
1324 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1325 if ( tx_status & TS_LATCOL ) {
1326 printk(KERN_DEBUG CARDNAME
1327 ": Late collision occurred on last xmit.\n");
1328 dev->stats.tx_window_errors++;
1329 }
1330 #if 0
1331 if ( tx_status & TS_16COL ) { ... }
1332 #endif
1333
1334 if ( tx_status & TS_SUCCESS ) {
1335 printk(CARDNAME": Successful packet caused interrupt\n");
1336 }
1337 /* re-enable transmit */
1338 SMC_SELECT_BANK( 0 );
1339 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1340
1341 /* kill the packet */
1342 SMC_SELECT_BANK( 2 );
1343 outw( MC_FREEPKT, ioaddr + MMU_CMD );
1344
1345 /* one less packet waiting for me */
1346 lp->packets_waiting--;
1347
1348 outb( saved_packet, ioaddr + PNR_ARR );
1349 }
1350
1351 /*--------------------------------------------------------------------
1352 .
1353 . This is the main routine of the driver, to handle the device when
1354 . it needs some attention.
1355 .
1356 . So:
1357 . first, save state of the chipset
1358 . branch off into routines to handle each case, and acknowledge
1359 . each to the interrupt register
1360 . and finally restore state.
1361 .
1362 ---------------------------------------------------------------------*/
1363
smc_interrupt(int irq,void * dev_id)1364 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1365 {
1366 struct net_device *dev = dev_id;
1367 int ioaddr = dev->base_addr;
1368 struct smc_local *lp = netdev_priv(dev);
1369
1370 byte status;
1371 word card_stats;
1372 byte mask;
1373 int timeout;
1374 /* state registers */
1375 word saved_bank;
1376 word saved_pointer;
1377 int handled = 0;
1378
1379
1380 PRINTK3((CARDNAME": SMC interrupt started\n"));
1381
1382 saved_bank = inw( ioaddr + BANK_SELECT );
1383
1384 SMC_SELECT_BANK(2);
1385 saved_pointer = inw( ioaddr + POINTER );
1386
1387 mask = inb( ioaddr + INT_MASK );
1388 /* clear all interrupts */
1389 outb( 0, ioaddr + INT_MASK );
1390
1391
1392 /* set a timeout value, so I don't stay here forever */
1393 timeout = 4;
1394
1395 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));
1396 do {
1397 /* read the status flag, and mask it */
1398 status = inb( ioaddr + INTERRUPT ) & mask;
1399 if (!status )
1400 break;
1401
1402 handled = 1;
1403
1404 PRINTK3((KERN_WARNING CARDNAME
1405 ": Handling interrupt status %x\n", status));
1406
1407 if (status & IM_RCV_INT) {
1408 /* Got a packet(s). */
1409 PRINTK2((KERN_WARNING CARDNAME
1410 ": Receive Interrupt\n"));
1411 smc_rcv(dev);
1412 } else if (status & IM_TX_INT ) {
1413 PRINTK2((KERN_WARNING CARDNAME
1414 ": TX ERROR handled\n"));
1415 smc_tx(dev);
1416 outb(IM_TX_INT, ioaddr + INTERRUPT );
1417 } else if (status & IM_TX_EMPTY_INT ) {
1418 /* update stats */
1419 SMC_SELECT_BANK( 0 );
1420 card_stats = inw( ioaddr + COUNTER );
1421 /* single collisions */
1422 dev->stats.collisions += card_stats & 0xF;
1423 card_stats >>= 4;
1424 /* multiple collisions */
1425 dev->stats.collisions += card_stats & 0xF;
1426
1427 /* these are for when linux supports these statistics */
1428
1429 SMC_SELECT_BANK( 2 );
1430 PRINTK2((KERN_WARNING CARDNAME
1431 ": TX_BUFFER_EMPTY handled\n"));
1432 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1433 mask &= ~IM_TX_EMPTY_INT;
1434 dev->stats.tx_packets += lp->packets_waiting;
1435 lp->packets_waiting = 0;
1436
1437 } else if (status & IM_ALLOC_INT ) {
1438 PRINTK2((KERN_DEBUG CARDNAME
1439 ": Allocation interrupt\n"));
1440 /* clear this interrupt so it doesn't happen again */
1441 mask &= ~IM_ALLOC_INT;
1442
1443 smc_hardware_send_packet( dev );
1444
1445 /* enable xmit interrupts based on this */
1446 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1447
1448 /* and let the card send more packets to me */
1449 netif_wake_queue(dev);
1450
1451 PRINTK2((CARDNAME": Handoff done successfully.\n"));
1452 } else if (status & IM_RX_OVRN_INT ) {
1453 dev->stats.rx_errors++;
1454 dev->stats.rx_fifo_errors++;
1455 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1456 } else if (status & IM_EPH_INT ) {
1457 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));
1458 } else if (status & IM_ERCV_INT ) {
1459 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));
1460 outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1461 }
1462 } while ( timeout -- );
1463
1464
1465 /* restore state register */
1466 SMC_SELECT_BANK( 2 );
1467 outb( mask, ioaddr + INT_MASK );
1468
1469 PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));
1470 outw( saved_pointer, ioaddr + POINTER );
1471
1472 SMC_SELECT_BANK( saved_bank );
1473
1474 PRINTK3((CARDNAME ": Interrupt done\n"));
1475 return IRQ_RETVAL(handled);
1476 }
1477
1478
1479 /*----------------------------------------------------
1480 . smc_close
1481 .
1482 . this makes the board clean up everything that it can
1483 . and not talk to the outside world. Caused by
1484 . an 'ifconfig ethX down'
1485 .
1486 -----------------------------------------------------*/
smc_close(struct net_device * dev)1487 static int smc_close(struct net_device *dev)
1488 {
1489 netif_stop_queue(dev);
1490 /* clear everything */
1491 smc_shutdown( dev->base_addr );
1492
1493 /* Update the statistics here. */
1494 return 0;
1495 }
1496
1497 /*-----------------------------------------------------------
1498 . smc_set_multicast_list
1499 .
1500 . This routine will, depending on the values passed to it,
1501 . either make it accept multicast packets, go into
1502 . promiscuous mode ( for TCPDUMP and cousins ) or accept
1503 . a select set of multicast packets
1504 */
smc_set_multicast_list(struct net_device * dev)1505 static void smc_set_multicast_list(struct net_device *dev)
1506 {
1507 short ioaddr = dev->base_addr;
1508
1509 SMC_SELECT_BANK(0);
1510 if ( dev->flags & IFF_PROMISC )
1511 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1512
1513 /* BUG? I never disable promiscuous mode if multicasting was turned on.
1514 Now, I turn off promiscuous mode, but I don't do anything to multicasting
1515 when promiscuous mode is turned on.
1516 */
1517
1518 /* Here, I am setting this to accept all multicast packets.
1519 I don't need to zero the multicast table, because the flag is
1520 checked before the table is
1521 */
1522 else if (dev->flags & IFF_ALLMULTI)
1523 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1524
1525 /* We just get all multicast packets even if we only want them
1526 . from one source. This will be changed at some future
1527 . point. */
1528 else if (!netdev_mc_empty(dev)) {
1529 /* support hardware multicasting */
1530
1531 /* be sure I get rid of flags I might have set */
1532 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1533 ioaddr + RCR );
1534 /* NOTE: this has to set the bank, so make sure it is the
1535 last thing called. The bank is set to zero at the top */
1536 smc_setmulticast(ioaddr, dev);
1537 }
1538 else {
1539 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1540 ioaddr + RCR );
1541
1542 /*
1543 since I'm disabling all multicast entirely, I need to
1544 clear the multicast list
1545 */
1546 SMC_SELECT_BANK( 3 );
1547 outw( 0, ioaddr + MULTICAST1 );
1548 outw( 0, ioaddr + MULTICAST2 );
1549 outw( 0, ioaddr + MULTICAST3 );
1550 outw( 0, ioaddr + MULTICAST4 );
1551 }
1552 }
1553
1554 #ifdef MODULE
1555
1556 static struct net_device *devSMC9194;
1557 MODULE_LICENSE("GPL");
1558
1559 module_param(io, int, 0);
1560 module_param(irq, int, 0);
1561 module_param(ifport, int, 0);
1562 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1563 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1564 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1565
init_module(void)1566 int __init init_module(void)
1567 {
1568 if (io == 0)
1569 printk(KERN_WARNING
1570 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1571
1572 /* copy the parameters from insmod into the device structure */
1573 devSMC9194 = smc_init(-1);
1574 if (IS_ERR(devSMC9194))
1575 return PTR_ERR(devSMC9194);
1576 return 0;
1577 }
1578
cleanup_module(void)1579 void __exit cleanup_module(void)
1580 {
1581 unregister_netdev(devSMC9194);
1582 free_irq(devSMC9194->irq, devSMC9194);
1583 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1584 free_netdev(devSMC9194);
1585 }
1586
1587 #endif /* MODULE */
1588