1 /*------------------------------------------------------------------------
3 . This is a driver for SMC's 9000 series of Ethernet cards.
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.
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 )
15 . io = for the base address
17 . ifport = 0 for autodetect, 1 for TP, 2 for AUI ( or 10base2 )
20 . Erik Stahlman ( erik@vt.edu )
22 . Arnaldo Carvalho de Melo <acme@conectiva.com.br>
24 . Hardware multicast code from Peter Cammaert ( pc@denkart.be )
28 . o skeleton.c by Donald Becker ( becker@scyld.com )
29 . o ( a LOT of advice from Becker as well )
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
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 ----------------------------------------------------------------------------*/
57 static const char version[] =
58 "smc9194.c:v0.14 12/15/00 by Erik Stahlman (erik@vt.edu)\n";
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>
67 #include <linux/slab.h>
68 #include <linux/string.h>
69 #include <linux/init.h>
70 #include <linux/crc32.h>
71 #include <linux/errno.h>
72 #include <linux/netdevice.h>
73 #include <linux/etherdevice.h>
74 #include <linux/skbuff.h>
75 #include <linux/bitops.h>
81 #define DRV_NAME "smc9194"
83 /*------------------------------------------------------------------------
85 . Configuration options, for the experienced user to change.
87 -------------------------------------------------------------------------*/
90 . Do you want to use 32 bit xfers? This should work on all chips, as
91 . the chipset is designed to accommodate them.
99 #if defined(__H8300H__) || defined(__H8300S__)
103 #define insl(a,b,l) io_insl_noswap(a,b,l)
104 #define outsl(a,b,l) io_outsl_noswap(a,b,l)
108 .the SMC9194 can be at any of the following port addresses. To change,
109 .for a slightly different card, you can add it to the array. Keep in
110 .mind that the array must end in zero.
118 #if defined(CONFIG_H8S_EDOSK2674)
119 static struct devlist smc_devlist[] __initdata = {
120 {.port = 0xf80000, .irq = 16},
121 {.port = 0, .irq = 0 },
124 static struct devlist smc_devlist[] __initdata = {
125 {.port = 0x200, .irq = 0},
126 {.port = 0x220, .irq = 0},
127 {.port = 0x240, .irq = 0},
128 {.port = 0x260, .irq = 0},
129 {.port = 0x280, .irq = 0},
130 {.port = 0x2A0, .irq = 0},
131 {.port = 0x2C0, .irq = 0},
132 {.port = 0x2E0, .irq = 0},
133 {.port = 0x300, .irq = 0},
134 {.port = 0x320, .irq = 0},
135 {.port = 0x340, .irq = 0},
136 {.port = 0x360, .irq = 0},
137 {.port = 0x380, .irq = 0},
138 {.port = 0x3A0, .irq = 0},
139 {.port = 0x3C0, .irq = 0},
140 {.port = 0x3E0, .irq = 0},
141 {.port = 0, .irq = 0},
145 . Wait time for memory to be free. This probably shouldn't be
146 . tuned that much, as waiting for this means nothing else happens
149 #define MEMORY_WAIT_TIME 16
154 . 0 for normal operation
155 . 1 for slightly more details
156 . >2 for various levels of increasingly useless information
157 . 2 for interrupt tracking, status flags
158 . 3 for packet dumps, etc.
163 #define PRINTK3(x) printk x
169 #define PRINTK2(x) printk x
175 #define PRINTK(x) printk x
181 /*------------------------------------------------------------------------
183 . The internal workings of the driver. If you are changing anything
184 . here with the SMC stuff, you should have the datasheet and known
185 . what you are doing.
187 -------------------------------------------------------------------------*/
188 #define CARDNAME "SMC9194"
191 /* store this information for the driver.. */
194 If I have to wait until memory is available to send
195 a packet, I will store the skbuff here, until I get the
196 desired memory. Then, I'll send it out and free it.
198 struct sk_buff * saved_skb;
201 . This keeps track of how many packets that I have
202 . sent out. When an TX_EMPTY interrupt comes, I know
203 . that all of these have been sent.
209 /*-----------------------------------------------------------------
211 . The driver can be entered at any of the following entry points.
213 .------------------------------------------------------------------ */
216 . This is called by register_netdev(). It is responsible for
217 . checking the portlist for the SMC9000 series chipset. If it finds
218 . one, then it will initialize the device, find the hardware information,
219 . and sets up the appropriate device parameters.
220 . NOTE: Interrupts are *OFF* when this procedure is called.
222 . NB:This shouldn't be static since it is referred to externally.
224 struct net_device *smc_init(int unit);
227 . The kernel calls this function when someone wants to use the device,
228 . typically 'ifconfig ethX up'.
230 static int smc_open(struct net_device *dev);
233 . Our watchdog timed out. Called by the networking layer
235 static void smc_timeout(struct net_device *dev);
238 . This is called by the kernel in response to 'ifconfig ethX down'. It
239 . is responsible for cleaning up everything that the open routine
240 . does, and maybe putting the card into a powerdown state.
242 static int smc_close(struct net_device *dev);
245 . Finally, a call to set promiscuous mode ( for TCPDUMP and related
246 . programs ) and multicast modes.
248 static void smc_set_multicast_list(struct net_device *dev);
251 /*---------------------------------------------------------------
253 . Interrupt level calls..
255 ----------------------------------------------------------------*/
258 . Handles the actual interrupt
260 static irqreturn_t smc_interrupt(int irq, void *);
262 . This is a separate procedure to handle the receipt of a packet, to
263 . leave the interrupt code looking slightly cleaner
265 static inline void smc_rcv( struct net_device *dev );
267 . This handles a TX interrupt, which is only called when an error
268 . relating to a packet is sent.
270 static inline void smc_tx( struct net_device * dev );
273 ------------------------------------------------------------
277 ------------------------------------------------------------
281 . Test if a given location contains a chip, trying to cause as
282 . little damage as possible if it's not a SMC chip.
284 static int smc_probe(struct net_device *dev, int ioaddr);
287 . A rather simple routine to print out a packet for debugging purposes.
290 static void print_packet( byte *, int );
293 #define tx_done(dev) 1
295 /* this is called to actually send the packet to the chip */
296 static void smc_hardware_send_packet( struct net_device * dev );
298 /* Since I am not sure if I will have enough room in the chip's ram
299 . to store the packet, I call this routine, which either sends it
300 . now, or generates an interrupt when the card is ready for the
302 static netdev_tx_t smc_wait_to_send_packet( struct sk_buff * skb,
303 struct net_device *dev );
305 /* this does a soft reset on the device */
306 static void smc_reset( int ioaddr );
308 /* Enable Interrupts, Receive, and Transmit */
309 static void smc_enable( int ioaddr );
311 /* this puts the device in an inactive state */
312 static void smc_shutdown( int ioaddr );
314 /* This routine will find the IRQ of the driver if one is not
315 . specified in the input to the device. */
316 static int smc_findirq( int ioaddr );
319 . Function: smc_reset( int ioaddr )
321 . This sets the SMC91xx chip to its normal state, hopefully from whatever
322 . mess that any other DOS driver has put it in.
324 . Maybe I should reset more registers to defaults in here? SOFTRESET should
328 . 1. send a SOFT RESET
329 . 2. wait for it to finish
330 . 3. enable autorelease mode
331 . 4. reset the memory management unit
332 . 5. clear all interrupts
335 static void smc_reset( int ioaddr )
337 /* This resets the registers mostly to defaults, but doesn't
338 affect EEPROM. That seems unnecessary */
339 SMC_SELECT_BANK( 0 );
340 outw( RCR_SOFTRESET, ioaddr + RCR );
342 /* this should pause enough for the chip to be happy */
345 /* Set the transmit and receive configuration registers to
347 outw( RCR_CLEAR, ioaddr + RCR );
348 outw( TCR_CLEAR, ioaddr + TCR );
350 /* set the control register to automatically
351 release successfully transmitted packets, to make the best
352 use out of our limited memory */
353 SMC_SELECT_BANK( 1 );
354 outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );
357 SMC_SELECT_BANK( 2 );
358 outw( MC_RESET, ioaddr + MMU_CMD );
360 /* Note: It doesn't seem that waiting for the MMU busy is needed here,
361 but this is a place where future chipsets _COULD_ break. Be wary
362 of issuing another MMU command right after this */
364 outb( 0, ioaddr + INT_MASK );
368 . Function: smc_enable
369 . Purpose: let the chip talk to the outside work
371 . 1. Enable the transmitter
372 . 2. Enable the receiver
373 . 3. Enable interrupts
375 static void smc_enable( int ioaddr )
377 SMC_SELECT_BANK( 0 );
378 /* see the header file for options in TCR/RCR NORMAL*/
379 outw( TCR_NORMAL, ioaddr + TCR );
380 outw( RCR_NORMAL, ioaddr + RCR );
382 /* now, enable interrupts */
383 SMC_SELECT_BANK( 2 );
384 outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
388 . Function: smc_shutdown
389 . Purpose: closes down the SMC91xxx chip.
391 . 1. zero the interrupt mask
392 . 2. clear the enable receive flag
393 . 3. clear the enable xmit flags
396 . (1) maybe utilize power down mode.
397 . Why not yet? Because while the chip will go into power down mode,
398 . the manual says that it will wake up in response to any I/O requests
399 . in the register space. Empirical results do not show this working.
401 static void smc_shutdown( int ioaddr )
403 /* no more interrupts for me */
404 SMC_SELECT_BANK( 2 );
405 outb( 0, ioaddr + INT_MASK );
407 /* and tell the card to stay away from that nasty outside world */
408 SMC_SELECT_BANK( 0 );
409 outb( RCR_CLEAR, ioaddr + RCR );
410 outb( TCR_CLEAR, ioaddr + TCR );
412 /* finally, shut the chip down */
413 SMC_SELECT_BANK( 1 );
414 outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL );
420 . Function: smc_setmulticast( int ioaddr, struct net_device *dev )
422 . This sets the internal hardware table to filter out unwanted multicast
423 . packets before they take up memory.
425 . The SMC chip uses a hash table where the high 6 bits of the CRC of
426 . address are the offset into the table. If that bit is 1, then the
427 . multicast packet is accepted. Otherwise, it's dropped silently.
429 . To use the 6 bits as an offset into the table, the high 3 bits are the
430 . number of the 8 bit register, while the low 3 bits are the bit within
433 . This routine is based very heavily on the one provided by Peter Cammaert.
437 static void smc_setmulticast(int ioaddr, struct net_device *dev)
440 unsigned char multicast_table[ 8 ];
441 struct netdev_hw_addr *ha;
442 /* table for flipping the order of 3 bits */
443 unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
445 /* start with a table of all zeros: reject all */
446 memset( multicast_table, 0, sizeof( multicast_table ) );
448 netdev_for_each_mc_addr(ha, dev) {
451 /* make sure this is a multicast address - shouldn't this
452 be a given if we have it here ? */
453 if (!(*ha->addr & 1))
456 /* only use the low order bits */
457 position = ether_crc_le(6, ha->addr) & 0x3f;
459 /* do some messy swapping to put the bit in the right spot */
460 multicast_table[invert3[position&7]] |=
461 (1<<invert3[(position>>3)&7]);
464 /* now, the table can be loaded into the chipset */
465 SMC_SELECT_BANK( 3 );
467 for ( i = 0; i < 8 ; i++ ) {
468 outb( multicast_table[i], ioaddr + MULTICAST1 + i );
473 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
475 . Attempt to allocate memory for a packet, if chip-memory is not
476 . available, then tell the card to generate an interrupt when it
481 . o if the saved_skb is not currently null, then drop this packet
482 . on the floor. This should never happen, because of TBUSY.
483 . o if the saved_skb is null, then replace it with the current packet,
484 . o See if I can sending it now.
485 . o (NO): Enable interrupts and let the interrupt handler deal with it.
486 . o (YES):Send it now.
488 static netdev_tx_t smc_wait_to_send_packet(struct sk_buff *skb,
489 struct net_device *dev)
491 struct smc_local *lp = netdev_priv(dev);
492 unsigned int ioaddr = dev->base_addr;
494 unsigned short numPages;
497 netif_stop_queue(dev);
498 /* Well, I want to send the packet.. but I don't know
499 if I can send it right now... */
501 if ( lp->saved_skb) {
502 /* THIS SHOULD NEVER HAPPEN. */
503 dev->stats.tx_aborted_errors++;
504 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
505 return NETDEV_TX_BUSY;
511 if (length < ETH_ZLEN) {
512 if (skb_padto(skb, ETH_ZLEN)) {
513 netif_wake_queue(dev);
520 ** The MMU wants the number of pages to be the number of 256 bytes
521 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
523 ** Pkt size for allocating is data length +6 (for additional status words,
524 ** length and ctl!) If odd size last byte is included in this header.
526 numPages = ((length & 0xfffe) + 6) / 256;
529 printk(CARDNAME": Far too big packet error.\n");
530 /* freeing the packet is a good thing here... but should
531 . any packets of this size get down here? */
533 lp->saved_skb = NULL;
534 /* this IS an error, but, i don't want the skb saved */
535 netif_wake_queue(dev);
538 /* either way, a packet is waiting now */
539 lp->packets_waiting++;
541 /* now, try to allocate the memory */
542 SMC_SELECT_BANK( 2 );
543 outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
547 . wait a short amount of time.. if I can send a packet now, I send
548 . it now. Otherwise, I enable an interrupt and wait for one to be
551 . I could have handled this a slightly different way, by checking to
552 . see if any memory was available in the FREE MEMORY register. However,
553 . either way, I need to generate an allocation, and the allocation works
554 . no matter what, so I saw no point in checking free memory.
556 time_out = MEMORY_WAIT_TIME;
560 status = inb( ioaddr + INTERRUPT );
561 if ( status & IM_ALLOC_INT ) {
562 /* acknowledge the interrupt */
563 outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
566 } while ( -- time_out );
569 /* oh well, wait until the chip finds memory later */
570 SMC_ENABLE_INT( IM_ALLOC_INT );
571 PRINTK2((CARDNAME": memory allocation deferred.\n"));
572 /* it's deferred, but I'll handle it later */
575 /* or YES! I can send the packet now.. */
576 smc_hardware_send_packet(dev);
577 netif_wake_queue(dev);
582 . Function: smc_hardware_send_packet(struct net_device * )
584 . This sends the actual packet to the SMC9xxx chip.
587 . First, see if a saved_skb is available.
588 . ( this should NOT be called if there is no 'saved_skb'
589 . Now, find the packet number that the chip allocated
590 . Point the data pointers at it in memory
591 . Set the length word in the chip's memory
592 . Dump the packet to chip memory
593 . Check if a last byte is needed ( odd length packet )
594 . if so, set the control flag right
595 . Tell the card to send it
596 . Enable the transmit interrupt, so I know if it failed
597 . Free the kernel data if I actually sent it.
599 static void smc_hardware_send_packet( struct net_device * dev )
601 struct smc_local *lp = netdev_priv(dev);
603 struct sk_buff * skb = lp->saved_skb;
608 ioaddr = dev->base_addr;
611 PRINTK((CARDNAME": In XMIT with no packet to send\n"));
614 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
617 /* If I get here, I _know_ there is a packet slot waiting for me */
618 packet_no = inb( ioaddr + PNR_ARR + 1 );
619 if ( packet_no & 0x80 ) {
620 /* or isn't there? BAD CHIP! */
621 printk(KERN_DEBUG CARDNAME": Memory allocation failed.\n");
622 dev_kfree_skb_any(skb);
623 lp->saved_skb = NULL;
624 netif_wake_queue(dev);
628 /* we have a packet address, so tell the card to use it */
629 outb( packet_no, ioaddr + PNR_ARR );
631 /* point to the beginning of the packet */
632 outw( PTR_AUTOINC , ioaddr + POINTER );
634 PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
636 print_packet( buf, length );
639 /* send the packet length ( +6 for status, length and ctl byte )
640 and the status word ( set to zeros ) */
642 outl( (length +6 ) << 16 , ioaddr + DATA_1 );
644 outw( 0, ioaddr + DATA_1 );
645 /* send the packet length ( +6 for status words, length, and ctl*/
646 outb( (length+6) & 0xFF,ioaddr + DATA_1 );
647 outb( (length+6) >> 8 , ioaddr + DATA_1 );
650 /* send the actual data
651 . I _think_ it's faster to send the longs first, and then
652 . mop up by sending the last word. It depends heavily
653 . on alignment, at least on the 486. Maybe it would be
654 . a good idea to check which is optimal? But that could take
655 . almost as much time as is saved?
658 if ( length & 0x2 ) {
659 outsl(ioaddr + DATA_1, buf, length >> 2 );
660 #if !defined(__H8300H__) && !defined(__H8300S__)
661 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
663 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
667 outsl(ioaddr + DATA_1, buf, length >> 2 );
669 outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
671 /* Send the last byte, if there is one. */
673 if ( (length & 1) == 0 ) {
674 outw( 0, ioaddr + DATA_1 );
676 outb( buf[length -1 ], ioaddr + DATA_1 );
677 outb( 0x20, ioaddr + DATA_1);
680 /* enable the interrupts */
681 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
683 /* and let the chipset deal with it */
684 outw( MC_ENQUEUE , ioaddr + MMU_CMD );
686 PRINTK2((CARDNAME": Sent packet of length %d\n", length));
688 lp->saved_skb = NULL;
689 dev_kfree_skb_any (skb);
691 dev->trans_start = jiffies;
693 /* we can send another packet */
694 netif_wake_queue(dev);
699 /*-------------------------------------------------------------------------
703 | dev->base_addr == 0, try to find all possible locations
704 | dev->base_addr == 1, return failure code
705 | dev->base_addr == 2, always allocate space, and return success
706 | dev->base_addr == <anything else> this is the address to check
709 | pointer to net_device or ERR_PTR(error)
711 ---------------------------------------------------------------------------
717 struct net_device * __init smc_init(int unit)
719 struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
720 struct devlist *smcdev = smc_devlist;
724 return ERR_PTR(-ENODEV);
727 sprintf(dev->name, "eth%d", unit);
728 netdev_boot_setup_check(dev);
733 if (io > 0x1ff) { /* Check a single specified location. */
734 err = smc_probe(dev, io);
735 } else if (io != 0) { /* Don't probe at all. */
738 for (;smcdev->port; smcdev++) {
739 if (smc_probe(dev, smcdev->port) == 0)
747 err = register_netdev(dev);
752 free_irq(dev->irq, dev);
753 release_region(dev->base_addr, SMC_IO_EXTENT);
759 /*----------------------------------------------------------------------
762 . This routine has a simple purpose -- make the SMC chip generate an
763 . interrupt, so an auto-detect routine can detect it, and find the IRQ,
764 ------------------------------------------------------------------------
766 static int __init smc_findirq(int ioaddr)
770 unsigned long cookie;
773 cookie = probe_irq_on();
776 * What I try to do here is trigger an ALLOC_INT. This is done
777 * by allocating a small chunk of memory, which will give an interrupt
783 /* enable ALLOCation interrupts ONLY */
784 outb( IM_ALLOC_INT, ioaddr + INT_MASK );
787 . Allocate 512 bytes of memory. Note that the chip was just
788 . reset so all the memory is available
790 outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
793 . Wait until positive that the interrupt has been generated
798 int_status = inb( ioaddr + INTERRUPT );
800 if ( int_status & IM_ALLOC_INT )
801 break; /* got the interrupt */
804 /* there is really nothing that I can do here if timeout fails,
805 as probe_irq_off will return a 0 anyway, which is what I
806 want in this case. Plus, the clean up is needed in both
810 On a fast machine, the status might change before the interrupt
811 is given to the processor. This means that the interrupt was
812 never detected, and probe_irq_off fails to report anything.
813 This should fix probe_irq_* problems.
818 /* and disable all interrupts again */
819 outb( 0, ioaddr + INT_MASK );
821 /* and return what I found */
822 return probe_irq_off(cookie);
823 #else /* NO_AUTOPROBE */
824 struct devlist *smcdev;
825 for (smcdev = smc_devlist; smcdev->port; smcdev++) {
826 if (smcdev->port == ioaddr)
833 static const struct net_device_ops smc_netdev_ops = {
834 .ndo_open = smc_open,
835 .ndo_stop = smc_close,
836 .ndo_start_xmit = smc_wait_to_send_packet,
837 .ndo_tx_timeout = smc_timeout,
838 .ndo_set_multicast_list = smc_set_multicast_list,
839 .ndo_change_mtu = eth_change_mtu,
840 .ndo_set_mac_address = eth_mac_addr,
841 .ndo_validate_addr = eth_validate_addr,
844 /*----------------------------------------------------------------------
845 . Function: smc_probe( int ioaddr )
848 . Tests to see if a given ioaddr points to an SMC9xxx chip.
849 . Returns a 0 on success
852 . (1) see if the high byte of BANK_SELECT is 0x33
853 . (2) compare the ioaddr with the base register's address
854 . (3) see if I recognize the chip ID in the appropriate register
856 .---------------------------------------------------------------------
859 /*---------------------------------------------------------------
860 . Here I do typical initialization tasks.
862 . o Initialize the structure if needed
863 . o print out my vanity message if not done so already
864 . o print out what type of hardware is detected
865 . o print out the ethernet address
867 . o set up my private data
868 . o configure the dev structure with my subroutines
869 . o actually GRAB the irq.
871 .-----------------------------------------------------------------
873 static int __init smc_probe(struct net_device *dev, int ioaddr)
875 int i, memory, retval;
876 static unsigned version_printed;
879 const char *version_string;
880 const char *if_string;
883 word revision_register;
884 word base_address_register;
885 word configuration_register;
886 word memory_info_register;
887 word memory_cfg_register;
889 /* Grab the region so that no one else tries to probe our ioports. */
890 if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
894 dev->if_port = ifport;
896 /* First, see if the high byte is 0x33 */
897 bank = inw( ioaddr + BANK_SELECT );
898 if ( (bank & 0xFF00) != 0x3300 ) {
902 /* The above MIGHT indicate a device, but I need to write to further
904 outw( 0x0, ioaddr + BANK_SELECT );
905 bank = inw( ioaddr + BANK_SELECT );
906 if ( (bank & 0xFF00 ) != 0x3300 ) {
910 #if !defined(CONFIG_H8S_EDOSK2674)
911 /* well, we've already written once, so hopefully another time won't
912 hurt. This time, I need to switch the bank register to bank 1,
913 so I can access the base address register */
915 base_address_register = inw( ioaddr + BASE );
916 if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {
917 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "
918 "Probably not a SMC chip\n",
919 ioaddr, base_address_register >> 3 & 0x3E0 );
920 /* well, the base address register didn't match. Must not have
921 been a SMC chip after all. */
926 (void)base_address_register; /* Warning suppression */
930 /* check if the revision register is something that I recognize.
931 These might need to be added to later, as future revisions
934 revision_register = inw( ioaddr + REVISION );
935 if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {
936 /* I don't recognize this chip, so... */
937 printk(CARDNAME ": IO %x: Unrecognized revision register:"
938 " %x, Contact author.\n", ioaddr, revision_register);
944 /* at this point I'll assume that the chip is an SMC9xxx.
945 It might be prudent to check a listing of MAC addresses
946 against the hardware address, or do some other tests. */
948 if (version_printed++ == 0)
949 printk("%s", version);
951 /* fill in some of the fields */
952 dev->base_addr = ioaddr;
955 . Get the MAC address ( bank 1, regs 4 - 9 )
957 SMC_SELECT_BANK( 1 );
958 for ( i = 0; i < 6; i += 2 ) {
961 address = inw( ioaddr + ADDR0 + i );
962 dev->dev_addr[ i + 1] = address >> 8;
963 dev->dev_addr[ i ] = address & 0xFF;
966 /* get the memory information */
968 SMC_SELECT_BANK( 0 );
969 memory_info_register = inw( ioaddr + MIR );
970 memory_cfg_register = inw( ioaddr + MCR );
971 memory = ( memory_cfg_register >> 9 ) & 0x7; /* multiplier */
972 memory *= 256 * ( memory_info_register & 0xFF );
975 Now, I want to find out more about the chip. This is sort of
976 redundant, but it's cleaner to have it in both, rather than having
977 one VERY long probe procedure.
980 revision_register = inw( ioaddr + REVISION );
981 version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];
982 if ( !version_string ) {
983 /* I shouldn't get here because this call was done before.... */
988 /* is it using AUI or 10BaseT ? */
989 if ( dev->if_port == 0 ) {
991 configuration_register = inw( ioaddr + CONFIG );
992 if ( configuration_register & CFG_AUI_SELECT )
997 if_string = interfaces[ dev->if_port - 1 ];
999 /* now, reset the chip, and put it into a known state */
1000 smc_reset( ioaddr );
1003 . If dev->irq is 0, then the device has to be banged on to see
1006 . This banging doesn't always detect the IRQ, for unknown reasons.
1007 . a workaround is to reset the chip and try again.
1009 . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
1010 . be what is requested on the command line. I don't do that, mostly
1011 . because the card that I have uses a non-standard method of accessing
1012 . the IRQs, and because this _should_ work in most configurations.
1014 . Specifying an IRQ is done with the assumption that the user knows
1015 . what (s)he is doing. No checking is done!!!!
1018 if ( dev->irq < 2 ) {
1022 while ( trials-- ) {
1023 dev->irq = smc_findirq( ioaddr );
1026 /* kick the card and try again */
1027 smc_reset( ioaddr );
1030 if (dev->irq == 0 ) {
1031 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1036 /* now, print out the card info, in a short format.. */
1038 printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1039 version_string, revision_register & 0xF, ioaddr, dev->irq,
1040 if_string, memory );
1042 . Print the Ethernet address
1044 printk("ADDR: %pM\n", dev->dev_addr);
1046 /* set the private data to zero by default */
1047 memset(netdev_priv(dev), 0, sizeof(struct smc_local));
1050 retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);
1052 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1057 dev->netdev_ops = &smc_netdev_ops;
1058 dev->watchdog_timeo = HZ/20;
1063 release_region(ioaddr, SMC_IO_EXTENT);
1068 static void print_packet( byte * buf, int length )
1075 printk("Packet of length %d\n", length);
1076 lines = length / 16;
1077 remainder = length % 16;
1079 for ( i = 0; i < lines ; i ++ ) {
1082 for ( cur = 0; cur < 8; cur ++ ) {
1087 printk("%02x%02x ", a, b );
1091 for ( i = 0; i < remainder/2 ; i++ ) {
1096 printk("%02x%02x ", a, b );
1105 * Open and Initialize the board
1107 * Set up everything, reset the card, etc ..
1110 static int smc_open(struct net_device *dev)
1112 int ioaddr = dev->base_addr;
1114 int i; /* used to set hw ethernet address */
1116 /* clear out all the junk that was put here before... */
1117 memset(netdev_priv(dev), 0, sizeof(struct smc_local));
1119 /* reset the hardware */
1121 smc_reset( ioaddr );
1122 smc_enable( ioaddr );
1124 /* Select which interface to use */
1126 SMC_SELECT_BANK( 1 );
1127 if ( dev->if_port == 1 ) {
1128 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1131 else if ( dev->if_port == 2 ) {
1132 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1137 According to Becker, I have to set the hardware address
1138 at this point, because the (l)user can set it with an
1139 ioctl. Easily done...
1141 SMC_SELECT_BANK( 1 );
1142 for ( i = 0; i < 6; i += 2 ) {
1145 address = dev->dev_addr[ i + 1 ] << 8 ;
1146 address |= dev->dev_addr[ i ];
1147 outw( address, ioaddr + ADDR0 + i );
1150 netif_start_queue(dev);
1154 /*--------------------------------------------------------
1155 . Called by the kernel to send a packet out into the void
1156 . of the net. This routine is largely based on
1157 . skeleton.c, from Becker.
1158 .--------------------------------------------------------
1161 static void smc_timeout(struct net_device *dev)
1163 /* If we get here, some higher level has decided we are broken.
1164 There should really be a "kick me" function call instead. */
1165 printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1166 tx_done(dev) ? "IRQ conflict" :
1167 "network cable problem");
1168 /* "kick" the adaptor */
1169 smc_reset( dev->base_addr );
1170 smc_enable( dev->base_addr );
1171 dev->trans_start = jiffies;
1172 /* clear anything saved */
1173 ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;
1174 netif_wake_queue(dev);
1177 /*-------------------------------------------------------------
1179 . smc_rcv - receive a packet from the card
1181 . There is ( at least ) a packet waiting to be read from
1185 . o If an error, record it
1186 . o otherwise, read in the packet
1187 --------------------------------------------------------------
1189 static void smc_rcv(struct net_device *dev)
1191 int ioaddr = dev->base_addr;
1198 packet_number = inw( ioaddr + FIFO_PORTS );
1200 if ( packet_number & FP_RXEMPTY ) {
1201 /* we got called , but nothing was on the FIFO */
1202 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n"));
1203 /* don't need to restore anything */
1207 /* start reading from the start of the packet */
1208 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1210 /* First two words are status and packet_length */
1211 status = inw( ioaddr + DATA_1 );
1212 packet_length = inw( ioaddr + DATA_1 );
1214 packet_length &= 0x07ff; /* mask off top bits */
1216 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1218 . the packet length contains 3 extra words :
1219 . status, length, and an extra word with an odd byte .
1223 if ( !(status & RS_ERRORS ) ){
1224 /* do stuff to make a new packet */
1225 struct sk_buff * skb;
1228 /* read one extra byte */
1229 if ( status & RS_ODDFRAME )
1232 /* set multicast stats */
1233 if ( status & RS_MULTICAST )
1234 dev->stats.multicast++;
1236 skb = dev_alloc_skb( packet_length + 5);
1238 if ( skb == NULL ) {
1239 printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1240 dev->stats.rx_dropped++;
1245 ! This should work without alignment, but it could be
1249 skb_reserve( skb, 2 ); /* 16 bit alignment */
1251 data = skb_put( skb, packet_length);
1254 /* QUESTION: Like in the TX routine, do I want
1255 to send the DWORDs or the bytes first, or some
1256 mixture. A mixture might improve already slow PIO
1258 PRINTK3((" Reading %d dwords (and %d bytes)\n",
1259 packet_length >> 2, packet_length & 3 ));
1260 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1261 /* read the left over bytes */
1262 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1263 packet_length & 0x3 );
1265 PRINTK3((" Reading %d words and %d byte(s)\n",
1266 (packet_length >> 1 ), packet_length & 1 ));
1267 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1268 if ( packet_length & 1 ) {
1269 data += packet_length & ~1;
1270 *(data++) = inb( ioaddr + DATA_1 );
1274 print_packet( data, packet_length );
1277 skb->protocol = eth_type_trans(skb, dev );
1279 dev->stats.rx_packets++;
1280 dev->stats.rx_bytes += packet_length;
1283 dev->stats.rx_errors++;
1285 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
1286 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1287 dev->stats.rx_length_errors++;
1288 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
1292 /* error or good, tell the card to get rid of this packet */
1293 outw( MC_RELEASE, ioaddr + MMU_CMD );
1297 /*************************************************************************
1300 . Purpose: Handle a transmit error message. This will only be called
1301 . when an error, because of the AUTO_RELEASE mode.
1304 . Save pointer and packet no
1305 . Get the packet no from the top of the queue
1306 . check if it's valid ( if not, is this an error??? )
1307 . read the status word
1309 . ( resend? Not really, since we don't want old packets around )
1310 . Restore saved values
1311 ************************************************************************/
1312 static void smc_tx( struct net_device * dev )
1314 int ioaddr = dev->base_addr;
1315 struct smc_local *lp = netdev_priv(dev);
1323 saved_packet = inb( ioaddr + PNR_ARR );
1324 packet_no = inw( ioaddr + FIFO_PORTS );
1327 /* select this as the packet to read from */
1328 outb( packet_no, ioaddr + PNR_ARR );
1330 /* read the first word from this packet */
1331 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1333 tx_status = inw( ioaddr + DATA_1 );
1334 PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));
1336 dev->stats.tx_errors++;
1337 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1338 if ( tx_status & TS_LATCOL ) {
1339 printk(KERN_DEBUG CARDNAME
1340 ": Late collision occurred on last xmit.\n");
1341 dev->stats.tx_window_errors++;
1344 if ( tx_status & TS_16COL ) { ... }
1347 if ( tx_status & TS_SUCCESS ) {
1348 printk(CARDNAME": Successful packet caused interrupt\n");
1350 /* re-enable transmit */
1351 SMC_SELECT_BANK( 0 );
1352 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1354 /* kill the packet */
1355 SMC_SELECT_BANK( 2 );
1356 outw( MC_FREEPKT, ioaddr + MMU_CMD );
1358 /* one less packet waiting for me */
1359 lp->packets_waiting--;
1361 outb( saved_packet, ioaddr + PNR_ARR );
1365 /*--------------------------------------------------------------------
1367 . This is the main routine of the driver, to handle the device when
1368 . it needs some attention.
1371 . first, save state of the chipset
1372 . branch off into routines to handle each case, and acknowledge
1373 . each to the interrupt register
1374 . and finally restore state.
1376 ---------------------------------------------------------------------*/
1378 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1380 struct net_device *dev = dev_id;
1381 int ioaddr = dev->base_addr;
1382 struct smc_local *lp = netdev_priv(dev);
1388 /* state registers */
1394 PRINTK3((CARDNAME": SMC interrupt started\n"));
1396 saved_bank = inw( ioaddr + BANK_SELECT );
1399 saved_pointer = inw( ioaddr + POINTER );
1401 mask = inb( ioaddr + INT_MASK );
1402 /* clear all interrupts */
1403 outb( 0, ioaddr + INT_MASK );
1406 /* set a timeout value, so I don't stay here forever */
1409 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));
1411 /* read the status flag, and mask it */
1412 status = inb( ioaddr + INTERRUPT ) & mask;
1418 PRINTK3((KERN_WARNING CARDNAME
1419 ": Handling interrupt status %x\n", status));
1421 if (status & IM_RCV_INT) {
1422 /* Got a packet(s). */
1423 PRINTK2((KERN_WARNING CARDNAME
1424 ": Receive Interrupt\n"));
1426 } else if (status & IM_TX_INT ) {
1427 PRINTK2((KERN_WARNING CARDNAME
1428 ": TX ERROR handled\n"));
1430 outb(IM_TX_INT, ioaddr + INTERRUPT );
1431 } else if (status & IM_TX_EMPTY_INT ) {
1433 SMC_SELECT_BANK( 0 );
1434 card_stats = inw( ioaddr + COUNTER );
1435 /* single collisions */
1436 dev->stats.collisions += card_stats & 0xF;
1438 /* multiple collisions */
1439 dev->stats.collisions += card_stats & 0xF;
1441 /* these are for when linux supports these statistics */
1443 SMC_SELECT_BANK( 2 );
1444 PRINTK2((KERN_WARNING CARDNAME
1445 ": TX_BUFFER_EMPTY handled\n"));
1446 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1447 mask &= ~IM_TX_EMPTY_INT;
1448 dev->stats.tx_packets += lp->packets_waiting;
1449 lp->packets_waiting = 0;
1451 } else if (status & IM_ALLOC_INT ) {
1452 PRINTK2((KERN_DEBUG CARDNAME
1453 ": Allocation interrupt\n"));
1454 /* clear this interrupt so it doesn't happen again */
1455 mask &= ~IM_ALLOC_INT;
1457 smc_hardware_send_packet( dev );
1459 /* enable xmit interrupts based on this */
1460 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1462 /* and let the card send more packets to me */
1463 netif_wake_queue(dev);
1465 PRINTK2((CARDNAME": Handoff done successfully.\n"));
1466 } else if (status & IM_RX_OVRN_INT ) {
1467 dev->stats.rx_errors++;
1468 dev->stats.rx_fifo_errors++;
1469 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1470 } else if (status & IM_EPH_INT ) {
1471 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));
1472 } else if (status & IM_ERCV_INT ) {
1473 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));
1474 outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1476 } while ( timeout -- );
1479 /* restore state register */
1480 SMC_SELECT_BANK( 2 );
1481 outb( mask, ioaddr + INT_MASK );
1483 PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));
1484 outw( saved_pointer, ioaddr + POINTER );
1486 SMC_SELECT_BANK( saved_bank );
1488 PRINTK3((CARDNAME ": Interrupt done\n"));
1489 return IRQ_RETVAL(handled);
1493 /*----------------------------------------------------
1496 . this makes the board clean up everything that it can
1497 . and not talk to the outside world. Caused by
1498 . an 'ifconfig ethX down'
1500 -----------------------------------------------------*/
1501 static int smc_close(struct net_device *dev)
1503 netif_stop_queue(dev);
1504 /* clear everything */
1505 smc_shutdown( dev->base_addr );
1507 /* Update the statistics here. */
1511 /*-----------------------------------------------------------
1512 . smc_set_multicast_list
1514 . This routine will, depending on the values passed to it,
1515 . either make it accept multicast packets, go into
1516 . promiscuous mode ( for TCPDUMP and cousins ) or accept
1517 . a select set of multicast packets
1519 static void smc_set_multicast_list(struct net_device *dev)
1521 short ioaddr = dev->base_addr;
1524 if ( dev->flags & IFF_PROMISC )
1525 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1527 /* BUG? I never disable promiscuous mode if multicasting was turned on.
1528 Now, I turn off promiscuous mode, but I don't do anything to multicasting
1529 when promiscuous mode is turned on.
1532 /* Here, I am setting this to accept all multicast packets.
1533 I don't need to zero the multicast table, because the flag is
1534 checked before the table is
1536 else if (dev->flags & IFF_ALLMULTI)
1537 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1539 /* We just get all multicast packets even if we only want them
1540 . from one source. This will be changed at some future
1542 else if (!netdev_mc_empty(dev)) {
1543 /* support hardware multicasting */
1545 /* be sure I get rid of flags I might have set */
1546 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1548 /* NOTE: this has to set the bank, so make sure it is the
1549 last thing called. The bank is set to zero at the top */
1550 smc_setmulticast(ioaddr, dev);
1553 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1557 since I'm disabling all multicast entirely, I need to
1558 clear the multicast list
1560 SMC_SELECT_BANK( 3 );
1561 outw( 0, ioaddr + MULTICAST1 );
1562 outw( 0, ioaddr + MULTICAST2 );
1563 outw( 0, ioaddr + MULTICAST3 );
1564 outw( 0, ioaddr + MULTICAST4 );
1570 static struct net_device *devSMC9194;
1571 MODULE_LICENSE("GPL");
1573 module_param(io, int, 0);
1574 module_param(irq, int, 0);
1575 module_param(ifport, int, 0);
1576 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1577 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1578 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1580 int __init init_module(void)
1584 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1586 /* copy the parameters from insmod into the device structure */
1587 devSMC9194 = smc_init(-1);
1588 if (IS_ERR(devSMC9194))
1589 return PTR_ERR(devSMC9194);
1593 void __exit cleanup_module(void)
1595 unregister_netdev(devSMC9194);
1596 free_irq(devSMC9194->irq, devSMC9194);
1597 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1598 free_netdev(devSMC9194);