开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
smc9194.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：43k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

smc9194.c：源码内容
  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.  ----------------------------------------------------------------------------*/
  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/version.h>
  62. #include <linux/kernel.h>
  63. #include <linux/sched.h>
  64. #include <linux/types.h>
  65. #include <linux/fcntl.h>
  66. #include <linux/interrupt.h>
  67. #include <linux/ptrace.h>
  68. #include <linux/ioport.h>
  69. #include <linux/in.h>
  70. #include <linux/slab.h>
  71. #include <linux/string.h>
  72. #include <linux/init.h>
  73. #include <linux/crc32.h>
  74. #include <asm/bitops.h>
  75. #include <asm/io.h>
  76. #include <linux/errno.h>
  78. #include <linux/netdevice.h>
  79. #include <linux/etherdevice.h>
  80. #include <linux/skbuff.h>
  82. #include "smc9194.h"
  83. /*------------------------------------------------------------------------
  84.  .
  85.  . Configuration options, for the experienced user to change.
  86.  .
  87.  -------------------------------------------------------------------------*/
  89. /*
  90.  . Do you want to use 32 bit xfers?  This should work on all chips, as
  91.  . the chipset is designed to accommodate them.
  92. */
  93. #ifdef __sh__
  94. #undef USE_32_BIT
  95. #else
  96. #define USE_32_BIT 1
  97. #endif
  99. /*
  100.  .the SMC9194 can be at any of the following port addresses.  To change,
  101.  .for a slightly different card, you can add it to the array.  Keep in
  102.  .mind that the array must end in zero.
  103. */
  104. static unsigned int smc_portlist[] __initdata = { 
  105. 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
  106. 0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0, 0
  107. };
  109. /*
  110.  . Wait time for memory to be free.  This probably shouldn't be
  111.  . tuned that much, as waiting for this means nothing else happens
  112.  . in the system
  113. */
  114. #define MEMORY_WAIT_TIME 16
  116. /*
  117.  . DEBUGGING LEVELS
  118.  .
  119.  . 0 for normal operation
  120.  . 1 for slightly more details
  121.  . >2 for various levels of increasingly useless information
  122.  .    2 for interrupt tracking, status flags
  123.  .    3 for packet dumps, etc.
  124. */
  125. #define SMC_DEBUG 0
  127. #if (SMC_DEBUG > 2 )
  128. #define PRINTK3(x) printk x
  129. #else
  130. #define PRINTK3(x)
  131. #endif
  133. #if SMC_DEBUG > 1
  134. #define PRINTK2(x) printk x
  135. #else
  136. #define PRINTK2(x)
  137. #endif
  139. #ifdef SMC_DEBUG
  140. #define PRINTK(x) printk x
  141. #else
  142. #define PRINTK(x)
  143. #endif
  146. /*------------------------------------------------------------------------
  147.  .
  148.  . The internal workings of the driver.  If you are changing anything
  149.  . here with the SMC stuff, you should have the datasheet and known
  150.  . what you are doing.
  151.  .
  152.  -------------------------------------------------------------------------*/
  153. #define CARDNAME "SMC9194"
  156. /* store this information for the driver.. */
  157. struct smc_local {
  158. /*
  159.      these are things that the kernel wants me to keep, so users
  160.    can find out semi-useless statistics of how well the card is
  161.    performing
  162.   */
  163. struct net_device_stats stats;
  165. /*
  166.    If I have to wait until memory is available to send
  167.    a packet, I will store the skbuff here, until I get the
  168.    desired memory.  Then, I'll send it out and free it.
  169. */
  170. struct sk_buff * saved_skb;
  172. /*
  173.    . This keeps track of how many packets that I have
  174.    . sent out.  When an TX_EMPTY interrupt comes, I know
  175.  . that all of these have been sent.
  176. */
  177. int packets_waiting;
  178. };
  181. /*-----------------------------------------------------------------
  182.  .
  183.  .  The driver can be entered at any of the following entry points.
  184.  .
  185.  .------------------------------------------------------------------  */
  187. /*
  188.  . This is called by  register_netdev().  It is responsible for
  189.  . checking the portlist for the SMC9000 series chipset.  If it finds
  190.  . one, then it will initialize the device, find the hardware information,
  191.  . and sets up the appropriate device parameters.
  192.  . NOTE: Interrupts are *OFF* when this procedure is called.
  193.  .
  194.  . NB:This shouldn't be static since it is referred to externally.
  195. */
  196. int smc_init(struct net_device *dev);
  198. /*
  199.  . The kernel calls this function when someone wants to use the device,
  200.  . typically 'ifconfig ethX up'.
  201. */
  202. static int smc_open(struct net_device *dev);
  204. /*
  205.  . Our watchdog timed out. Called by the networking layer
  206. */
  207. static void smc_timeout(struct net_device *dev);
  209. /*
  210.  . This is called by the kernel in response to 'ifconfig ethX down'.  It
  211.  . is responsible for cleaning up everything that the open routine
  212.  . does, and maybe putting the card into a powerdown state.
  213. */
  214. static int smc_close(struct net_device *dev);
  216. /*
  217.  . This routine allows the proc file system to query the driver's
  218.  . statistics.
  219. */
  220. static struct net_device_stats * smc_query_statistics( struct net_device *dev);
  222. /*
  223.  . Finally, a call to set promiscuous mode ( for TCPDUMP and related
  224.  . programs ) and multicast modes.
  225. */
  226. static void smc_set_multicast_list(struct net_device *dev);
  229. /*---------------------------------------------------------------
  230.  .
  231.  . Interrupt level calls..
  232.  .
  233.  ----------------------------------------------------------------*/
  235. /*
  236.  . Handles the actual interrupt
  237. */
  238. static void smc_interrupt(int irq, void *, struct pt_regs *regs);
  239. /*
  240.  . This is a separate procedure to handle the receipt of a packet, to
  241.  . leave the interrupt code looking slightly cleaner
  242. */
  243. static inline void smc_rcv( struct net_device *dev );
  244. /*
  245.  . This handles a TX interrupt, which is only called when an error
  246.  . relating to a packet is sent.
  247. */
  248. static inline void smc_tx( struct net_device * dev );
  250. /*
  251.  ------------------------------------------------------------
  252.  .
  253.  . Internal routines
  254.  .
  255.  ------------------------------------------------------------
  256. */
  258. /*
  259.  . Test if a given location contains a chip, trying to cause as
  260.  . little damage as possible if it's not a SMC chip.
  261. */
  262. static int smc_probe(struct net_device *dev, int ioaddr);
  264. /*
  265.  . A rather simple routine to print out a packet for debugging purposes.
  266. */
  267. #if SMC_DEBUG > 2
  268. static void print_packet( byte *, int );
  269. #endif
  271. #define tx_done(dev) 1
  273. /* this is called to actually send the packet to the chip */
  274. static void smc_hardware_send_packet( struct net_device * dev );
  276. /* Since I am not sure if I will have enough room in the chip's ram
  277.  . to store the packet, I call this routine, which either sends it
  278.  . now, or generates an interrupt when the card is ready for the
  279.  . packet */
  280. static int  smc_wait_to_send_packet( struct sk_buff * skb, struct net_device *dev );
  282. /* this does a soft reset on the device */
  283. static void smc_reset( int ioaddr );
  285. /* Enable Interrupts, Receive, and Transmit */
  286. static void smc_enable( int ioaddr );
  288. /* this puts the device in an inactive state */
  289. static void smc_shutdown( int ioaddr );
  291. /* This routine will find the IRQ of the driver if one is not
  292.  . specified in the input to the device.  */
  293. static int smc_findirq( int ioaddr );
  295. /*
  296.  . Function: smc_reset( int ioaddr )
  297.  . Purpose:
  298.  .   This sets the SMC91xx chip to its normal state, hopefully from whatever
  299.  .  mess that any other DOS driver has put it in.
  300.  .
  301.  . Maybe I should reset more registers to defaults in here?  SOFTRESET  should
  302.  . do that for me.
  303.  .
  304.  . Method:
  305.  . 1.  send a SOFT RESET
  306.  . 2.  wait for it to finish
  307.  . 3.  enable autorelease mode
  308.  . 4.  reset the memory management unit
  309.  . 5.  clear all interrupts
  310.  .
  311. */
  312. static void smc_reset( int ioaddr )
  313. {
  314. /* This resets the registers mostly to defaults, but doesn't
  315.    affect EEPROM.  That seems unnecessary */
  316. SMC_SELECT_BANK( 0 );
  317. outw( RCR_SOFTRESET, ioaddr + RCR );
  319. /* this should pause enough for the chip to be happy */
  320. SMC_DELAY( );
  322. /* Set the transmit and receive configuration registers to
  323.    default values */
  324. outw( RCR_CLEAR, ioaddr + RCR );
  325. outw( TCR_CLEAR, ioaddr + TCR );
  327. /* set the control register to automatically
  328.    release successfully transmitted packets, to make the best
  329.    use out of our limited memory */
  330. SMC_SELECT_BANK( 1 );
  331. outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );
  333. /* Reset the MMU */
  334. SMC_SELECT_BANK( 2 );
  335. outw( MC_RESET, ioaddr + MMU_CMD );
  337. /* Note:  It doesn't seem that waiting for the MMU busy is needed here,
  338.    but this is a place where future chipsets _COULD_ break.  Be wary
  339.      of issuing another MMU command right after this */
  341. outb( 0, ioaddr + INT_MASK );
  342. }
  344. /*
  345.  . Function: smc_enable
  346.  . Purpose: let the chip talk to the outside work
  347.  . Method:
  348.  . 1.  Enable the transmitter
  349.  . 2.  Enable the receiver
  350.  . 3.  Enable interrupts
  351. */
  352. static void smc_enable( int ioaddr )
  353. {
  354. SMC_SELECT_BANK( 0 );
  355. /* see the header file for options in TCR/RCR NORMAL*/
  356. outw( TCR_NORMAL, ioaddr + TCR );
  357. outw( RCR_NORMAL, ioaddr + RCR );
  359. /* now, enable interrupts */
  360. SMC_SELECT_BANK( 2 );
  361. outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
  362. }
  364. /*
  365.  . Function: smc_shutdown
  366.  . Purpose:  closes down the SMC91xxx chip.
  367.  . Method:
  368.  . 1. zero the interrupt mask
  369.  . 2. clear the enable receive flag
  370.  . 3. clear the enable xmit flags
  371.  .
  372.  . TODO:
  373.  .   (1) maybe utilize power down mode.
  374.  . Why not yet?  Because while the chip will go into power down mode,
  375.  . the manual says that it will wake up in response to any I/O requests
  376.  . in the register space.   Empirical results do not show this working.
  377. */
  378. static void smc_shutdown( int ioaddr )
  379. {
  380. /* no more interrupts for me */
  381. SMC_SELECT_BANK( 2 );
  382. outb( 0, ioaddr + INT_MASK );
  384. /* and tell the card to stay away from that nasty outside world */
  385. SMC_SELECT_BANK( 0 );
  386. outb( RCR_CLEAR, ioaddr + RCR );
  387. outb( TCR_CLEAR, ioaddr + TCR );
  388. #if 0
  389. /* finally, shut the chip down */
  390. SMC_SELECT_BANK( 1 );
  391. outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL  );
  392. #endif
  393. }
  396. /*
  397.  . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )
  398.  . Purpose:
  399.  .    This sets the internal hardware table to filter out unwanted multicast
  400.  .    packets before they take up memory.
  401.  .
  402.  .    The SMC chip uses a hash table where the high 6 bits of the CRC of
  403.  .    address are the offset into the table.  If that bit is 1, then the
  404.  .    multicast packet is accepted.  Otherwise, it's dropped silently.
  405.  .
  406.  .    To use the 6 bits as an offset into the table, the high 3 bits are the
  407.  .    number of the 8 bit register, while the low 3 bits are the bit within
  408.  .    that register.
  409.  .
  410.  . This routine is based very heavily on the one provided by Peter Cammaert.
  411. */
  414. static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list * addrs ) {
  415. int i;
  416. unsigned char multicast_table[ 8 ];
  417. struct dev_mc_list * cur_addr;
  418. /* table for flipping the order of 3 bits */
  419. unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
  421. /* start with a table of all zeros: reject all */
  422. memset( multicast_table, 0, sizeof( multicast_table ) );
  424. cur_addr = addrs;
  425. for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next  ) {
  426. int position;
  428. /* do we have a pointer here? */
  429. if ( !cur_addr )
  430. break;
  431. /* make sure this is a multicast address - shouldn't this
  432.    be a given if we have it here ? */
  433. if ( !( *cur_addr->dmi_addr & 1 ) )
  434. continue;
  436. /* only use the low order bits */
  437. position = ether_crc_le(6, cur_addr->dmi_addr) & 0x3f;
  439. /* do some messy swapping to put the bit in the right spot */
  440. multicast_table[invert3[position&7]] |=
  441. (1<<invert3[(position>>3)&7]);
  443. }
  444. /* now, the table can be loaded into the chipset */
  445. SMC_SELECT_BANK( 3 );
  447. for ( i = 0; i < 8 ; i++ ) {
  448. outb( multicast_table[i], ioaddr + MULTICAST1 + i );
  449. }
  450. }
  452. /*
  453.  . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
  454.  . Purpose:
  455.  .    Attempt to allocate memory for a packet, if chip-memory is not
  456.  .    available, then tell the card to generate an interrupt when it
  457.  .    is available.
  458.  .
  459.  . Algorithm:
  460.  .
  461.  . o if the saved_skb is not currently null, then drop this packet
  462.  . on the floor.  This should never happen, because of TBUSY.
  463.  . o if the saved_skb is null, then replace it with the current packet,
  464.  . o See if I can sending it now.
  465.  . o  (NO): Enable interrupts and let the interrupt handler deal with it.
  466.  . o (YES):Send it now.
  467. */
  468. static int smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * dev )
  469. {
  470. struct smc_local *lp  = (struct smc_local *)dev->priv;
  471. unsigned short ioaddr  = dev->base_addr;
  472. word  length;
  473. unsigned short  numPages;
  474. word time_out;
  476. netif_stop_queue(dev);
  477. /* Well, I want to send the packet.. but I don't know
  478.    if I can send it right now...  */
  480. if ( lp->saved_skb) {
  481. /* THIS SHOULD NEVER HAPPEN. */
  482. lp->stats.tx_aborted_errors++;
  483. printk(CARDNAME": Bad Craziness - sent packet while busy.n" );
  484. return 1;
  485. }
  486. lp->saved_skb = skb;
  488. length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  491. /*
  492. ** The MMU wants the number of pages to be the number of 256 bytes
  493. ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
  494. **
  495. ** Pkt size for allocating is data length +6 (for additional status words,
  496. ** length and ctl!) If odd size last byte is included in this header.
  497. */
  498. numPages =  ((length & 0xfffe) + 6) / 256;
  500. if (numPages > 7 ) {
  501. printk(CARDNAME": Far too big packet error. n");
  502. /* freeing the packet is a good thing here... but should
  503.  . any packets of this size get down here?   */
  504. dev_kfree_skb (skb);
  505. lp->saved_skb = NULL;
  506. /* this IS an error, but, i don't want the skb saved */
  507. netif_wake_queue(dev);
  508. return 0;
  509. }
  510. /* either way, a packet is waiting now */
  511. lp->packets_waiting++;
  513. /* now, try to allocate the memory */
  514. SMC_SELECT_BANK( 2 );
  515. outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
  516. /*
  517.   . Performance Hack
  518. .
  519.   . wait a short amount of time.. if I can send a packet now, I send
  520. . it now.  Otherwise, I enable an interrupt and wait for one to be
  521. . available.
  522. .
  523. . I could have handled this a slightly different way, by checking to
  524. . see if any memory was available in the FREE MEMORY register.  However,
  525. . either way, I need to generate an allocation, and the allocation works
  526. . no matter what, so I saw no point in checking free memory.
  527. */
  528. time_out = MEMORY_WAIT_TIME;
  529. do {
  530. word status;
  532. status = inb( ioaddr + INTERRUPT );
  533. if ( status & IM_ALLOC_INT ) {
  534. /* acknowledge the interrupt */
  535. outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
  536.    break;
  537. }
  538.     } while ( -- time_out );
  540.     if ( !time_out ) {
  541. /* oh well, wait until the chip finds memory later */
  542. SMC_ENABLE_INT( IM_ALLOC_INT );
  543.        PRINTK2((CARDNAME": memory allocation deferred. n"));
  544. /* it's deferred, but I'll handle it later */
  545.        return 0;
  546.     }
  547. /* or YES! I can send the packet now.. */
  548. smc_hardware_send_packet(dev);
  549. netif_wake_queue(dev);
  550. return 0;
  551. }
  553. /*
  554.  . Function:  smc_hardware_send_packet(struct net_device * )
  555.  . Purpose:
  556.  . This sends the actual packet to the SMC9xxx chip.
  557.  .
  558.  . Algorithm:
  559.  .  First, see if a saved_skb is available.
  560.  . ( this should NOT be called if there is no 'saved_skb'
  561.  . Now, find the packet number that the chip allocated
  562.  . Point the data pointers at it in memory
  563.  . Set the length word in the chip's memory
  564.  . Dump the packet to chip memory
  565.  . Check if a last byte is needed ( odd length packet )
  566.  . if so, set the control flag right
  567.  .  Tell the card to send it
  568.  . Enable the transmit interrupt, so I know if it failed
  569.  .  Free the kernel data if I actually sent it.
  570. */
  571. static void smc_hardware_send_packet( struct net_device * dev )
  572. {
  573. struct smc_local *lp = (struct smc_local *)dev->priv;
  574. byte   packet_no;
  575. struct sk_buff *  skb = lp->saved_skb;
  576. word length;
  577. unsigned short ioaddr;
  578. byte * buf;
  580. ioaddr = dev->base_addr;
  582. if ( !skb ) {
  583. PRINTK((CARDNAME": In XMIT with no packet to send n"));
  584. return;
  585. }
  586. length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
  587. buf = skb->data;
  589. /* If I get here, I _know_ there is a packet slot waiting for me */
  590. packet_no = inb( ioaddr + PNR_ARR + 1 );
  591. if ( packet_no & 0x80 ) {
  592. /* or isn't there?  BAD CHIP! */
  593. printk(KERN_DEBUG CARDNAME": Memory allocation failed. n");
  594. dev_kfree_skb_any(skb);
  595. lp->saved_skb = NULL;
  596. netif_wake_queue(dev);
  597. return;
  598. }
  600. /* we have a packet address, so tell the card to use it */
  601. outb( packet_no, ioaddr + PNR_ARR );
  603. /* point to the beginning of the packet */
  604. outw( PTR_AUTOINC , ioaddr + POINTER );
  606.     PRINTK3((CARDNAME": Trying to xmit packet of length %xn", length ));
  607. #if SMC_DEBUG > 2
  608. print_packet( buf, length );
  609. #endif
  611. /* send the packet length ( +6 for status, length and ctl byte )
  612.      and the status word ( set to zeros ) */
  613. #ifdef USE_32_BIT
  614. outl(  (length +6 ) << 16 , ioaddr + DATA_1 );
  615. #else
  616. outw( 0, ioaddr + DATA_1 );
  617. /* send the packet length ( +6 for status words, length, and ctl*/
  618. outb( (length+6) & 0xFF,ioaddr + DATA_1 );
  619. outb( (length+6) >> 8 , ioaddr + DATA_1 );
  620. #endif
  622. /* send the actual data
  623.  . I _think_ it's faster to send the longs first, and then
  624.  . mop up by sending the last word.  It depends heavily
  625.    . on alignment, at least on the 486.  Maybe it would be
  626.    . a good idea to check which is optimal?  But that could take
  627.  . almost as much time as is saved?
  628. */
  629. #ifdef USE_32_BIT
  630. if ( length & 0x2  ) {
  631. outsl(ioaddr + DATA_1, buf,  length >> 2 );
  632. outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
  633. }
  634. else
  635. outsl(ioaddr + DATA_1, buf,  length >> 2 );
  636. #else
  637. outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
  638. #endif
  639. /* Send the last byte, if there is one.   */
  641. if ( (length & 1) == 0 ) {
  642. outw( 0, ioaddr + DATA_1 );
  643. } else {
  644. outb( buf[length -1 ], ioaddr + DATA_1 );
  645. outb( 0x20, ioaddr + DATA_1);
  646. }
  648. /* enable the interrupts */
  649. SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
  651. /* and let the chipset deal with it */
  652. outw( MC_ENQUEUE , ioaddr + MMU_CMD );
  654. PRINTK2((CARDNAME": Sent packet of length %d n",length));
  656. lp->saved_skb = NULL;
  657. dev_kfree_skb_any (skb);
  659. dev->trans_start = jiffies;
  661. /* we can send another packet */
  662. netif_wake_queue(dev);
  664. return;
  665. }
  667. /*-------------------------------------------------------------------------
  668.  |
  669.  | smc_init( struct net_device * dev )
  670.  |   Input parameters:
  671.  | dev->base_addr == 0, try to find all possible locations
  672.  | dev->base_addr == 1, return failure code
  673.  | dev->base_addr == 2, always allocate space,  and return success
  674.  | dev->base_addr == <anything else>   this is the address to check
  675.  |
  676.  |   Output:
  677.  | 0 --> there is a device
  678.  | anything else, error
  679.  |
  680.  ---------------------------------------------------------------------------
  681. */
  682. int __init smc_init(struct net_device *dev)
  683. {
  684. int i;
  685. int base_addr = dev->base_addr;
  687. SET_MODULE_OWNER(dev);
  689. /*  try a specific location */
  690. if (base_addr > 0x1ff)
  691. return smc_probe(dev, base_addr);
  692. else if (base_addr != 0)
  693. return -ENXIO;
  695. /* check every ethernet address */
  696. for (i = 0; smc_portlist[i]; i++)
  697. if (smc_probe(dev, smc_portlist[i]) == 0)
  698. return 0;
  700. /* couldn't find anything */
  701. return -ENODEV;
  702. }
  704. /*----------------------------------------------------------------------
  705.  . smc_findirq
  706.  .
  707.  . This routine has a simple purpose -- make the SMC chip generate an
  708.  . interrupt, so an auto-detect routine can detect it, and find the IRQ,
  709.  ------------------------------------------------------------------------
  710. */
  711. int __init smc_findirq( int ioaddr )
  712. {
  713. int timeout = 20;
  714. unsigned long cookie;
  717. /* I have to do a STI() here, because this is called from
  718.    a routine that does an CLI during this process, making it
  719.    rather difficult to get interrupts for auto detection */
  720. sti();
  722. cookie = probe_irq_on();
  724. /*
  725.  * What I try to do here is trigger an ALLOC_INT. This is done
  726.  * by allocating a small chunk of memory, which will give an interrupt
  727.  * when done.
  728.  */
  731. SMC_SELECT_BANK(2);
  732. /* enable ALLOCation interrupts ONLY */
  733. outb( IM_ALLOC_INT, ioaddr + INT_MASK );
  735. /*
  736.    . Allocate 512 bytes of memory.  Note that the chip was just
  737.  . reset so all the memory is available
  738. */
  739. outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
  741. /*
  742.  . Wait until positive that the interrupt has been generated
  743. */
  744. while ( timeout ) {
  745. byte int_status;
  747. int_status = inb( ioaddr + INTERRUPT );
  749. if ( int_status & IM_ALLOC_INT )
  750. break; /* got the interrupt */
  751. timeout--;
  752. }
  753. /* there is really nothing that I can do here if timeout fails,
  754.    as autoirq_report will return a 0 anyway, which is what I
  755.    want in this case.   Plus, the clean up is needed in both
  756.    cases.  */
  758. /* DELAY HERE!
  759.    On a fast machine, the status might change before the interrupt
  760.    is given to the processor.  This means that the interrupt was
  761.    never detected, and autoirq_report fails to report anything.
  762.    This should fix autoirq_* problems.
  763. */
  764. SMC_DELAY();
  765. SMC_DELAY();
  767. /* and disable all interrupts again */
  768. outb( 0, ioaddr + INT_MASK );
  770. /* clear hardware interrupts again, because that's how it
  771.    was when I was called... */
  772. cli();
  774. /* and return what I found */
  775. return probe_irq_off(cookie);
  776. }
  778. /*----------------------------------------------------------------------
  779.  . Function: smc_probe( int ioaddr )
  780.  .
  781.  . Purpose:
  782.  . Tests to see if a given ioaddr points to an SMC9xxx chip.
  783.  . Returns a 0 on success
  784.  .
  785.  . Algorithm:
  786.  . (1) see if the high byte of BANK_SELECT is 0x33
  787.  .  (2) compare the ioaddr with the base register's address
  788.  . (3) see if I recognize the chip ID in the appropriate register
  789.  .
  790.  .---------------------------------------------------------------------
  791.  */
  793. /*---------------------------------------------------------------
  794.  . Here I do typical initialization tasks.
  795.  .
  796.  . o  Initialize the structure if needed
  797.  . o  print out my vanity message if not done so already
  798.  . o  print out what type of hardware is detected
  799.  . o  print out the ethernet address
  800.  . o  find the IRQ
  801.  . o  set up my private data
  802.  . o  configure the dev structure with my subroutines
  803.  . o  actually GRAB the irq.
  804.  . o  GRAB the region
  805.  .-----------------------------------------------------------------
  806. */
  807. static int __init smc_probe(struct net_device *dev, int ioaddr)
  808. {
  809. int i, memory, retval;
  810. static unsigned version_printed;
  811. unsigned int bank;
  813. const char *version_string;
  814. const char *if_string;
  816. /* registers */
  817. word revision_register;
  818. word base_address_register;
  819. word configuration_register;
  820. word memory_info_register;
  821. word memory_cfg_register;
  823. /* Grab the region so that no one else tries to probe our ioports. */
  824. if (!request_region(ioaddr, SMC_IO_EXTENT, dev->name))
  825. return -EBUSY;
  827. /* First, see if the high byte is 0x33 */
  828. bank = inw( ioaddr + BANK_SELECT );
  829. if ( (bank & 0xFF00) != 0x3300 ) {
  830. retval = -ENODEV;
  831. goto err_out;
  832. }
  833. /* The above MIGHT indicate a device, but I need to write to further
  834.     test this.  */
  835. outw( 0x0, ioaddr + BANK_SELECT );
  836. bank = inw( ioaddr + BANK_SELECT );
  837. if ( (bank & 0xFF00 ) != 0x3300 ) {
  838. retval = -ENODEV;
  839. goto err_out;
  840. }
  841. /* well, we've already written once, so hopefully another time won't
  842.      hurt.  This time, I need to switch the bank register to bank 1,
  843.    so I can access the base address register */
  844. SMC_SELECT_BANK(1);
  845. base_address_register = inw( ioaddr + BASE );
  846. if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) )  {
  847. printk(CARDNAME ": IOADDR %x doesn't match configuration (%x)."
  848. "Probably not a SMC chipn",
  849. ioaddr, base_address_register >> 3 & 0x3E0 );
  850. /* well, the base address register didn't match.  Must not have
  851.    been a SMC chip after all. */
  852. retval = -ENODEV;
  853. goto err_out;
  854. }
  856. /*  check if the revision register is something that I recognize.
  857.     These might need to be added to later, as future revisions
  858.     could be added.  */
  859. SMC_SELECT_BANK(3);
  860. revision_register  = inw( ioaddr + REVISION );
  861. if ( !chip_ids[ ( revision_register  >> 4 ) & 0xF  ] ) {
  862. /* I don't recognize this chip, so... */
  863. printk(CARDNAME ": IO %x: Unrecognized revision register:"
  864. " %x, Contact author. n", ioaddr, revision_register );
  866. retval = -ENODEV;
  867. goto err_out;
  868. }
  870. /* at this point I'll assume that the chip is an SMC9xxx.
  871.    It might be prudent to check a listing of MAC addresses
  872.    against the hardware address, or do some other tests. */
  874. if (version_printed++ == 0)
  875. printk("%s", version);
  877. /* fill in some of the fields */
  878. dev->base_addr = ioaddr;
  880. /*
  881.    . Get the MAC address ( bank 1, regs 4 - 9 )
  882. */
  883. SMC_SELECT_BANK( 1 );
  884. for ( i = 0; i < 6; i += 2 ) {
  885. word address;
  887. address = inw( ioaddr + ADDR0 + i  );
  888. dev->dev_addr[ i + 1] = address >> 8;
  889. dev->dev_addr[ i ] = address & 0xFF;
  890. }
  892. /* get the memory information */
  894. SMC_SELECT_BANK( 0 );
  895. memory_info_register = inw( ioaddr + MIR );
  896. memory_cfg_register  = inw( ioaddr + MCR );
  897. memory = ( memory_cfg_register >> 9 )  & 0x7;  /* multiplier */
  898. memory *= 256 * ( memory_info_register & 0xFF );
  900. /*
  901.  Now, I want to find out more about the chip.  This is sort of
  902.    redundant, but it's cleaner to have it in both, rather than having
  903.    one VERY long probe procedure.
  904. */
  905. SMC_SELECT_BANK(3);
  906. revision_register  = inw( ioaddr + REVISION );
  907. version_string = chip_ids[ ( revision_register  >> 4 ) & 0xF  ];
  908. if ( !version_string ) {
  909. /* I shouldn't get here because this call was done before.... */
  910. retval = -ENODEV;
  911. goto err_out;
  912. }
  914. /* is it using AUI or 10BaseT ? */
  915. if ( dev->if_port == 0 ) {
  916. SMC_SELECT_BANK(1);
  917. configuration_register = inw( ioaddr + CONFIG );
  918. if ( configuration_register & CFG_AUI_SELECT )
  919. dev->if_port = 2;
  920. else
  921. dev->if_port = 1;
  922. }
  923. if_string = interfaces[ dev->if_port - 1 ];
  925. /* now, reset the chip, and put it into a known state */
  926. smc_reset( ioaddr );
  928. /*
  929.  . If dev->irq is 0, then the device has to be banged on to see
  930.  . what the IRQ is.
  931.    .
  932.  . This banging doesn't always detect the IRQ, for unknown reasons.
  933.  . a workaround is to reset the chip and try again.
  934.  .
  935.  . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
  936.  . be what is requested on the command line.   I don't do that, mostly
  937.  . because the card that I have uses a non-standard method of accessing
  938.  . the IRQs, and because this _should_ work in most configurations.
  939.  .
  940.  . Specifying an IRQ is done with the assumption that the user knows
  941.  . what (s)he is doing.  No checking is done!!!!
  942.    .
  943. */
  944. if ( dev->irq < 2 ) {
  945. int trials;
  947. trials = 3;
  948. while ( trials-- ) {
  949. dev->irq = smc_findirq( ioaddr );
  950. if ( dev->irq )
  951. break;
  952. /* kick the card and try again */
  953. smc_reset( ioaddr );
  954. }
  955. }
  956. if (dev->irq == 0 ) {
  957. printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.n");
  958. retval = -ENODEV;
  959. goto err_out;
  960. }
  962. /* now, print out the card info, in a short format.. */
  964. printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
  965. version_string, revision_register & 0xF, ioaddr, dev->irq,
  966. if_string, memory );
  967. /*
  968.  . Print the Ethernet address
  969. */
  970. printk("ADDR: ");
  971. for (i = 0; i < 5; i++)
  972. printk("%2.2x:", dev->dev_addr[i] );
  973. printk("%2.2x n", dev->dev_addr[5] );
  976. /* Initialize the private structure. */
  977. if (dev->priv == NULL) {
  978. dev->priv = kmalloc(sizeof(struct smc_local), GFP_KERNEL);
  979. if (dev->priv == NULL) {
  980. retval = -ENOMEM;
  981. goto err_out;
  982. }
  983. }
  984. /* set the private data to zero by default */
  985. memset(dev->priv, 0, sizeof(struct smc_local));
  987. /* Fill in the fields of the device structure with ethernet values. */
  988. ether_setup(dev);
  990. /* Grab the IRQ */
  991.        retval = request_irq(dev->irq, &smc_interrupt, 0, dev->name, dev);
  992.        if (retval) {
  993. printk("%s: unable to get IRQ %d (irqval=%d).n", dev->name,
  994. dev->irq, retval);
  995. kfree(dev->priv);
  996. dev->priv = NULL;
  997.       goto err_out;
  998.        }
  1000. dev->open         = smc_open;
  1001. dev->stop         = smc_close;
  1002. dev->hard_start_xmit     = smc_wait_to_send_packet;
  1003. dev->tx_timeout      = smc_timeout;
  1004. dev->watchdog_timeo = HZ/20;
  1005. dev->get_stats = smc_query_statistics;
  1006. dev->set_multicast_list  = smc_set_multicast_list;
  1008. return 0;
  1010. err_out:
  1011. release_region(ioaddr, SMC_IO_EXTENT);
  1012. return retval;
  1013. }
  1015. #if SMC_DEBUG > 2
  1016. static void print_packet( byte * buf, int length )
  1017. {
  1018. #if 0
  1019. int i;
  1020. int remainder;
  1021. int lines;
  1023. printk("Packet of length %d n", length );
  1024. lines = length / 16;
  1025. remainder = length % 16;
  1027. for ( i = 0; i < lines ; i ++ ) {
  1028. int cur;
  1030. for ( cur = 0; cur < 8; cur ++ ) {
  1031. byte a, b;
  1033. a = *(buf ++ );
  1034. b = *(buf ++ );
  1035. printk("%02x%02x ", a, b );
  1036. }
  1037. printk("n");
  1038. }
  1039. for ( i = 0; i < remainder/2 ; i++ ) {
  1040. byte a, b;
  1042. a = *(buf ++ );
  1043. b = *(buf ++ );
  1044. printk("%02x%02x ", a, b );
  1045. }
  1046. printk("n");
  1047. #endif
  1048. }
  1049. #endif
  1052. /*
  1053.  * Open and Initialize the board
  1054.  *
  1055.  * Set up everything, reset the card, etc ..
  1056.  *
  1057.  */
  1058. static int smc_open(struct net_device *dev)
  1059. {
  1060. int ioaddr = dev->base_addr;
  1062. int i; /* used to set hw ethernet address */
  1064. /* clear out all the junk that was put here before... */
  1065. memset(dev->priv, 0, sizeof(struct smc_local));
  1067. /* reset the hardware */
  1069. smc_reset( ioaddr );
  1070. smc_enable( ioaddr );
  1072. /* Select which interface to use */
  1074. SMC_SELECT_BANK( 1 );
  1075. if ( dev->if_port == 1 ) {
  1076. outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
  1077. ioaddr + CONFIG );
  1078. }
  1079. else if ( dev->if_port == 2 ) {
  1080. outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
  1081. ioaddr + CONFIG );
  1082. }
  1084. /*
  1085.    According to Becker, I have to set the hardware address
  1086. at this point, because the (l)user can set it with an
  1087. ioctl.  Easily done...
  1088. */
  1089. SMC_SELECT_BANK( 1 );
  1090. for ( i = 0; i < 6; i += 2 ) {
  1091. word address;
  1093. address = dev->dev_addr[ i + 1 ] << 8 ;
  1094. address  |= dev->dev_addr[ i ];
  1095. outw( address, ioaddr + ADDR0 + i );
  1096. }
  1098. netif_start_queue(dev);
  1099. return 0;
  1100. }
  1102. /*--------------------------------------------------------
  1103.  . Called by the kernel to send a packet out into the void
  1104.  . of the net.  This routine is largely based on
  1105.  . skeleton.c, from Becker.
  1106.  .--------------------------------------------------------
  1107. */
  1109. static void smc_timeout(struct net_device *dev)
  1110. {
  1111. /* If we get here, some higher level has decided we are broken.
  1112.    There should really be a "kick me" function call instead. */
  1113. printk(KERN_WARNING CARDNAME": transmit timed out, %s?n",
  1114. tx_done(dev) ? "IRQ conflict" :
  1115. "network cable problem");
  1116. /* "kick" the adaptor */
  1117. smc_reset( dev->base_addr );
  1118. smc_enable( dev->base_addr );
  1119. dev->trans_start = jiffies;
  1120. /* clear anything saved */
  1121. ((struct smc_local *)dev->priv)->saved_skb = NULL;
  1122. netif_wake_queue(dev);
  1123. }
  1125. /*--------------------------------------------------------------------
  1126.  .
  1127.  . This is the main routine of the driver, to handle the device when
  1128.  . it needs some attention.
  1129.  .
  1130.  . So:
  1131.  .   first, save state of the chipset
  1132.  .   branch off into routines to handle each case, and acknowledge
  1133.  .     each to the interrupt register
  1134.  .   and finally restore state.
  1135.  .
  1136.  ---------------------------------------------------------------------*/
  1138. static void smc_interrupt(int irq, void * dev_id,  struct pt_regs * regs)
  1139. {
  1140. struct net_device *dev  = dev_id;
  1141. int ioaddr  = dev->base_addr;
  1142. struct smc_local *lp  = (struct smc_local *)dev->priv;
  1144. byte status;
  1145. word card_stats;
  1146. byte mask;
  1147. int timeout;
  1148. /* state registers */
  1149. word saved_bank;
  1150. word saved_pointer;
  1154. PRINTK3((CARDNAME": SMC interrupt started n"));
  1156. saved_bank = inw( ioaddr + BANK_SELECT );
  1158. SMC_SELECT_BANK(2);
  1159. saved_pointer = inw( ioaddr + POINTER );
  1161. mask = inb( ioaddr + INT_MASK );
  1162. /* clear all interrupts */
  1163. outb( 0, ioaddr + INT_MASK );
  1166. /* set a timeout value, so I don't stay here forever */
  1167. timeout = 4;
  1169. PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x n", mask ));
  1170. do {
  1171. /* read the status flag, and mask it */
  1172. status = inb( ioaddr + INTERRUPT ) & mask;
  1173. if (!status )
  1174. break;
  1176. PRINTK3((KERN_WARNING CARDNAME
  1177. ": Handling interrupt status %x n", status ));
  1179. if (status & IM_RCV_INT) {
  1180. /* Got a packet(s). */
  1181. PRINTK2((KERN_WARNING CARDNAME
  1182. ": Receive Interruptn"));
  1183. smc_rcv(dev);
  1184. } else if (status & IM_TX_INT ) {
  1185. PRINTK2((KERN_WARNING CARDNAME
  1186. ": TX ERROR handledn"));
  1187. smc_tx(dev);
  1188. outb(IM_TX_INT, ioaddr + INTERRUPT );
  1189. } else if (status & IM_TX_EMPTY_INT ) {
  1190. /* update stats */
  1191. SMC_SELECT_BANK( 0 );
  1192. card_stats = inw( ioaddr + COUNTER );
  1193. /* single collisions */
  1194. lp->stats.collisions += card_stats & 0xF;
  1195. card_stats >>= 4;
  1196. /* multiple collisions */
  1197. lp->stats.collisions += card_stats & 0xF;
  1199. /* these are for when linux supports these statistics */
  1201. SMC_SELECT_BANK( 2 );
  1202. PRINTK2((KERN_WARNING CARDNAME
  1203. ": TX_BUFFER_EMPTY handledn"));
  1204. outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
  1205. mask &= ~IM_TX_EMPTY_INT;
  1206. lp->stats.tx_packets += lp->packets_waiting;
  1207. lp->packets_waiting = 0;
  1209. } else if (status & IM_ALLOC_INT ) {
  1210. PRINTK2((KERN_DEBUG CARDNAME
  1211. ": Allocation interrupt n"));
  1212. /* clear this interrupt so it doesn't happen again */
  1213. mask &= ~IM_ALLOC_INT;
  1215. smc_hardware_send_packet( dev );
  1217. /* enable xmit interrupts based on this */
  1218. mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
  1220. /* and let the card send more packets to me */
  1221. netif_wake_queue(dev);
  1223. PRINTK2((CARDNAME": Handoff done successfully.n"));
  1224. } else if (status & IM_RX_OVRN_INT ) {
  1225. lp->stats.rx_errors++;
  1226. lp->stats.rx_fifo_errors++;
  1227. outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
  1228. } else if (status & IM_EPH_INT ) {
  1229. PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT n"));
  1230. } else if (status & IM_ERCV_INT ) {
  1231. PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT n"));
  1232. outb( IM_ERCV_INT, ioaddr + INTERRUPT );
  1233. }
  1234. } while ( timeout -- );
  1237. /* restore state register */
  1238. SMC_SELECT_BANK( 2 );
  1239. outb( mask, ioaddr + INT_MASK );
  1241. PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x n", mask ));
  1242. outw( saved_pointer, ioaddr + POINTER );
  1244. SMC_SELECT_BANK( saved_bank );
  1246. PRINTK3((CARDNAME ": Interrupt donen"));
  1247. return;
  1248. }
  1250. /*-------------------------------------------------------------
  1251.  .
  1252.  . smc_rcv -  receive a packet from the card
  1253.  .
  1254.  . There is ( at least ) a packet waiting to be read from
  1255.  . chip-memory.
  1256.  .
  1257.  . o Read the status
  1258.  . o If an error, record it
  1259.  . o otherwise, read in the packet
  1260.  --------------------------------------------------------------
  1261. */
  1262. static void smc_rcv(struct net_device *dev)
  1263. {
  1264. struct smc_local *lp = (struct smc_local *)dev->priv;
  1265. int  ioaddr = dev->base_addr;
  1266. int  packet_number;
  1267. word status;
  1268. word packet_length;
  1270. /* assume bank 2 */
  1272. packet_number = inw( ioaddr + FIFO_PORTS );
  1274. if ( packet_number & FP_RXEMPTY ) {
  1275. /* we got called , but nothing was on the FIFO */
  1276. PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. n"));
  1277. /* don't need to restore anything */
  1278. return;
  1279. }
  1281. /*  start reading from the start of the packet */
  1282. outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
  1284. /* First two words are status and packet_length */
  1285. status  = inw( ioaddr + DATA_1 );
  1286. packet_length  = inw( ioaddr + DATA_1 );
  1288. packet_length &= 0x07ff;  /* mask off top bits */
  1290. PRINTK2(("RCV: STATUS %4x LENGTH %4xn", status, packet_length ));
  1291. /*
  1292.  . the packet length contains 3 extra words :
  1293.  . status, length, and an extra word with an odd byte .
  1294. */
  1295. packet_length -= 6;
  1297. if ( !(status & RS_ERRORS ) ){
  1298. /* do stuff to make a new packet */
  1299. struct sk_buff  * skb;
  1300. byte * data;
  1302. /* read one extra byte */
  1303. if ( status & RS_ODDFRAME )
  1304. packet_length++;
  1306. /* set multicast stats */
  1307. if ( status & RS_MULTICAST )
  1308. lp->stats.multicast++;
  1310. skb = dev_alloc_skb( packet_length + 5);
  1312. if ( skb == NULL ) {
  1313. printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.n");
  1314. lp->stats.rx_dropped++;
  1315. goto done;
  1316. }
  1318. /*
  1319.  ! This should work without alignment, but it could be
  1320.  ! in the worse case
  1321. */
  1323. skb_reserve( skb, 2 );   /* 16 bit alignment */
  1325. skb->dev = dev;
  1326. data = skb_put( skb, packet_length);
  1328. #ifdef USE_32_BIT
  1329. /* QUESTION:  Like in the TX routine, do I want
  1330.    to send the DWORDs or the bytes first, or some
  1331.    mixture.  A mixture might improve already slow PIO
  1332.    performance  */
  1333. PRINTK3((" Reading %d dwords (and %d bytes) n",
  1334. packet_length >> 2, packet_length & 3 ));
  1335. insl(ioaddr + DATA_1 , data, packet_length >> 2 );
  1336. /* read the left over bytes */
  1337. insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
  1338. packet_length & 0x3  );
  1339. #else
  1340. PRINTK3((" Reading %d words and %d byte(s) n",
  1341. (packet_length >> 1 ), packet_length & 1 ));
  1342. insw(ioaddr + DATA_1 , data, packet_length >> 1);
  1343. if ( packet_length & 1 ) {
  1344. data += packet_length & ~1;
  1345. *(data++) = inb( ioaddr + DATA_1 );
  1346. }
  1347. #endif
  1348. #if SMC_DEBUG > 2
  1349. print_packet( data, packet_length );
  1350. #endif
  1352. skb->protocol = eth_type_trans(skb, dev );
  1353. netif_rx(skb);
  1354. dev->last_rx = jiffies;
  1355. lp->stats.rx_packets++;
  1356. lp->stats.rx_bytes += packet_length;
  1357. } else {
  1358. /* error ... */
  1359. lp->stats.rx_errors++;
  1361. if ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;
  1362. if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
  1363. lp->stats.rx_length_errors++;
  1364. if ( status & RS_BADCRC) lp->stats.rx_crc_errors++;
  1365. }
  1367. done:
  1368. /*  error or good, tell the card to get rid of this packet */
  1369. outw( MC_RELEASE, ioaddr + MMU_CMD );
  1370. }
  1373. /*************************************************************************
  1374.  . smc_tx
  1375.  .
  1376.  . Purpose:  Handle a transmit error message.   This will only be called
  1377.  .   when an error, because of the AUTO_RELEASE mode.
  1378.  .
  1379.  . Algorithm:
  1380.  . Save pointer and packet no
  1381.  . Get the packet no from the top of the queue
  1382.  . check if it's valid ( if not, is this an error??? )
  1383.  . read the status word
  1384.  . record the error
  1385.  . ( resend?  Not really, since we don't want old packets around )
  1386.  . Restore saved values
  1387.  ************************************************************************/
  1388. static void smc_tx( struct net_device * dev )
  1389. {
  1390. int ioaddr = dev->base_addr;
  1391. struct smc_local *lp = (struct smc_local *)dev->priv;
  1392. byte saved_packet;
  1393. byte packet_no;
  1394. word tx_status;
  1397. /* assume bank 2  */
  1399. saved_packet = inb( ioaddr + PNR_ARR );
  1400. packet_no = inw( ioaddr + FIFO_PORTS );
  1401. packet_no &= 0x7F;
  1403. /* select this as the packet to read from */
  1404. outb( packet_no, ioaddr + PNR_ARR );
  1406. /* read the first word from this packet */
  1407. outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
  1409. tx_status = inw( ioaddr + DATA_1 );
  1410. PRINTK3((CARDNAME": TX DONE STATUS: %4x n", tx_status ));
  1412. lp->stats.tx_errors++;
  1413. if ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
  1414. if ( tx_status & TS_LATCOL  ) {
  1415. printk(KERN_DEBUG CARDNAME
  1416. ": Late collision occurred on last xmit.n");
  1417. lp->stats.tx_window_errors++;
  1418. }
  1419. #if 0
  1420. if ( tx_status & TS_16COL ) { ... }
  1421. #endif
  1423. if ( tx_status & TS_SUCCESS ) {
  1424. printk(CARDNAME": Successful packet caused interrupt n");
  1425. }
  1426. /* re-enable transmit */
  1427. SMC_SELECT_BANK( 0 );
  1428. outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
  1430. /* kill the packet */
  1431. SMC_SELECT_BANK( 2 );
  1432. outw( MC_FREEPKT, ioaddr + MMU_CMD );
  1434. /* one less packet waiting for me */
  1435. lp->packets_waiting--;
  1437. outb( saved_packet, ioaddr + PNR_ARR );
  1438. return;
  1439. }
  1441. /*----------------------------------------------------
  1442.  . smc_close
  1443.  .
  1444.  . this makes the board clean up everything that it can
  1445.  . and not talk to the outside world.   Caused by
  1446.  . an 'ifconfig ethX down'
  1447.  .
  1448.  -----------------------------------------------------*/
  1449. static int smc_close(struct net_device *dev)
  1450. {
  1451. netif_stop_queue(dev);
  1452. /* clear everything */
  1453. smc_shutdown( dev->base_addr );
  1455. /* Update the statistics here. */
  1456. return 0;
  1457. }
  1459. /*------------------------------------------------------------
  1460.  . Get the current statistics.
  1461.  . This may be called with the card open or closed.
  1462.  .-------------------------------------------------------------*/
  1463. static struct net_device_stats* smc_query_statistics(struct net_device *dev) {
  1464. struct smc_local *lp = (struct smc_local *)dev->priv;
  1466. return &lp->stats;
  1467. }
  1469. /*-----------------------------------------------------------
  1470.  . smc_set_multicast_list
  1471.  .
  1472.  . This routine will, depending on the values passed to it,
  1473.  . either make it accept multicast packets, go into
  1474.  . promiscuous mode ( for TCPDUMP and cousins ) or accept
  1475.  . a select set of multicast packets
  1476. */
  1477. static void smc_set_multicast_list(struct net_device *dev)
  1478. {
  1479. short ioaddr = dev->base_addr;
  1481. SMC_SELECT_BANK(0);
  1482. if ( dev->flags & IFF_PROMISC )
  1483. outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
  1485. /* BUG?  I never disable promiscuous mode if multicasting was turned on.
  1486.    Now, I turn off promiscuous mode, but I don't do anything to multicasting
  1487.    when promiscuous mode is turned on.
  1488. */
  1490. /* Here, I am setting this to accept all multicast packets.
  1491.    I don't need to zero the multicast table, because the flag is
  1492.    checked before the table is
  1493. */
  1494. else if (dev->flags & IFF_ALLMULTI)
  1495. outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
  1497. /* We just get all multicast packets even if we only want them
  1498.  . from one source.  This will be changed at some future
  1499.  . point. */
  1500. else if (dev->mc_count )  {
  1501. /* support hardware multicasting */
  1503. /* be sure I get rid of flags I might have set */
  1504. outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
  1505. ioaddr + RCR );
  1506. /* NOTE: this has to set the bank, so make sure it is the
  1507.    last thing called.  The bank is set to zero at the top */
  1508. smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
  1509. }
  1510. else  {
  1511. outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
  1512. ioaddr + RCR );
  1514. /*
  1515.   since I'm disabling all multicast entirely, I need to
  1516.   clear the multicast list
  1517. */
  1518. SMC_SELECT_BANK( 3 );
  1519. outw( 0, ioaddr + MULTICAST1 );
  1520. outw( 0, ioaddr + MULTICAST2 );
  1521. outw( 0, ioaddr + MULTICAST3 );
  1522. outw( 0, ioaddr + MULTICAST4 );
  1523. }
  1524. }
  1526. #ifdef MODULE
  1528. static struct net_device devSMC9194;
  1529. static int io;
  1530. static int irq;
  1531. static int ifport;
  1532. MODULE_LICENSE("GPL");
  1534. MODULE_PARM(io, "i");
  1535. MODULE_PARM(irq, "i");
  1536. MODULE_PARM(ifport, "i");
  1537. MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
  1538. MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
  1539. MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
  1541. int init_module(void)
  1542. {
  1543. int result;
  1545. if (io == 0)
  1546. printk(KERN_WARNING
  1547. CARDNAME": You shouldn't use auto-probing with insmod!n" );
  1549. /* copy the parameters from insmod into the device structure */
  1550. devSMC9194.base_addr = io;
  1551. devSMC9194.irq       = irq;
  1552. devSMC9194.if_port = ifport;
  1553. devSMC9194.init    = smc_init;
  1554. if ((result = register_netdev(&devSMC9194)) != 0)
  1555. return result;
  1557. return 0;
  1558. }
  1560. void cleanup_module(void)
  1561. {
  1562. /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
  1563. unregister_netdev(&devSMC9194);
  1565. free_irq(devSMC9194.irq, &devSMC9194);
  1566. release_region(devSMC9194.base_addr, SMC_IO_EXTENT);
  1568. if (devSMC9194.priv)
  1569. kfree(devSMC9194.priv);
  1570. }
  1572. #endif /* MODULE */