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/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>
80 #define DRV_NAME "smc9194"
82 /*------------------------------------------------------------------------
84 . Configuration options, for the experienced user to change.
86 -------------------------------------------------------------------------*/
89 . Do you want to use 32 bit xfers? This should work on all chips, as
90 . the chipset is designed to accommodate them.
98 #if defined(__H8300H__) || defined(__H8300S__)
102 #define insl(a,b,l) io_insl_noswap(a,b,l)
103 #define outsl(a,b,l) io_outsl_noswap(a,b,l)
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.
117 #if defined(CONFIG_H8S_EDOSK2674)
118 static struct devlist smc_devlist[] __initdata = {
119 {.port = 0xf80000, .irq = 16},
120 {.port = 0, .irq = 0 },
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},
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
148 #define MEMORY_WAIT_TIME 16
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.
162 #define PRINTK3(x) printk x
168 #define PRINTK2(x) printk x
174 #define PRINTK(x) printk x
180 /*------------------------------------------------------------------------
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.
186 -------------------------------------------------------------------------*/
187 #define CARDNAME "SMC9194"
190 /* store this information for the driver.. */
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.
197 struct sk_buff * saved_skb;
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.
208 /*-----------------------------------------------------------------
210 . The driver can be entered at any of the following entry points.
212 .------------------------------------------------------------------ */
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.
221 . NB:This shouldn't be static since it is referred to externally.
223 struct net_device *smc_init(int unit);
226 . The kernel calls this function when someone wants to use the device,
227 . typically 'ifconfig ethX up'.
229 static int smc_open(struct net_device *dev);
232 . Our watchdog timed out. Called by the networking layer
234 static void smc_timeout(struct net_device *dev);
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.
241 static int smc_close(struct net_device *dev);
244 . Finally, a call to set promiscuous mode ( for TCPDUMP and related
245 . programs ) and multicast modes.
247 static void smc_set_multicast_list(struct net_device *dev);
250 /*---------------------------------------------------------------
252 . Interrupt level calls..
254 ----------------------------------------------------------------*/
257 . Handles the actual interrupt
259 static irqreturn_t smc_interrupt(int irq, void *);
261 . This is a separate procedure to handle the receipt of a packet, to
262 . leave the interrupt code looking slightly cleaner
264 static inline void smc_rcv( struct net_device *dev );
266 . This handles a TX interrupt, which is only called when an error
267 . relating to a packet is sent.
269 static inline void smc_tx( struct net_device * dev );
272 ------------------------------------------------------------
276 ------------------------------------------------------------
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.
283 static int smc_probe(struct net_device *dev, int ioaddr);
286 . A rather simple routine to print out a packet for debugging purposes.
289 static void print_packet( byte *, int );
292 #define tx_done(dev) 1
294 /* this is called to actually send the packet to the chip */
295 static void smc_hardware_send_packet( struct net_device * dev );
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
301 static netdev_tx_t smc_wait_to_send_packet( struct sk_buff * skb,
302 struct net_device *dev );
304 /* this does a soft reset on the device */
305 static void smc_reset( int ioaddr );
307 /* Enable Interrupts, Receive, and Transmit */
308 static void smc_enable( int ioaddr );
310 /* this puts the device in an inactive state */
311 static void smc_shutdown( int ioaddr );
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 );
318 . Function: smc_reset( int ioaddr )
320 . This sets the SMC91xx chip to its normal state, hopefully from whatever
321 . mess that any other DOS driver has put it in.
323 . Maybe I should reset more registers to defaults in here? SOFTRESET should
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
334 static void smc_reset( int ioaddr )
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 );
341 /* this should pause enough for the chip to be happy */
344 /* Set the transmit and receive configuration registers to
346 outw( RCR_CLEAR, ioaddr + RCR );
347 outw( TCR_CLEAR, ioaddr + TCR );
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 );
356 SMC_SELECT_BANK( 2 );
357 outw( MC_RESET, ioaddr + MMU_CMD );
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 */
363 outb( 0, ioaddr + INT_MASK );
367 . Function: smc_enable
368 . Purpose: let the chip talk to the outside work
370 . 1. Enable the transmitter
371 . 2. Enable the receiver
372 . 3. Enable interrupts
374 static void smc_enable( int ioaddr )
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 );
381 /* now, enable interrupts */
382 SMC_SELECT_BANK( 2 );
383 outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
387 . Function: smc_shutdown
388 . Purpose: closes down the SMC91xxx chip.
390 . 1. zero the interrupt mask
391 . 2. clear the enable receive flag
392 . 3. clear the enable xmit flags
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.
400 static void smc_shutdown( int ioaddr )
402 /* no more interrupts for me */
403 SMC_SELECT_BANK( 2 );
404 outb( 0, ioaddr + INT_MASK );
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 );
411 /* finally, shut the chip down */
412 SMC_SELECT_BANK( 1 );
413 outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL );
419 . Function: smc_setmulticast( int ioaddr, struct net_device *dev )
421 . This sets the internal hardware table to filter out unwanted multicast
422 . packets before they take up memory.
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.
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
432 . This routine is based very heavily on the one provided by Peter Cammaert.
436 static void smc_setmulticast(int ioaddr, struct net_device *dev)
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 };
444 /* start with a table of all zeros: reject all */
445 memset( multicast_table, 0, sizeof( multicast_table ) );
447 netdev_for_each_mc_addr(ha, dev) {
450 /* make sure this is a multicast address - shouldn't this
451 be a given if we have it here ? */
452 if (!(*ha->addr & 1))
455 /* only use the low order bits */
456 position = ether_crc_le(6, ha->addr) & 0x3f;
458 /* do some messy swapping to put the bit in the right spot */
459 multicast_table[invert3[position&7]] |=
460 (1<<invert3[(position>>3)&7]);
463 /* now, the table can be loaded into the chipset */
464 SMC_SELECT_BANK( 3 );
466 for ( i = 0; i < 8 ; i++ ) {
467 outb( multicast_table[i], ioaddr + MULTICAST1 + i );
472 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
474 . Attempt to allocate memory for a packet, if chip-memory is not
475 . available, then tell the card to generate an interrupt when it
480 . o if the saved_skb is not currently null, then drop this packet
481 . on the floor. This should never happen, because of TBUSY.
482 . o if the saved_skb is null, then replace it with the current packet,
483 . o See if I can sending it now.
484 . o (NO): Enable interrupts and let the interrupt handler deal with it.
485 . o (YES):Send it now.
487 static netdev_tx_t smc_wait_to_send_packet(struct sk_buff *skb,
488 struct net_device *dev)
490 struct smc_local *lp = netdev_priv(dev);
491 unsigned int ioaddr = dev->base_addr;
493 unsigned short numPages;
496 netif_stop_queue(dev);
497 /* Well, I want to send the packet.. but I don't know
498 if I can send it right now... */
500 if ( lp->saved_skb) {
501 /* THIS SHOULD NEVER HAPPEN. */
502 dev->stats.tx_aborted_errors++;
503 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
504 return NETDEV_TX_BUSY;
510 if (length < ETH_ZLEN) {
511 if (skb_padto(skb, ETH_ZLEN)) {
512 netif_wake_queue(dev);
519 ** The MMU wants the number of pages to be the number of 256 bytes
520 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
522 ** Pkt size for allocating is data length +6 (for additional status words,
523 ** length and ctl!) If odd size last byte is included in this header.
525 numPages = ((length & 0xfffe) + 6) / 256;
528 printk(CARDNAME": Far too big packet error.\n");
529 /* freeing the packet is a good thing here... but should
530 . any packets of this size get down here? */
532 lp->saved_skb = NULL;
533 /* this IS an error, but, i don't want the skb saved */
534 netif_wake_queue(dev);
537 /* either way, a packet is waiting now */
538 lp->packets_waiting++;
540 /* now, try to allocate the memory */
541 SMC_SELECT_BANK( 2 );
542 outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
546 . wait a short amount of time.. if I can send a packet now, I send
547 . it now. Otherwise, I enable an interrupt and wait for one to be
550 . I could have handled this a slightly different way, by checking to
551 . see if any memory was available in the FREE MEMORY register. However,
552 . either way, I need to generate an allocation, and the allocation works
553 . no matter what, so I saw no point in checking free memory.
555 time_out = MEMORY_WAIT_TIME;
559 status = inb( ioaddr + INTERRUPT );
560 if ( status & IM_ALLOC_INT ) {
561 /* acknowledge the interrupt */
562 outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
565 } while ( -- time_out );
568 /* oh well, wait until the chip finds memory later */
569 SMC_ENABLE_INT( IM_ALLOC_INT );
570 PRINTK2((CARDNAME": memory allocation deferred.\n"));
571 /* it's deferred, but I'll handle it later */
574 /* or YES! I can send the packet now.. */
575 smc_hardware_send_packet(dev);
576 netif_wake_queue(dev);
581 . Function: smc_hardware_send_packet(struct net_device * )
583 . This sends the actual packet to the SMC9xxx chip.
586 . First, see if a saved_skb is available.
587 . ( this should NOT be called if there is no 'saved_skb'
588 . Now, find the packet number that the chip allocated
589 . Point the data pointers at it in memory
590 . Set the length word in the chip's memory
591 . Dump the packet to chip memory
592 . Check if a last byte is needed ( odd length packet )
593 . if so, set the control flag right
594 . Tell the card to send it
595 . Enable the transmit interrupt, so I know if it failed
596 . Free the kernel data if I actually sent it.
598 static void smc_hardware_send_packet( struct net_device * dev )
600 struct smc_local *lp = netdev_priv(dev);
602 struct sk_buff * skb = lp->saved_skb;
607 ioaddr = dev->base_addr;
610 PRINTK((CARDNAME": In XMIT with no packet to send\n"));
613 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
616 /* If I get here, I _know_ there is a packet slot waiting for me */
617 packet_no = inb( ioaddr + PNR_ARR + 1 );
618 if ( packet_no & 0x80 ) {
619 /* or isn't there? BAD CHIP! */
620 printk(KERN_DEBUG CARDNAME": Memory allocation failed.\n");
621 dev_kfree_skb_any(skb);
622 lp->saved_skb = NULL;
623 netif_wake_queue(dev);
627 /* we have a packet address, so tell the card to use it */
628 outb( packet_no, ioaddr + PNR_ARR );
630 /* point to the beginning of the packet */
631 outw( PTR_AUTOINC , ioaddr + POINTER );
633 PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
635 print_packet( buf, length );
638 /* send the packet length ( +6 for status, length and ctl byte )
639 and the status word ( set to zeros ) */
641 outl( (length +6 ) << 16 , ioaddr + DATA_1 );
643 outw( 0, ioaddr + DATA_1 );
644 /* send the packet length ( +6 for status words, length, and ctl*/
645 outb( (length+6) & 0xFF,ioaddr + DATA_1 );
646 outb( (length+6) >> 8 , ioaddr + DATA_1 );
649 /* send the actual data
650 . I _think_ it's faster to send the longs first, and then
651 . mop up by sending the last word. It depends heavily
652 . on alignment, at least on the 486. Maybe it would be
653 . a good idea to check which is optimal? But that could take
654 . almost as much time as is saved?
657 if ( length & 0x2 ) {
658 outsl(ioaddr + DATA_1, buf, length >> 2 );
659 #if !defined(__H8300H__) && !defined(__H8300S__)
660 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
662 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
666 outsl(ioaddr + DATA_1, buf, length >> 2 );
668 outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
670 /* Send the last byte, if there is one. */
672 if ( (length & 1) == 0 ) {
673 outw( 0, ioaddr + DATA_1 );
675 outb( buf[length -1 ], ioaddr + DATA_1 );
676 outb( 0x20, ioaddr + DATA_1);
679 /* enable the interrupts */
680 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
682 /* and let the chipset deal with it */
683 outw( MC_ENQUEUE , ioaddr + MMU_CMD );
685 PRINTK2((CARDNAME": Sent packet of length %d\n", length));
687 lp->saved_skb = NULL;
688 dev_kfree_skb_any (skb);
690 dev->trans_start = jiffies;
692 /* we can send another packet */
693 netif_wake_queue(dev);
698 /*-------------------------------------------------------------------------
702 | dev->base_addr == 0, try to find all possible locations
703 | dev->base_addr == 1, return failure code
704 | dev->base_addr == 2, always allocate space, and return success
705 | dev->base_addr == <anything else> this is the address to check
708 | pointer to net_device or ERR_PTR(error)
710 ---------------------------------------------------------------------------
716 struct net_device * __init smc_init(int unit)
718 struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
719 struct devlist *smcdev = smc_devlist;
723 return ERR_PTR(-ENODEV);
726 sprintf(dev->name, "eth%d", unit);
727 netdev_boot_setup_check(dev);
732 if (io > 0x1ff) { /* Check a single specified location. */
733 err = smc_probe(dev, io);
734 } else if (io != 0) { /* Don't probe at all. */
737 for (;smcdev->port; smcdev++) {
738 if (smc_probe(dev, smcdev->port) == 0)
746 err = register_netdev(dev);
751 free_irq(dev->irq, dev);
752 release_region(dev->base_addr, SMC_IO_EXTENT);
758 /*----------------------------------------------------------------------
761 . This routine has a simple purpose -- make the SMC chip generate an
762 . interrupt, so an auto-detect routine can detect it, and find the IRQ,
763 ------------------------------------------------------------------------
765 static int __init smc_findirq(int ioaddr)
769 unsigned long cookie;
772 cookie = probe_irq_on();
775 * What I try to do here is trigger an ALLOC_INT. This is done
776 * by allocating a small chunk of memory, which will give an interrupt
782 /* enable ALLOCation interrupts ONLY */
783 outb( IM_ALLOC_INT, ioaddr + INT_MASK );
786 . Allocate 512 bytes of memory. Note that the chip was just
787 . reset so all the memory is available
789 outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
792 . Wait until positive that the interrupt has been generated
797 int_status = inb( ioaddr + INTERRUPT );
799 if ( int_status & IM_ALLOC_INT )
800 break; /* got the interrupt */
803 /* there is really nothing that I can do here if timeout fails,
804 as probe_irq_off will return a 0 anyway, which is what I
805 want in this case. Plus, the clean up is needed in both
809 On a fast machine, the status might change before the interrupt
810 is given to the processor. This means that the interrupt was
811 never detected, and probe_irq_off fails to report anything.
812 This should fix probe_irq_* problems.
817 /* and disable all interrupts again */
818 outb( 0, ioaddr + INT_MASK );
820 /* and return what I found */
821 return probe_irq_off(cookie);
822 #else /* NO_AUTOPROBE */
823 struct devlist *smcdev;
824 for (smcdev = smc_devlist; smcdev->port; smcdev++) {
825 if (smcdev->port == ioaddr)
832 static const struct net_device_ops smc_netdev_ops = {
833 .ndo_open = smc_open,
834 .ndo_stop = smc_close,
835 .ndo_start_xmit = smc_wait_to_send_packet,
836 .ndo_tx_timeout = smc_timeout,
837 .ndo_set_multicast_list = smc_set_multicast_list,
838 .ndo_change_mtu = eth_change_mtu,
839 .ndo_set_mac_address = eth_mac_addr,
840 .ndo_validate_addr = eth_validate_addr,
843 /*----------------------------------------------------------------------
844 . Function: smc_probe( int ioaddr )
847 . Tests to see if a given ioaddr points to an SMC9xxx chip.
848 . Returns a 0 on success
851 . (1) see if the high byte of BANK_SELECT is 0x33
852 . (2) compare the ioaddr with the base register's address
853 . (3) see if I recognize the chip ID in the appropriate register
855 .---------------------------------------------------------------------
858 /*---------------------------------------------------------------
859 . Here I do typical initialization tasks.
861 . o Initialize the structure if needed
862 . o print out my vanity message if not done so already
863 . o print out what type of hardware is detected
864 . o print out the ethernet address
866 . o set up my private data
867 . o configure the dev structure with my subroutines
868 . o actually GRAB the irq.
870 .-----------------------------------------------------------------
872 static int __init smc_probe(struct net_device *dev, int ioaddr)
874 int i, memory, retval;
875 static unsigned version_printed;
878 const char *version_string;
879 const char *if_string;
882 word revision_register;
883 word base_address_register;
884 word configuration_register;
885 word memory_info_register;
886 word memory_cfg_register;
888 /* Grab the region so that no one else tries to probe our ioports. */
889 if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
893 dev->if_port = ifport;
895 /* First, see if the high byte is 0x33 */
896 bank = inw( ioaddr + BANK_SELECT );
897 if ( (bank & 0xFF00) != 0x3300 ) {
901 /* The above MIGHT indicate a device, but I need to write to further
903 outw( 0x0, ioaddr + BANK_SELECT );
904 bank = inw( ioaddr + BANK_SELECT );
905 if ( (bank & 0xFF00 ) != 0x3300 ) {
909 #if !defined(CONFIG_H8S_EDOSK2674)
910 /* well, we've already written once, so hopefully another time won't
911 hurt. This time, I need to switch the bank register to bank 1,
912 so I can access the base address register */
914 base_address_register = inw( ioaddr + BASE );
915 if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {
916 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "
917 "Probably not a SMC chip\n",
918 ioaddr, base_address_register >> 3 & 0x3E0 );
919 /* well, the base address register didn't match. Must not have
920 been a SMC chip after all. */
925 (void)base_address_register; /* Warning suppression */
929 /* check if the revision register is something that I recognize.
930 These might need to be added to later, as future revisions
933 revision_register = inw( ioaddr + REVISION );
934 if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {
935 /* I don't recognize this chip, so... */
936 printk(CARDNAME ": IO %x: Unrecognized revision register:"
937 " %x, Contact author.\n", ioaddr, revision_register);
943 /* at this point I'll assume that the chip is an SMC9xxx.
944 It might be prudent to check a listing of MAC addresses
945 against the hardware address, or do some other tests. */
947 if (version_printed++ == 0)
948 printk("%s", version);
950 /* fill in some of the fields */
951 dev->base_addr = ioaddr;
954 . Get the MAC address ( bank 1, regs 4 - 9 )
956 SMC_SELECT_BANK( 1 );
957 for ( i = 0; i < 6; i += 2 ) {
960 address = inw( ioaddr + ADDR0 + i );
961 dev->dev_addr[ i + 1] = address >> 8;
962 dev->dev_addr[ i ] = address & 0xFF;
965 /* get the memory information */
967 SMC_SELECT_BANK( 0 );
968 memory_info_register = inw( ioaddr + MIR );
969 memory_cfg_register = inw( ioaddr + MCR );
970 memory = ( memory_cfg_register >> 9 ) & 0x7; /* multiplier */
971 memory *= 256 * ( memory_info_register & 0xFF );
974 Now, I want to find out more about the chip. This is sort of
975 redundant, but it's cleaner to have it in both, rather than having
976 one VERY long probe procedure.
979 revision_register = inw( ioaddr + REVISION );
980 version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];
981 if ( !version_string ) {
982 /* I shouldn't get here because this call was done before.... */
987 /* is it using AUI or 10BaseT ? */
988 if ( dev->if_port == 0 ) {
990 configuration_register = inw( ioaddr + CONFIG );
991 if ( configuration_register & CFG_AUI_SELECT )
996 if_string = interfaces[ dev->if_port - 1 ];
998 /* now, reset the chip, and put it into a known state */
1002 . If dev->irq is 0, then the device has to be banged on to see
1005 . This banging doesn't always detect the IRQ, for unknown reasons.
1006 . a workaround is to reset the chip and try again.
1008 . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
1009 . be what is requested on the command line. I don't do that, mostly
1010 . because the card that I have uses a non-standard method of accessing
1011 . the IRQs, and because this _should_ work in most configurations.
1013 . Specifying an IRQ is done with the assumption that the user knows
1014 . what (s)he is doing. No checking is done!!!!
1017 if ( dev->irq < 2 ) {
1021 while ( trials-- ) {
1022 dev->irq = smc_findirq( ioaddr );
1025 /* kick the card and try again */
1026 smc_reset( ioaddr );
1029 if (dev->irq == 0 ) {
1030 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1035 /* now, print out the card info, in a short format.. */
1037 printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1038 version_string, revision_register & 0xF, ioaddr, dev->irq,
1039 if_string, memory );
1041 . Print the Ethernet address
1043 printk("ADDR: %pM\n", dev->dev_addr);
1046 retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);
1048 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1053 dev->netdev_ops = &smc_netdev_ops;
1054 dev->watchdog_timeo = HZ/20;
1059 release_region(ioaddr, SMC_IO_EXTENT);
1064 static void print_packet( byte * buf, int length )
1071 printk("Packet of length %d\n", length);
1072 lines = length / 16;
1073 remainder = length % 16;
1075 for ( i = 0; i < lines ; i ++ ) {
1078 for ( cur = 0; cur < 8; cur ++ ) {
1083 printk("%02x%02x ", a, b );
1087 for ( i = 0; i < remainder/2 ; i++ ) {
1092 printk("%02x%02x ", a, b );
1101 * Open and Initialize the board
1103 * Set up everything, reset the card, etc ..
1106 static int smc_open(struct net_device *dev)
1108 int ioaddr = dev->base_addr;
1110 int i; /* used to set hw ethernet address */
1112 /* clear out all the junk that was put here before... */
1113 memset(netdev_priv(dev), 0, sizeof(struct smc_local));
1115 /* reset the hardware */
1117 smc_reset( ioaddr );
1118 smc_enable( ioaddr );
1120 /* Select which interface to use */
1122 SMC_SELECT_BANK( 1 );
1123 if ( dev->if_port == 1 ) {
1124 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1127 else if ( dev->if_port == 2 ) {
1128 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1133 According to Becker, I have to set the hardware address
1134 at this point, because the (l)user can set it with an
1135 ioctl. Easily done...
1137 SMC_SELECT_BANK( 1 );
1138 for ( i = 0; i < 6; i += 2 ) {
1141 address = dev->dev_addr[ i + 1 ] << 8 ;
1142 address |= dev->dev_addr[ i ];
1143 outw( address, ioaddr + ADDR0 + i );
1146 netif_start_queue(dev);
1150 /*--------------------------------------------------------
1151 . Called by the kernel to send a packet out into the void
1152 . of the net. This routine is largely based on
1153 . skeleton.c, from Becker.
1154 .--------------------------------------------------------
1157 static void smc_timeout(struct net_device *dev)
1159 /* If we get here, some higher level has decided we are broken.
1160 There should really be a "kick me" function call instead. */
1161 printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1162 tx_done(dev) ? "IRQ conflict" :
1163 "network cable problem");
1164 /* "kick" the adaptor */
1165 smc_reset( dev->base_addr );
1166 smc_enable( dev->base_addr );
1167 dev->trans_start = jiffies; /* prevent tx timeout */
1168 /* clear anything saved */
1169 ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;
1170 netif_wake_queue(dev);
1173 /*-------------------------------------------------------------
1175 . smc_rcv - receive a packet from the card
1177 . There is ( at least ) a packet waiting to be read from
1181 . o If an error, record it
1182 . o otherwise, read in the packet
1183 --------------------------------------------------------------
1185 static void smc_rcv(struct net_device *dev)
1187 int ioaddr = dev->base_addr;
1194 packet_number = inw( ioaddr + FIFO_PORTS );
1196 if ( packet_number & FP_RXEMPTY ) {
1197 /* we got called , but nothing was on the FIFO */
1198 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n"));
1199 /* don't need to restore anything */
1203 /* start reading from the start of the packet */
1204 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1206 /* First two words are status and packet_length */
1207 status = inw( ioaddr + DATA_1 );
1208 packet_length = inw( ioaddr + DATA_1 );
1210 packet_length &= 0x07ff; /* mask off top bits */
1212 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1214 . the packet length contains 3 extra words :
1215 . status, length, and an extra word with an odd byte .
1219 if ( !(status & RS_ERRORS ) ){
1220 /* do stuff to make a new packet */
1221 struct sk_buff * skb;
1224 /* read one extra byte */
1225 if ( status & RS_ODDFRAME )
1228 /* set multicast stats */
1229 if ( status & RS_MULTICAST )
1230 dev->stats.multicast++;
1232 skb = dev_alloc_skb( packet_length + 5);
1234 if ( skb == NULL ) {
1235 printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1236 dev->stats.rx_dropped++;
1241 ! This should work without alignment, but it could be
1245 skb_reserve( skb, 2 ); /* 16 bit alignment */
1247 data = skb_put( skb, packet_length);
1250 /* QUESTION: Like in the TX routine, do I want
1251 to send the DWORDs or the bytes first, or some
1252 mixture. A mixture might improve already slow PIO
1254 PRINTK3((" Reading %d dwords (and %d bytes)\n",
1255 packet_length >> 2, packet_length & 3 ));
1256 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1257 /* read the left over bytes */
1258 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1259 packet_length & 0x3 );
1261 PRINTK3((" Reading %d words and %d byte(s)\n",
1262 (packet_length >> 1 ), packet_length & 1 ));
1263 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1264 if ( packet_length & 1 ) {
1265 data += packet_length & ~1;
1266 *(data++) = inb( ioaddr + DATA_1 );
1270 print_packet( data, packet_length );
1273 skb->protocol = eth_type_trans(skb, dev );
1275 dev->stats.rx_packets++;
1276 dev->stats.rx_bytes += packet_length;
1279 dev->stats.rx_errors++;
1281 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;
1282 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1283 dev->stats.rx_length_errors++;
1284 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;
1288 /* error or good, tell the card to get rid of this packet */
1289 outw( MC_RELEASE, ioaddr + MMU_CMD );
1293 /*************************************************************************
1296 . Purpose: Handle a transmit error message. This will only be called
1297 . when an error, because of the AUTO_RELEASE mode.
1300 . Save pointer and packet no
1301 . Get the packet no from the top of the queue
1302 . check if it's valid ( if not, is this an error??? )
1303 . read the status word
1305 . ( resend? Not really, since we don't want old packets around )
1306 . Restore saved values
1307 ************************************************************************/
1308 static void smc_tx( struct net_device * dev )
1310 int ioaddr = dev->base_addr;
1311 struct smc_local *lp = netdev_priv(dev);
1319 saved_packet = inb( ioaddr + PNR_ARR );
1320 packet_no = inw( ioaddr + FIFO_PORTS );
1323 /* select this as the packet to read from */
1324 outb( packet_no, ioaddr + PNR_ARR );
1326 /* read the first word from this packet */
1327 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1329 tx_status = inw( ioaddr + DATA_1 );
1330 PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));
1332 dev->stats.tx_errors++;
1333 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1334 if ( tx_status & TS_LATCOL ) {
1335 printk(KERN_DEBUG CARDNAME
1336 ": Late collision occurred on last xmit.\n");
1337 dev->stats.tx_window_errors++;
1340 if ( tx_status & TS_16COL ) { ... }
1343 if ( tx_status & TS_SUCCESS ) {
1344 printk(CARDNAME": Successful packet caused interrupt\n");
1346 /* re-enable transmit */
1347 SMC_SELECT_BANK( 0 );
1348 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1350 /* kill the packet */
1351 SMC_SELECT_BANK( 2 );
1352 outw( MC_FREEPKT, ioaddr + MMU_CMD );
1354 /* one less packet waiting for me */
1355 lp->packets_waiting--;
1357 outb( saved_packet, ioaddr + PNR_ARR );
1361 /*--------------------------------------------------------------------
1363 . This is the main routine of the driver, to handle the device when
1364 . it needs some attention.
1367 . first, save state of the chipset
1368 . branch off into routines to handle each case, and acknowledge
1369 . each to the interrupt register
1370 . and finally restore state.
1372 ---------------------------------------------------------------------*/
1374 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1376 struct net_device *dev = dev_id;
1377 int ioaddr = dev->base_addr;
1378 struct smc_local *lp = netdev_priv(dev);
1384 /* state registers */
1390 PRINTK3((CARDNAME": SMC interrupt started\n"));
1392 saved_bank = inw( ioaddr + BANK_SELECT );
1395 saved_pointer = inw( ioaddr + POINTER );
1397 mask = inb( ioaddr + INT_MASK );
1398 /* clear all interrupts */
1399 outb( 0, ioaddr + INT_MASK );
1402 /* set a timeout value, so I don't stay here forever */
1405 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));
1407 /* read the status flag, and mask it */
1408 status = inb( ioaddr + INTERRUPT ) & mask;
1414 PRINTK3((KERN_WARNING CARDNAME
1415 ": Handling interrupt status %x\n", status));
1417 if (status & IM_RCV_INT) {
1418 /* Got a packet(s). */
1419 PRINTK2((KERN_WARNING CARDNAME
1420 ": Receive Interrupt\n"));
1422 } else if (status & IM_TX_INT ) {
1423 PRINTK2((KERN_WARNING CARDNAME
1424 ": TX ERROR handled\n"));
1426 outb(IM_TX_INT, ioaddr + INTERRUPT );
1427 } else if (status & IM_TX_EMPTY_INT ) {
1429 SMC_SELECT_BANK( 0 );
1430 card_stats = inw( ioaddr + COUNTER );
1431 /* single collisions */
1432 dev->stats.collisions += card_stats & 0xF;
1434 /* multiple collisions */
1435 dev->stats.collisions += card_stats & 0xF;
1437 /* these are for when linux supports these statistics */
1439 SMC_SELECT_BANK( 2 );
1440 PRINTK2((KERN_WARNING CARDNAME
1441 ": TX_BUFFER_EMPTY handled\n"));
1442 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1443 mask &= ~IM_TX_EMPTY_INT;
1444 dev->stats.tx_packets += lp->packets_waiting;
1445 lp->packets_waiting = 0;
1447 } else if (status & IM_ALLOC_INT ) {
1448 PRINTK2((KERN_DEBUG CARDNAME
1449 ": Allocation interrupt\n"));
1450 /* clear this interrupt so it doesn't happen again */
1451 mask &= ~IM_ALLOC_INT;
1453 smc_hardware_send_packet( dev );
1455 /* enable xmit interrupts based on this */
1456 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1458 /* and let the card send more packets to me */
1459 netif_wake_queue(dev);
1461 PRINTK2((CARDNAME": Handoff done successfully.\n"));
1462 } else if (status & IM_RX_OVRN_INT ) {
1463 dev->stats.rx_errors++;
1464 dev->stats.rx_fifo_errors++;
1465 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1466 } else if (status & IM_EPH_INT ) {
1467 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));
1468 } else if (status & IM_ERCV_INT ) {
1469 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));
1470 outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1472 } while ( timeout -- );
1475 /* restore state register */
1476 SMC_SELECT_BANK( 2 );
1477 outb( mask, ioaddr + INT_MASK );
1479 PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));
1480 outw( saved_pointer, ioaddr + POINTER );
1482 SMC_SELECT_BANK( saved_bank );
1484 PRINTK3((CARDNAME ": Interrupt done\n"));
1485 return IRQ_RETVAL(handled);
1489 /*----------------------------------------------------
1492 . this makes the board clean up everything that it can
1493 . and not talk to the outside world. Caused by
1494 . an 'ifconfig ethX down'
1496 -----------------------------------------------------*/
1497 static int smc_close(struct net_device *dev)
1499 netif_stop_queue(dev);
1500 /* clear everything */
1501 smc_shutdown( dev->base_addr );
1503 /* Update the statistics here. */
1507 /*-----------------------------------------------------------
1508 . smc_set_multicast_list
1510 . This routine will, depending on the values passed to it,
1511 . either make it accept multicast packets, go into
1512 . promiscuous mode ( for TCPDUMP and cousins ) or accept
1513 . a select set of multicast packets
1515 static void smc_set_multicast_list(struct net_device *dev)
1517 short ioaddr = dev->base_addr;
1520 if ( dev->flags & IFF_PROMISC )
1521 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1523 /* BUG? I never disable promiscuous mode if multicasting was turned on.
1524 Now, I turn off promiscuous mode, but I don't do anything to multicasting
1525 when promiscuous mode is turned on.
1528 /* Here, I am setting this to accept all multicast packets.
1529 I don't need to zero the multicast table, because the flag is
1530 checked before the table is
1532 else if (dev->flags & IFF_ALLMULTI)
1533 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1535 /* We just get all multicast packets even if we only want them
1536 . from one source. This will be changed at some future
1538 else if (!netdev_mc_empty(dev)) {
1539 /* support hardware multicasting */
1541 /* be sure I get rid of flags I might have set */
1542 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1544 /* NOTE: this has to set the bank, so make sure it is the
1545 last thing called. The bank is set to zero at the top */
1546 smc_setmulticast(ioaddr, dev);
1549 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1553 since I'm disabling all multicast entirely, I need to
1554 clear the multicast list
1556 SMC_SELECT_BANK( 3 );
1557 outw( 0, ioaddr + MULTICAST1 );
1558 outw( 0, ioaddr + MULTICAST2 );
1559 outw( 0, ioaddr + MULTICAST3 );
1560 outw( 0, ioaddr + MULTICAST4 );
1566 static struct net_device *devSMC9194;
1567 MODULE_LICENSE("GPL");
1569 module_param(io, int, 0);
1570 module_param(irq, int, 0);
1571 module_param(ifport, int, 0);
1572 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1573 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1574 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1576 int __init init_module(void)
1580 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1582 /* copy the parameters from insmod into the device structure */
1583 devSMC9194 = smc_init(-1);
1584 if (IS_ERR(devSMC9194))
1585 return PTR_ERR(devSMC9194);
1589 void __exit cleanup_module(void)
1591 unregister_netdev(devSMC9194);
1592 free_irq(devSMC9194->irq, devSMC9194);
1593 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1594 free_netdev(devSMC9194);