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

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

Linux/Unix编程

开发平台：

Unix_Linux

sbni.c：源码内容
  1. /* sbni.c:  Granch SBNI12 leased line adapters driver for linux
  2.  *
  3.  * Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
  4.  *
  5.  * Previous versions were written by Yaroslav Polyakov,
  6.  * Alexey Zverev and Max Khon.
  7.  *
  8.  * Driver supports SBNI12-02,-04,-05,-10,-11 cards, single and
  9.  * double-channel, PCI and ISA modifications.
  10.  * More info and useful utilities to work with SBNI12 cards you can find
  11.  * at http://www.granch.com (English) or http://www.granch.ru (Russian)
  12.  *
  13.  * This software may be used and distributed according to the terms
  14.  * of the GNU General Public License.
  15.  *
  16.  *
  17.  *  5.0.1 Jun 22 2001
  18.  *   - Fixed bug in probe
  19.  *  5.0.0 Jun 06 2001
  20.  *   - Driver was completely redesigned by Denis I.Timofeev,
  21.  *   - now PCI/Dual, ISA/Dual (with single interrupt line) models are
  22.  *   - supported
  23.  *  3.3.0 Thu Feb 24 21:30:28 NOVT 2000 
  24.  *        - PCI cards support
  25.  *  3.2.0 Mon Dec 13 22:26:53 NOVT 1999
  26.  *    - Completely rebuilt all the packet storage system
  27.  *    -    to work in Ethernet-like style.
  28.  *  3.1.1 just fixed some bugs (5 aug 1999)
  29.  *  3.1.0 added balancing feature (26 apr 1999)
  30.  *  3.0.1 just fixed some bugs (14 apr 1999).
  31.  *  3.0.0 Initial Revision, Yaroslav Polyakov (24 Feb 1999)
  32.  *        - added pre-calculation for CRC, fixed bug with "len-2" frames, 
  33.  *        - removed outbound fragmentation (MTU=1000), written CRC-calculation 
  34.  *        - on asm, added work with hard_headers and now we have our own cache 
  35.  *        - for them, optionally supported word-interchange on some chipsets,
  36.  * 
  37.  * Known problem: this driver wasn't tested on multiprocessor machine.
  38.  */
  40. #include <linux/module.h>
  41. #include <linux/kernel.h>
  42. #include <linux/sched.h>
  43. #include <linux/ptrace.h>
  44. #include <linux/fcntl.h>
  45. #include <linux/ioport.h>
  46. #include <linux/interrupt.h>
  47. #include <linux/slab.h>
  48. #include <linux/string.h>
  49. #include <linux/errno.h>
  51. #include <asm/io.h>
  52. #include <asm/types.h>
  53. #include <asm/byteorder.h>
  54. #include <asm/irq.h>
  55. #include <asm/uaccess.h>
  58. #include <linux/netdevice.h>
  59. #include <linux/etherdevice.h>
  60. #include <linux/skbuff.h>
  61. #include <linux/timer.h>
  62. #include <linux/init.h>
  64. #include <net/arp.h>
  65. #include <linux/pci.h>
  67. #include <linux/config.h>
  68. #include "sbni.h"
  71. /* device private data */
  73. struct net_local {
  74. struct net_device_stats stats;
  75. struct timer_list watchdog;
  77. spinlock_t lock;
  78. struct sk_buff  *rx_buf_p; /* receive buffer ptr */
  79. struct sk_buff  *tx_buf_p; /* transmit buffer ptr */
  81. unsigned int framelen; /* current frame length */
  82. unsigned int maxframe; /* maximum valid frame length */
  83. unsigned int state;
  84. unsigned int inppos, outpos; /* positions in rx/tx buffers */
  86. /* transmitting frame number - from frames qty to 1 */
  87. unsigned int tx_frameno;
  89. /* expected number of next receiving frame */
  90. unsigned int wait_frameno;
  92. /* count of failed attempts to frame send - 32 attempts do before
  93.    error - while receiver tunes on opposite side of wire */
  94. unsigned int trans_errors;
  96. /* idle time; send pong when limit exceeded */
  97. unsigned int timer_ticks;
  99. /* fields used for receive level autoselection */
  100. int delta_rxl;
  101. unsigned int cur_rxl_index, timeout_rxl;
  102. unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
  104. struct sbni_csr1 csr1; /* current value of CSR1 */
  105. struct sbni_in_stats in_stats;  /* internal statistics */ 
  107. struct net_device *second; /* for ISA/dual cards */
  109. #ifdef CONFIG_SBNI_MULTILINE
  110. struct net_device *master;
  111. struct net_device *link;
  112. #endif
  113. };
  116. static int  sbni_card_probe( unsigned long );
  117. static int  sbni_pci_probe( struct net_device  * );
  118. static struct net_device  *sbni_probe1(struct net_device *, unsigned long, int);
  119. static int  sbni_open( struct net_device * );
  120. static int  sbni_close( struct net_device * );
  121. static int  sbni_start_xmit( struct sk_buff *, struct net_device * );
  122. static int  sbni_ioctl( struct net_device *, struct ifreq *, int );
  123. static struct net_device_stats  *sbni_get_stats( struct net_device * );
  124. static void  set_multicast_list( struct net_device * );
  126. static void  sbni_interrupt( int, void *, struct pt_regs * );
  127. static void  handle_channel( struct net_device * );
  128. static int   recv_frame( struct net_device * );
  129. static void  send_frame( struct net_device * );
  130. static int   upload_data( struct net_device *,
  131.   unsigned, unsigned, unsigned, u32 );
  132. static void  download_data( struct net_device *, u32 * );
  133. static void  sbni_watchdog( unsigned long );
  134. static void  interpret_ack( struct net_device *, unsigned );
  135. static int   append_frame_to_pkt( struct net_device *, unsigned, u32 );
  136. static void  indicate_pkt( struct net_device * );
  137. static void  card_start( struct net_device * );
  138. static void  prepare_to_send( struct sk_buff *, struct net_device * );
  139. static void  drop_xmit_queue( struct net_device * );
  140. static void  send_frame_header( struct net_device *, u32 * );
  141. static int   skip_tail( unsigned int, unsigned int, u32 );
  142. static int   check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
  143. static void  change_level( struct net_device * );
  144. static void  timeout_change_level( struct net_device * );
  145. static u32   calc_crc32( u32, u8 *, u32 );
  146. static struct sk_buff *  get_rx_buf( struct net_device * );
  148. #ifdef CONFIG_SBNI_MULTILINE
  149. static int  enslave( struct net_device *, struct net_device * );
  150. static int  emancipate( struct net_device * );
  151. #endif
  153. #ifdef __i386__
  154. #define ASM_CRC 1
  155. #endif
  157. static const char  version[] =
  158. "Granch SBNI12 driver ver 5.0.1  Jun 22 2001  Denis I.Timofeev.n";
  160. static int  skip_pci_probe __initdata = 0;
  161. static int  scandone __initdata = 0;
  162. static int  num __initdata = 0;
  164. static unsigned char  rxl_tab[];
  165. static u32  crc32tab[];
  167. /* A list of all installed devices, for removing the driver module. */
  168. static struct net_device  *sbni_cards[ SBNI_MAX_NUM_CARDS ];
  170. /* Lists of device's parameters */
  171. static u32 io[   SBNI_MAX_NUM_CARDS ] __initdata =
  172. { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
  173. static u32 irq[  SBNI_MAX_NUM_CARDS ] __initdata;
  174. static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
  175. static u32 rxl[  SBNI_MAX_NUM_CARDS ] __initdata =
  176. { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
  177. static u32 mac[  SBNI_MAX_NUM_CARDS ] __initdata;
  179. #ifndef MODULE
  180. typedef u32  iarr[];
  181. static iarr  *dest[5] = { &io, &irq, &baud, &rxl, &mac };
  182. #endif
  184. /* A zero-terminated list of I/O addresses to be probed on ISA bus */
  185. static unsigned int  netcard_portlist[ ] __initdata = { 
  186. 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
  187. 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
  188. 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
  189. 0 };
  192. /*
  193.  * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
  194.  * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
  195.  */
  197. static inline int __init
  198. sbni_isa_probe( struct net_device  *dev )
  199. {
  200. if( dev->base_addr > 0x1ff
  201.     &&  !check_region( dev->base_addr, SBNI_IO_EXTENT )
  202.     &&  sbni_probe1( dev, dev->base_addr, dev->irq ) )
  204. return  0;
  205. else {
  206. printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
  207. "is malfunctional!n", dev->base_addr );
  208. return  -ENODEV;
  209. }
  210. }
  213. int __init
  214. sbni_probe( struct net_device  *dev )
  215. {
  216. int  i;
  218. static unsigned  version_printed __initdata = 0;
  219. if( version_printed++ == 0 )
  220. printk( KERN_INFO "%s", version );
  222. if( !dev ) { /* simple sanity check */
  223. printk( KERN_ERR "sbni: NULL device!n" );
  224. return  -ENODEV;
  225. }
  227. SET_MODULE_OWNER( dev );
  229. if( dev->base_addr )
  230. return  sbni_isa_probe( dev );
  231. /* otherwise we have to perform search our adapter */
  233. if( io[ num ] != -1 )
  234. dev->base_addr = io[ num ],
  235. dev->irq = irq[ num ];
  236. else if( scandone  ||  io[ 0 ] != -1 )
  237. return  -ENODEV;
  239. /* if io[ num ] contains non-zero address, then that is on ISA bus */
  240. if( dev->base_addr )
  241. return  sbni_isa_probe( dev );
  243. /* ...otherwise - scan PCI first */
  244. if( !skip_pci_probe  &&  !sbni_pci_probe( dev ) )
  245. return  0;
  247. if( io[ num ] == -1 ) {
  248. /* Auto-scan will be stopped when first ISA card were found */
  249. scandone = 1;
  250. if( num > 0 )
  251. return  -ENODEV;
  252. }
  254. for( i = 0;  netcard_portlist[ i ];  ++i ) {
  255. int  ioaddr = netcard_portlist[ i ];
  256. if( !check_region( ioaddr, SBNI_IO_EXTENT )
  257.     &&  sbni_probe1( dev, ioaddr, 0 ))
  258. return 0;
  259. }
  261. return  -ENODEV;
  262. }
  265. int __init
  266. sbni_pci_probe( struct net_device  *dev )
  267. {
  268. struct pci_dev  *pdev = NULL;
  270. if( !pci_present( ) )
  271. return  -ENODEV;
  273. while( (pdev = pci_find_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
  274.        != NULL ) {
  275. int  pci_irq_line;
  276. unsigned long  pci_ioaddr;
  277. u16  subsys;
  279. if( pdev->vendor != SBNI_PCI_VENDOR
  280.     &&  pdev->device != SBNI_PCI_DEVICE )
  281. continue;
  283. pci_ioaddr = pci_resource_start( pdev, 0 );
  284. pci_irq_line = pdev->irq;
  286. /* Avoid already found cards from previous calls */
  287. if( check_region( pci_ioaddr, SBNI_IO_EXTENT ) ) {
  288. pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
  289. if( subsys != 2  || /* Dual adapter is present */
  290.     check_region( pci_ioaddr += 4, SBNI_IO_EXTENT ) )
  291. continue;
  292. }
  294. if( pci_irq_line <= 0  ||  pci_irq_line >= NR_IRQS )
  295. printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
  296. "this PCI card to IRQ %d, which is unlikely "
  297. "to work!.n"
  298. KERN_WARNING " You should use the PCI BIOS "
  299. "setup to assign a valid IRQ line.n",
  300. pci_irq_line );
  302. /* avoiding re-enable dual adapters */
  303. if( (pci_ioaddr & 7) == 0  &&  pci_enable_device( pdev ) )
  304. return  -EIO;
  305. if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) )
  306. return  0;
  307. }
  308. return  -ENODEV;
  309. }
  312. static struct net_device * __init
  313. sbni_probe1( struct net_device  *dev,  unsigned long  ioaddr,  int  irq )
  314. {
  315. struct net_local  *nl;
  317. if( !request_region( ioaddr, SBNI_IO_EXTENT, dev->name ) )
  318. return  0;
  320. if( sbni_card_probe( ioaddr ) ) {
  321. release_region( ioaddr, SBNI_IO_EXTENT );
  322. return  0;
  323. }
  325. outb( 0, ioaddr + CSR0 );
  327. if( irq < 2 ) {
  328. autoirq_setup( 5 );
  329. outb( EN_INT | TR_REQ, ioaddr + CSR0 );
  330. outb( PR_RES, ioaddr + CSR1 );
  331. irq = autoirq_report( 5 );
  332. outb( 0, ioaddr + CSR0 );
  334. if( !irq ) {
  335. printk( KERN_ERR "%s: can't detect device irq!n",
  336. dev->name );
  337. release_region( ioaddr, SBNI_IO_EXTENT );
  338. return  0;
  339. }
  340. } else if( irq == 2 )
  341. irq = 9;
  343. dev->irq = irq;
  344. dev->base_addr = ioaddr;
  346. /* Allocate dev->priv and fill in sbni-specific dev fields. */
  347. nl = (struct net_local *) kmalloc(sizeof(struct net_local), GFP_KERNEL);
  348. if( !nl ) {
  349. printk( KERN_ERR "%s: unable to get memory!n", dev->name );
  350. release_region( ioaddr, SBNI_IO_EXTENT );
  351. return  0;
  352. }
  354. dev->priv = nl;
  355. memset( nl, 0, sizeof(struct net_local) );
  356. spin_lock_init( &nl->lock );
  358. /* store MAC address (generate if that isn't known) */
  359. *(u16 *)dev->dev_addr = htons( 0x00ff );
  360. *(u32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
  361. ( (mac[num]  ?  mac[num]  :  (u32)((long)dev->priv)) & 0x00ffffff) );
  363. /* store link settings (speed, receive level ) */
  364. nl->maxframe  = DEFAULT_FRAME_LEN;
  365. nl->csr1.rate = baud[ num ];
  367. if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
  368. /* autotune rxl */
  369. nl->cur_rxl_index = DEF_RXL,
  370. nl->delta_rxl = DEF_RXL_DELTA;
  371. else
  372. nl->delta_rxl = 0;
  373. nl->csr1.rxl  = rxl_tab[ nl->cur_rxl_index ];
  374. if( inb( ioaddr + CSR0 ) & 0x01 )
  375. nl->state |= FL_SLOW_MODE;
  377. printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
  378. "MAC: 00:ff:01:%02x:%02x:%02xn", 
  379. dev->name, dev->base_addr, dev->irq,
  380. ((u8 *) dev->dev_addr) [3],
  381. ((u8 *) dev->dev_addr) [4],
  382. ((u8 *) dev->dev_addr) [5] );
  384. printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
  385. ( (nl->state & FL_SLOW_MODE)  ?  500000 : 2000000)
  386. / (1 << nl->csr1.rate) );
  388. if( nl->delta_rxl == 0 )
  389. printk( "0x%x (fixed)n", nl->cur_rxl_index ); 
  390. else
  391. printk( "(auto)n");
  393. #ifdef CONFIG_SBNI_MULTILINE
  394. nl->master = dev;
  395. nl->link   = NULL;
  396. #endif
  397.    
  398. dev->open = &sbni_open;
  399. dev->stop = &sbni_close;
  400. dev->hard_start_xmit = &sbni_start_xmit;
  401. dev->get_stats = &sbni_get_stats;
  402. dev->set_multicast_list = &set_multicast_list;
  403. dev->do_ioctl = &sbni_ioctl;
  404. ether_setup( dev );
  406. sbni_cards[ num++ ] = dev;
  407. return  dev;
  408. }
  410. /* -------------------------------------------------------------------------- */
  412. #ifdef CONFIG_SBNI_MULTILINE
  414. static int
  415. sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
  416. {
  417. struct net_device  *p;
  419. netif_stop_queue( dev );
  421. /* Looking for idle device in the list */
  422. for( p = dev;  p; ) {
  423. struct net_local  *nl = (struct net_local *) p->priv;
  424. spin_lock( &nl->lock );
  425. if( nl->tx_buf_p  ||  (nl->state & FL_LINE_DOWN) ) {
  426. p = nl->link;
  427. spin_unlock( &nl->lock );
  428. } else {
  429. /* Idle dev is found */
  430. prepare_to_send( skb, p );
  431. spin_unlock( &nl->lock );
  432. netif_start_queue( dev );
  433. return  0;
  434. }
  435. }
  437. return  1;
  438. }
  440. #else /* CONFIG_SBNI_MULTILINE */
  442. static int
  443. sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
  444. {
  445. struct net_local  *nl  = (struct net_local *) dev->priv;
  447. netif_stop_queue( dev );
  448. spin_lock( &nl->lock );
  450. prepare_to_send( skb, dev );
  452. spin_unlock( &nl->lock );
  453. return  0;
  454. }
  456. #endif /* CONFIG_SBNI_MULTILINE */
  458. /* -------------------------------------------------------------------------- */
  460. /* interrupt handler */
  462. /*
  463.  *  SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
  464.  * be looked as two independent single-channel devices. Every channel seems
  465.  * as Ethernet interface but interrupt handler must be common. Really, first
  466.  * channel ("master") driver only registers the handler. In its struct net_local
  467.  * it has got pointer to "slave" channel's struct net_local and handles that's
  468.  * interrupts too.
  469.  * dev of successfully attached ISA SBNI boards is linked to list.
  470.  * While next board driver is initialized, it scans this list. If one
  471.  * has found dev with same irq and ioaddr different by 4 then it assumes
  472.  * this board to be "master".
  473.  */ 
  475. static void
  476. sbni_interrupt( int  irq,  void  *dev_id,  struct pt_regs  *regs )
  477. {
  478. struct net_device   *dev = (struct net_device *) dev_id;
  479. struct net_local  *nl  = (struct net_local *) dev->priv;
  480. int repeat;
  482. spin_lock( &nl->lock );
  483. if( nl->second )
  484. spin_lock( &((struct net_local *) nl->second->priv)->lock );
  486. do {
  487. repeat = 0;
  488. if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
  489. handle_channel( dev ),
  490. repeat = 1;
  491. if( nl->second  &&  /* second channel present */
  492.     (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
  493. handle_channel( nl->second ),
  494. repeat = 1;
  495. } while( repeat );
  497. if( nl->second )
  498. spin_unlock( &((struct net_local *)nl->second->priv)->lock );
  499. spin_unlock( &nl->lock );
  500. }
  503. static void
  504. handle_channel( struct net_device  *dev )
  505. {
  506. struct net_local *nl    = (struct net_local *) dev->priv;
  507. unsigned long ioaddr = dev->base_addr;
  509. int  req_ans;
  510. unsigned char  csr0;
  512. #ifdef CONFIG_SBNI_MULTILINE
  513. /* Lock the master device because we going to change its local data */
  514. if( nl->state & FL_SLAVE )
  515. spin_lock( &((struct net_local *) nl->master->priv)->lock );
  516. #endif
  518. outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
  520. nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
  521. for(;;) {
  522. csr0 = inb( ioaddr + CSR0 );
  523. if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
  524. break;
  526. req_ans = !(nl->state & FL_PREV_OK);
  528. if( csr0 & RC_RDY )
  529. req_ans = recv_frame( dev );
  531. /*
  532.  * TR_RDY always equals 1 here because we have owned the marker,
  533.  * and we set TR_REQ when disabled interrupts
  534.  */
  535. csr0 = inb( ioaddr + CSR0 );
  536. if( !(csr0 & TR_RDY)  ||  (csr0 & RC_RDY) )
  537. printk( KERN_ERR "%s: internal error!n", dev->name );
  539. /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
  540. if( req_ans  ||  nl->tx_frameno != 0 )
  541. send_frame( dev );
  542. else
  543. /* send marker without any data */
  544. outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
  545. }
  547. outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
  549. #ifdef CONFIG_SBNI_MULTILINE
  550. if( nl->state & FL_SLAVE )
  551. spin_unlock( &((struct net_local *) nl->master->priv)->lock );
  552. #endif
  553. }
  556. /*
  557.  * Routine returns 1 if it need to acknoweledge received frame.
  558.  * Empty frame received without errors won't be acknoweledged.
  559.  */
  561. static int
  562. recv_frame( struct net_device  *dev )
  563. {
  564. struct net_local  *nl   = (struct net_local *) dev->priv;
  565. unsigned long  ioaddr = dev->base_addr;
  567. u32  crc = CRC32_INITIAL;
  569. unsigned  framelen, frameno, ack;
  570. unsigned  is_first, frame_ok;
  572. if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
  573. frame_ok = framelen > 4
  574. ?  upload_data( dev, framelen, frameno, is_first, crc )
  575. :  skip_tail( ioaddr, framelen, crc );
  576. if( frame_ok )
  577. interpret_ack( dev, ack );
  578. } else
  579. frame_ok = 0;
  581. outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
  582. if( frame_ok ) {
  583. nl->state |= FL_PREV_OK;
  584. if( framelen > 4 )
  585. nl->in_stats.all_rx_number++;
  586. } else
  587. nl->state &= ~FL_PREV_OK,
  588. change_level( dev ),
  589. nl->in_stats.all_rx_number++,
  590. nl->in_stats.bad_rx_number++;
  592. return  !frame_ok  ||  framelen > 4;
  593. }
  596. static void
  597. send_frame( struct net_device  *dev )
  598. {
  599. struct net_local  *nl    = (struct net_local *) dev->priv;
  601. u32  crc = CRC32_INITIAL;
  603. if( nl->state & FL_NEED_RESEND ) {
  605. /* if frame was sended but not ACK'ed - resend it */
  606. if( nl->trans_errors ) {
  607. --nl->trans_errors;
  608. if( nl->framelen != 0 )
  609. nl->in_stats.resend_tx_number++;
  610. } else {
  611. /* cannot xmit with many attempts */
  612. #ifdef CONFIG_SBNI_MULTILINE
  613. if( (nl->state & FL_SLAVE)  ||  nl->link )
  614. #endif
  615. nl->state |= FL_LINE_DOWN;
  616. drop_xmit_queue( dev );
  617. goto  do_send;
  618. }
  619. } else
  620. nl->trans_errors = TR_ERROR_COUNT;
  622. send_frame_header( dev, &crc );
  623. nl->state |= FL_NEED_RESEND;
  624. /*
  625.  * FL_NEED_RESEND will be cleared after ACK, but if empty
  626.  * frame sended then in prepare_to_send next frame
  627.  */
  630. if( nl->framelen ) {
  631. download_data( dev, &crc );
  632. nl->in_stats.all_tx_number++;
  633. nl->state |= FL_WAIT_ACK;
  634. }
  636. outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
  638. do_send:
  639. outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
  641. if( nl->tx_frameno )
  642. /* next frame exists - we request card to send it */
  643. outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
  644.       dev->base_addr + CSR0 );
  645. }
  648. /*
  649.  * Write the frame data into adapter's buffer memory, and calculate CRC.
  650.  * Do padding if necessary.
  651.  */
  653. static void
  654. download_data( struct net_device  *dev,  u32  *crc_p )
  655. {
  656. struct net_local  *nl    = (struct net_local *) dev->priv;
  657. struct sk_buff    *skb  = nl->tx_buf_p;
  659. unsigned  len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
  661. outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
  662. *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
  664. /* if packet too short we should write some more bytes to pad */
  665. for( len = nl->framelen - len;  len--; )
  666. outb( 0, dev->base_addr + DAT ),
  667. *crc_p = CRC32( 0, *crc_p );
  668. }
  671. static int
  672. upload_data( struct net_device  *dev,  unsigned  framelen,  unsigned  frameno,
  673.      unsigned  is_first,  u32  crc )
  674. {
  675. struct net_local  *nl = (struct net_local *) dev->priv;
  677. int  frame_ok;
  679. if( is_first )
  680. nl->wait_frameno = frameno,
  681. nl->inppos = 0;
  683. if( nl->wait_frameno == frameno ) {
  685. if( nl->inppos + framelen  <=  ETHER_MAX_LEN )
  686. frame_ok = append_frame_to_pkt( dev, framelen, crc );
  688. /*
  689.  * if CRC is right but framelen incorrect then transmitter
  690.  * error was occured... drop entire packet
  691.  */
  692. else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
  693.  != 0 )
  694. nl->wait_frameno = 0,
  695. nl->inppos = 0,
  696. #ifdef CONFIG_SBNI_MULTILINE
  697. ((struct net_local *) nl->master->priv)
  698. ->stats.rx_errors++,
  699. ((struct net_local *) nl->master->priv)
  700. ->stats.rx_missed_errors++;
  701. #else
  702. nl->stats.rx_errors++,
  703. nl->stats.rx_missed_errors++;
  704. #endif
  705. /* now skip all frames until is_first != 0 */
  706. } else
  707. frame_ok = skip_tail( dev->base_addr, framelen, crc );
  709. if( is_first  &&  !frame_ok )
  710. /*
  711.  * Frame has been broken, but we had already stored
  712.  * is_first... Drop entire packet.
  713.  */
  714. nl->wait_frameno = 0,
  715. #ifdef CONFIG_SBNI_MULTILINE
  716. ((struct net_local *) nl->master->priv)->stats.rx_errors++,
  717. ((struct net_local *) nl->master->priv)->stats.rx_crc_errors++;
  718. #else
  719. nl->stats.rx_errors++,
  720. nl->stats.rx_crc_errors++;
  721. #endif
  723. return  frame_ok;
  724. }
  727. static __inline void
  728. send_complete( struct net_local  *nl )
  729. {
  730. #ifdef CONFIG_SBNI_MULTILINE
  731. ((struct net_local *) nl->master->priv)->stats.tx_packets++;
  732. ((struct net_local *) nl->master->priv)->stats.tx_bytes
  733. += nl->tx_buf_p->len;
  734. #else
  735. nl->stats.tx_packets++;
  736. nl->stats.tx_bytes += nl->tx_buf_p->len;
  737. #endif
  738. dev_kfree_skb_irq( nl->tx_buf_p );
  740. nl->tx_buf_p = NULL;
  742. nl->outpos = 0;
  743. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  744. nl->framelen   = 0;
  745. }
  748. static void
  749. interpret_ack( struct net_device  *dev,  unsigned  ack )
  750. {
  751. struct net_local  *nl = (struct net_local *) dev->priv;
  753. if( ack == FRAME_SENT_OK ) {
  754. nl->state &= ~FL_NEED_RESEND;
  756. if( nl->state & FL_WAIT_ACK ) {
  757. nl->outpos += nl->framelen;
  759. if( --nl->tx_frameno )
  760. nl->framelen = min_t(unsigned int,
  761.    nl->maxframe,
  762.    nl->tx_buf_p->len - nl->outpos);
  763. else
  764. send_complete( nl ),
  765. #ifdef CONFIG_SBNI_MULTILINE
  766. netif_wake_queue( nl->master );
  767. #else
  768. netif_wake_queue( dev );
  769. #endif
  770. }
  771. }
  773. nl->state &= ~FL_WAIT_ACK;
  774. }
  777. /*
  778.  * Glue received frame with previous fragments of packet.
  779.  * Indicate packet when last frame would be accepted.
  780.  */
  782. static int
  783. append_frame_to_pkt( struct net_device  *dev,  unsigned  framelen,  u32  crc )
  784. {
  785. struct net_local  *nl = (struct net_local *) dev->priv;
  787. u8  *p;
  789. if( nl->inppos + framelen  >  ETHER_MAX_LEN )
  790. return  0;
  792. if( !nl->rx_buf_p  &&  !(nl->rx_buf_p = get_rx_buf( dev )) )
  793. return  0;
  795. p = nl->rx_buf_p->data + nl->inppos;
  796. insb( dev->base_addr + DAT, p, framelen );
  797. if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
  798. return  0;
  800. nl->inppos += framelen - 4;
  801. if( --nl->wait_frameno == 0 ) /* last frame received */
  802. indicate_pkt( dev );
  804. return  1;
  805. }
  808. /*
  809.  * Prepare to start output on adapter.
  810.  * Transmitter will be actually activated when marker is accepted.
  811.  */
  813. static void
  814. prepare_to_send( struct sk_buff  *skb,  struct net_device  *dev )
  815. {
  816. struct net_local  *nl = (struct net_local *) dev->priv;
  818. unsigned int  len;
  820. /* nl->tx_buf_p == NULL here! */
  821. if( nl->tx_buf_p )
  822. printk( KERN_ERR "%s: memory leak!n", dev->name );
  824. nl->outpos = 0;
  825. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  827. len = skb->len;
  828. if( len < SBNI_MIN_LEN )
  829. len = SBNI_MIN_LEN;
  831. nl->tx_buf_p = skb;
  832. nl->tx_frameno = (len + nl->maxframe - 1) / nl->maxframe;
  833. nl->framelen = len < nl->maxframe  ?  len  :  nl->maxframe;
  835. outb( inb( dev->base_addr + CSR0 ) | TR_REQ,  dev->base_addr + CSR0 );
  836. #ifdef CONFIG_SBNI_MULTILINE
  837. nl->master->trans_start = jiffies;
  838. #else
  839. dev->trans_start = jiffies;
  840. #endif
  841. }
  844. static void
  845. drop_xmit_queue( struct net_device  *dev )
  846. {
  847. struct net_local  *nl = (struct net_local *) dev->priv;
  849. if( nl->tx_buf_p )
  850. dev_kfree_skb_any( nl->tx_buf_p ),
  851. nl->tx_buf_p = NULL,
  852. #ifdef CONFIG_SBNI_MULTILINE
  853. ((struct net_local *) nl->master->priv)
  854. ->stats.tx_errors++,
  855. ((struct net_local *) nl->master->priv)
  856. ->stats.tx_carrier_errors++;
  857. #else
  858. nl->stats.tx_errors++,
  859. nl->stats.tx_carrier_errors++;
  860. #endif
  862. nl->tx_frameno = 0;
  863. nl->framelen = 0;
  864. nl->outpos = 0;
  865. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  866. #ifdef CONFIG_SBNI_MULTILINE
  867. netif_start_queue( nl->master );
  868. nl->master->trans_start = jiffies;
  869. #else
  870. netif_start_queue( dev );
  871. dev->trans_start = jiffies;
  872. #endif
  873. }
  876. static void
  877. send_frame_header( struct net_device  *dev,  u32  *crc_p )
  878. {
  879. struct net_local  *nl  = (struct net_local *) dev->priv;
  881. u32  crc = *crc_p;
  882. u32  len_field = nl->framelen + 6; /* CRC + frameno + reserved */
  883. u8   value;
  885. if( nl->state & FL_NEED_RESEND )
  886. len_field |= FRAME_RETRY; /* non-first attempt... */
  888. if( nl->outpos == 0 )
  889. len_field |= FRAME_FIRST;
  891. len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
  892. outb( SBNI_SIG, dev->base_addr + DAT );
  894. value = (u8) len_field;
  895. outb( value, dev->base_addr + DAT );
  896. crc = CRC32( value, crc );
  897. value = (u8) (len_field >> 8);
  898. outb( value, dev->base_addr + DAT );
  899. crc = CRC32( value, crc );
  901. outb( nl->tx_frameno, dev->base_addr + DAT );
  902. crc = CRC32( nl->tx_frameno, crc );
  903. outb( 0, dev->base_addr + DAT );
  904. crc = CRC32( 0, crc );
  905. *crc_p = crc;
  906. }
  909. /*
  910.  * if frame tail not needed (incorrect number or received twice),
  911.  * it won't store, but CRC will be calculated
  912.  */
  914. static int
  915. skip_tail( unsigned int  ioaddr,  unsigned int  tail_len,  u32 crc )
  916. {
  917. while( tail_len-- )
  918. crc = CRC32( inb( ioaddr + DAT ), crc );
  920. return  crc == CRC32_REMAINDER;
  921. }
  924. /*
  925.  * Preliminary checks if frame header is correct, calculates its CRC
  926.  * and split it to simple fields
  927.  */
  929. static int
  930. check_fhdr( u32  ioaddr,  u32  *framelen,  u32  *frameno,  u32  *ack,
  931.     u32  *is_first,  u32  *crc_p )
  932. {
  933. u32  crc = *crc_p;
  934. u8   value;
  936. if( inb( ioaddr + DAT ) != SBNI_SIG )
  937. return  0;
  939. value = inb( ioaddr + DAT );
  940. *framelen = (u32)value;
  941. crc = CRC32( value, crc );
  942. value = inb( ioaddr + DAT );
  943. *framelen |= ((u32)value) << 8;
  944. crc = CRC32( value, crc );
  946. *ack = *framelen & FRAME_ACK_MASK;
  947. *is_first = (*framelen & FRAME_FIRST) != 0;
  949. if( (*framelen &= FRAME_LEN_MASK) < 6
  950.     ||  *framelen > SBNI_MAX_FRAME - 3 )
  951. return  0;
  953. value = inb( ioaddr + DAT );
  954. *frameno = (u32)value;
  955. crc = CRC32( value, crc );
  957. crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
  958. *framelen -= 2;
  960. *crc_p = crc;
  961. return  1;
  962. }
  965. static struct sk_buff *
  966. get_rx_buf( struct net_device  *dev )
  967. {
  968. /* +2 is to compensate for the alignment fixup below */
  969. struct sk_buff  *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
  970. if( !skb )
  971. return  NULL;
  973. #ifdef CONFIG_SBNI_MULTILINE
  974. skb->dev = ((struct net_local *) dev->priv)->master;
  975. #else
  976. skb->dev = dev;
  977. #endif
  978. skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
  979. return  skb;
  980. }
  983. static void
  984. indicate_pkt( struct net_device  *dev )
  985. {
  986. struct net_local  *nl  = (struct net_local *) dev->priv;
  987. struct sk_buff    *skb = nl->rx_buf_p;
  989. skb_put( skb, nl->inppos );
  991. #ifdef CONFIG_SBNI_MULTILINE
  992. skb->protocol = eth_type_trans( skb, nl->master );
  993. netif_rx( skb );
  994. dev->last_rx = jiffies;
  995. ++((struct net_local *) nl->master->priv)->stats.rx_packets;
  996. ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
  997. #else
  998. skb->protocol = eth_type_trans( skb, dev );
  999. netif_rx( skb );
  1000. dev->last_rx = jiffies;
  1001. ++nl->stats.rx_packets;
  1002. nl->stats.rx_bytes += nl->inppos;
  1003. #endif
  1004. nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
  1005. }
  1008. /* -------------------------------------------------------------------------- */
  1010. /*
  1011.  * Routine checks periodically wire activity and regenerates marker if
  1012.  * connect was inactive for a long time.
  1013.  */
  1015. static void
  1016. sbni_watchdog( unsigned long  arg )
  1017. {
  1018. struct net_device  *dev = (struct net_device *) arg;
  1019. struct net_local   *nl  = (struct net_local *) dev->priv;
  1020. struct timer_list  *w   = &nl->watchdog; 
  1021. unsigned long    flags;
  1022. unsigned char    csr0;
  1024. spin_lock_irqsave( &nl->lock, flags );
  1026. csr0 = inb( dev->base_addr + CSR0 );
  1027. if( csr0 & RC_CHK ) {
  1029. if( nl->timer_ticks ) {
  1030. if( csr0 & (RC_RDY | BU_EMP) )
  1031. /* receiving not active */
  1032. nl->timer_ticks--;
  1033. } else {
  1034. nl->in_stats.timeout_number++;
  1035. if( nl->delta_rxl )
  1036. timeout_change_level( dev );
  1038. outb( *(u_char *)&nl->csr1 | PR_RES,
  1039.       dev->base_addr + CSR1 );
  1040. csr0 = inb( dev->base_addr + CSR0 );
  1041. }
  1042. } else
  1043. nl->state &= ~FL_LINE_DOWN;
  1045. outb( csr0 | RC_CHK, dev->base_addr + CSR0 ); 
  1047. init_timer( w );
  1048. w->expires = jiffies + SBNI_TIMEOUT;
  1049. w->data = arg;
  1050. w->function = sbni_watchdog;
  1051. add_timer( w );
  1053. spin_unlock_irqrestore( &nl->lock, flags );
  1054. }
  1057. static unsigned char  rxl_tab[] = {
  1058. 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
  1059. 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
  1060. };
  1062. #define SIZE_OF_TIMEOUT_RXL_TAB 4
  1063. static unsigned char  timeout_rxl_tab[] = {
  1064. 0x03, 0x05, 0x08, 0x0b
  1065. };
  1067. /* -------------------------------------------------------------------------- */
  1069. static void
  1070. card_start( struct net_device  *dev )
  1071. {
  1072. struct net_local  *nl = (struct net_local *) dev->priv;
  1074. nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
  1075. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  1076. nl->state |= FL_PREV_OK;
  1078. nl->inppos = nl->outpos = 0;
  1079. nl->wait_frameno = 0;
  1080. nl->tx_frameno  = 0;
  1081. nl->framelen  = 0;
  1083. outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
  1084. outb( EN_INT, dev->base_addr + CSR0 );
  1085. }
  1087. /* -------------------------------------------------------------------------- */
  1089. /* Receive level auto-selection */
  1091. static void
  1092. change_level( struct net_device  *dev )
  1093. {
  1094. struct net_local  *nl = (struct net_local *) dev->priv;
  1096. if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
  1097. return;
  1099. if( nl->cur_rxl_index == 0 )
  1100. nl->delta_rxl = 1;
  1101. else if( nl->cur_rxl_index == 15 )
  1102. nl->delta_rxl = -1;
  1103. else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
  1104. nl->delta_rxl = -nl->delta_rxl;
  1106. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
  1107. inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
  1108. outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
  1110. nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
  1111. nl->cur_rxl_rcvd  = 0;
  1112. }
  1115. static void
  1116. timeout_change_level( struct net_device  *dev )
  1117. {
  1118. struct net_local  *nl = (struct net_local *) dev->priv;
  1120. nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
  1121. if( ++nl->timeout_rxl >= 4 )
  1122. nl->timeout_rxl = 0;
  1124. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
  1125. inb( dev->base_addr + CSR0 );
  1126. outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
  1128. nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
  1129. nl->cur_rxl_rcvd  = 0;
  1130. }
  1132. /* -------------------------------------------------------------------------- */
  1134. /*
  1135.  * Open/initialize the board. 
  1136.  */
  1138. static int
  1139. sbni_open( struct net_device  *dev )
  1140. {
  1141. struct net_local *nl = (struct net_local *) dev->priv;
  1142. struct timer_list *w  = &nl->watchdog;
  1144. /*
  1145.  * For double ISA adapters within "common irq" mode, we have to
  1146.  * determine whether primary or secondary channel is initialized,
  1147.  * and set the irq handler only in first case.
  1148.  */
  1149. if( dev->base_addr < 0x400 ) { /* ISA only */
  1150. struct net_device  **p = sbni_cards;
  1151. for( ;  *p  &&  p < sbni_cards + SBNI_MAX_NUM_CARDS;  ++p )
  1152. if( (*p)->irq == dev->irq
  1153.     &&  ((*p)->base_addr == dev->base_addr + 4
  1154.  ||  (*p)->base_addr == dev->base_addr - 4)
  1155.     &&  (*p)->flags & IFF_UP ) {
  1157. ((struct net_local *) ((*p)->priv))
  1158. ->second = dev;
  1159. printk( KERN_NOTICE "%s: using shared irq "
  1160. "with %sn", dev->name, (*p)->name );
  1161. nl->state |= FL_SECONDARY;
  1162. goto  handler_attached;
  1163. }
  1164. }
  1166. if( request_irq(dev->irq, sbni_interrupt, SA_SHIRQ, dev->name, dev) ) {
  1167. printk( KERN_ERR "%s: unable to get IRQ %d.n",
  1168. dev->name, dev->irq );
  1169. return  -EAGAIN;
  1170. }
  1172. handler_attached:
  1174. spin_lock( &nl->lock );
  1175. memset( &nl->stats, 0, sizeof(struct net_device_stats) );
  1176. memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
  1178. card_start( dev );
  1180. netif_start_queue( dev );
  1182. /* set timer watchdog */
  1183. init_timer( w );
  1184. w->expires = jiffies + SBNI_TIMEOUT;
  1185. w->data = (unsigned long) dev;
  1186. w->function = sbni_watchdog;
  1187. add_timer( w );
  1188.    
  1189. spin_unlock( &nl->lock );
  1190. return 0;
  1191. }
  1194. static int
  1195. sbni_close( struct net_device  *dev )
  1196. {
  1197. struct net_local  *nl = (struct net_local *) dev->priv;
  1199. if( nl->second  &&  nl->second->flags & IFF_UP ) {
  1200. printk( KERN_NOTICE "Secondary channel (%s) is active!n",
  1201. nl->second->name );
  1202. return  -EBUSY;
  1203. }
  1205. #ifdef CONFIG_SBNI_MULTILINE
  1206. if( nl->state & FL_SLAVE )
  1207. emancipate( dev );
  1208. else
  1209. while( nl->link ) /* it's master device! */
  1210. emancipate( nl->link );
  1211. #endif
  1213. spin_lock( &nl->lock );
  1215. nl->second = NULL;
  1216. drop_xmit_queue( dev );
  1217. netif_stop_queue( dev );
  1218.    
  1219. del_timer( &nl->watchdog );
  1221. outb( 0, dev->base_addr + CSR0 );
  1223. if( !(nl->state & FL_SECONDARY) )
  1224. free_irq( dev->irq, dev );
  1225. nl->state &= FL_SECONDARY;
  1227. spin_unlock( &nl->lock );
  1228. return 0;
  1229. }
  1232. /*
  1233. Valid combinations in CSR0 (for probing):
  1235. VALID_DECODER 0000,0011,1011,1010
  1237.      ; 0   ; -
  1238. TR_REQ ; 1   ; +
  1239. TR_RDY      ; 2   ; -
  1240. TR_RDY TR_REQ ; 3   ; +
  1241. BU_EMP      ; 4   ; +
  1242. BU_EMP       TR_REQ ; 5   ; +
  1243. BU_EMP TR_RDY      ; 6   ; -
  1244. BU_EMP TR_RDY TR_REQ ; 7   ; +
  1245. RC_RDY        ; 8   ; +
  1246. RC_RDY TR_REQ ; 9   ; +
  1247. RC_RDY TR_RDY ; 10  ; -
  1248. RC_RDY TR_RDY TR_REQ ; 11  ; -
  1249. RC_RDY BU_EMP ; 12  ; -
  1250. RC_RDY BU_EMP TR_REQ ; 13  ; -
  1251. RC_RDY BU_EMP TR_RDY ; 14  ; -
  1252. RC_RDY BU_EMP TR_RDY TR_REQ ; 15  ; -
  1253. */
  1255. #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
  1258. static int
  1259. sbni_card_probe( unsigned long  ioaddr )
  1260. {
  1261. unsigned char  csr0;
  1263. csr0 = inb( ioaddr + CSR0 );
  1264. if( csr0 != 0xff  &&  csr0 != 0x00 ) {
  1265. csr0 &= ~EN_INT;
  1266. if( csr0 & BU_EMP )
  1267. csr0 |= EN_INT;
  1268.       
  1269. if( VALID_DECODER & (1 << (csr0 >> 4)) )
  1270. return  0;
  1271. }
  1272.    
  1273. return  -ENODEV;
  1274. }
  1276. /* -------------------------------------------------------------------------- */
  1278. static int
  1279. sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
  1280. {
  1281. struct net_local  *nl = (struct net_local *) dev->priv; 
  1282. struct sbni_flags  flags;
  1283. int  error = 0;
  1285. #ifdef CONFIG_SBNI_MULTILINE
  1286. struct net_device  *slave_dev;
  1287. char  slave_name[ 8 ];
  1288. #endif
  1289.   
  1290. switch( cmd ) {
  1291. case  SIOCDEVGETINSTATS :
  1292. error = verify_area( VERIFY_WRITE, ifr->ifr_data,
  1293.      sizeof(struct sbni_in_stats) );
  1294. if( !error )
  1295. copy_to_user( ifr->ifr_data, &nl->in_stats,
  1296.       sizeof(struct sbni_in_stats) );
  1297. break;
  1299. case  SIOCDEVRESINSTATS :
  1300. if( current->euid != 0 ) /* root only */
  1301. return  -EPERM;
  1302. memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
  1303. break;
  1305. case  SIOCDEVGHWSTATE :
  1306. flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
  1307. flags.rate = nl->csr1.rate;
  1308. flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
  1309. flags.rxl = nl->cur_rxl_index;
  1310. flags.fixed_rxl = nl->delta_rxl == 0;
  1312. error = verify_area( VERIFY_WRITE, ifr->ifr_data,
  1313.      sizeof flags );
  1314. if( !error )
  1315. copy_to_user( ifr->ifr_data, &flags, sizeof flags );
  1316. break;
  1318. case  SIOCDEVSHWSTATE :
  1319. if( current->euid != 0 ) /* root only */
  1320. return  -EPERM;
  1322. spin_lock( &nl->lock );
  1323. flags = *(struct sbni_flags*) &ifr->ifr_data;
  1324. if( flags.fixed_rxl )
  1325. nl->delta_rxl = 0,
  1326. nl->cur_rxl_index = flags.rxl;
  1327. else
  1328. nl->delta_rxl = DEF_RXL_DELTA,
  1329. nl->cur_rxl_index = DEF_RXL;
  1331. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
  1332. nl->csr1.rate = flags.rate;
  1333. outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
  1334. spin_unlock( &nl->lock );
  1335. break;
  1337. #ifdef CONFIG_SBNI_MULTILINE
  1339. case  SIOCDEVENSLAVE :
  1340. if( current->euid != 0 ) /* root only */
  1341. return  -EPERM;
  1343. if( (error = verify_area( VERIFY_READ, ifr->ifr_data,
  1344.   sizeof slave_name )) != 0 )
  1345. return  error;
  1347. copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name );
  1348. slave_dev = dev_get_by_name( slave_name );
  1349. if( !slave_dev  ||  !(slave_dev->flags & IFF_UP) ) {
  1350. printk( KERN_ERR "%s: trying to enslave non-active "
  1351. "device %sn", dev->name, slave_name );
  1352. return  -EPERM;
  1353. }
  1355. return  enslave( dev, slave_dev );
  1357. case  SIOCDEVEMANSIPATE :
  1358. if( current->euid != 0 ) /* root only */
  1359. return  -EPERM;
  1361. return  emancipate( dev );
  1363. #endif /* CONFIG_SBNI_MULTILINE */
  1365. default :
  1366. return  -EOPNOTSUPP;
  1367. }
  1369. return  error;
  1370. }
  1373. #ifdef CONFIG_SBNI_MULTILINE
  1375. static int
  1376. enslave( struct net_device  *dev,  struct net_device  *slave_dev )
  1377. {
  1378. struct net_local  *nl  = (struct net_local *) dev->priv;
  1379. struct net_local  *snl = (struct net_local *) slave_dev->priv;
  1381. if( nl->state & FL_SLAVE ) /* This isn't master or free device */
  1382. return  -EBUSY;
  1384. if( snl->state & FL_SLAVE ) /* That was already enslaved */
  1385. return  -EBUSY;
  1387. spin_lock( &nl->lock );
  1388. spin_lock( &snl->lock );
  1390. /* append to list */
  1391. snl->link = nl->link;
  1392. nl->link  = slave_dev;
  1393. snl->master = dev;
  1394. snl->state |= FL_SLAVE;
  1396. /* Summary statistics of MultiLine operation will be stored
  1397.    in master's counters */
  1398. memset( &snl->stats, 0, sizeof(struct net_device_stats) );
  1399. netif_stop_queue( slave_dev );
  1400. netif_wake_queue( dev ); /* Now we are able to transmit */
  1402. spin_unlock( &snl->lock );
  1403. spin_unlock( &nl->lock );
  1404. printk( KERN_NOTICE "%s: slave device (%s) attached.n",
  1405. dev->name, slave_dev->name );
  1406. return  0;
  1407. }
  1410. static int
  1411. emancipate( struct net_device  *dev )
  1412. {
  1413. struct net_local   *snl = (struct net_local *) dev->priv;
  1414. struct net_device  *p   = snl->master;
  1415. struct net_local   *nl  = (struct net_local *) p->priv;
  1417. if( !(snl->state & FL_SLAVE) )
  1418. return  -EINVAL;
  1420. spin_lock( &nl->lock );
  1421. spin_lock( &snl->lock );
  1422. drop_xmit_queue( dev );
  1424. /* exclude from list */
  1425. for(;;) { /* must be in list */
  1426. struct net_local  *t = (struct net_local *) p->priv;
  1427. if( t->link == dev ) {
  1428. t->link = snl->link;
  1429. break;
  1430. }
  1431. p = t->link;
  1432. }
  1434. snl->link = NULL;
  1435. snl->master = dev;
  1436. snl->state &= ~FL_SLAVE;
  1438. netif_start_queue( dev );
  1440. spin_unlock( &snl->lock );
  1441. spin_unlock( &nl->lock );
  1443. dev_put( dev );
  1444. return  0;
  1445. }
  1447. #endif
  1450. static struct net_device_stats *
  1451. sbni_get_stats( struct net_device  *dev )
  1452. {
  1453. return  &((struct net_local *) dev->priv)->stats;
  1454. }
  1457. static void
  1458. set_multicast_list( struct net_device  *dev )
  1459. {
  1460. return; /* sbni always operate in promiscuos mode */
  1461. }
  1464. #ifdef MODULE
  1466. MODULE_PARM( io, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1467. MODULE_PARM( irq, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1468. MODULE_PARM( baud, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1469. MODULE_PARM( rxl, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1470. MODULE_PARM( mac, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1472. MODULE_PARM( skip_pci_probe, "i" );
  1474. MODULE_LICENSE("GPL");
  1477. int
  1478. init_module( void )
  1479. {
  1480. struct net_device  *dev;
  1482. while( num < SBNI_MAX_NUM_CARDS ) {
  1483. if( !(dev = kmalloc(sizeof(struct net_device), GFP_KERNEL)) ){
  1484. printk( KERN_ERR "sbni: unable to allocate device!n" );
  1485. return  -ENOMEM;
  1486. }
  1488. memset( dev, 0, sizeof(struct net_device) );
  1489. sprintf( dev->name, "sbni%d", num );
  1491. dev->init = sbni_probe;
  1492. if( register_netdev( dev ) ) {
  1493. kfree( dev );
  1494. break;
  1495. }
  1496. }
  1498. return  *sbni_cards  ?  0  :  -ENODEV;
  1499. }
  1501. void
  1502. cleanup_module( void )
  1503. {
  1504. struct net_device  *dev;
  1505. int  num;
  1507. /* No need to check MOD_IN_USE, as sys_delete_module( ) checks. */
  1508. for( num = 0;  num < SBNI_MAX_NUM_CARDS;  ++num )
  1509. if( (dev = sbni_cards[ num ]) != NULL ) {
  1510. unregister_netdev( dev );
  1511. release_region( dev->base_addr, SBNI_IO_EXTENT );
  1512. kfree( dev->priv );
  1513. kfree( dev );
  1514. }
  1515. }
  1517. #else /* MODULE */
  1519. static int __init
  1520. sbni_setup( char  *p )
  1521. {
  1522. int  n, parm;
  1524. if( *p++ != '(' )
  1525. goto  bad_param;
  1527. for( n = 0, parm = 0;  *p  &&  n < 8; ) {
  1528. (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
  1529. if( !*p  ||  *p == ')' )
  1530. return 1;
  1531. if( *p == ';' )
  1532. ++p, ++n, parm = 0;
  1533. else if( *p++ != ',' )
  1534. break;
  1535. else
  1536. if( ++parm >= 5 )
  1537. break;
  1538. }
  1539. bad_param:
  1540. printk( KERN_ERR "Error in sbni kernel parameter!n" );
  1541. return 0;
  1542. }
  1544. __setup( "sbni=", sbni_setup );
  1546. #endif /* MODULE */
  1548. /* -------------------------------------------------------------------------- */
  1550. #ifdef ASM_CRC
  1552. static u32
  1553. calc_crc32( u32  crc,  u8  *p,  u32  len )
  1554. {
  1555. register u32  _crc __asm ( "ax" );
  1556. _crc = crc;
  1558. __asm __volatile (
  1559. "xorl %%ebx, %%ebxn"
  1560. "movl %1, %%esin" 
  1561. "movl %2, %%ecxn" 
  1562. "movl $crc32tab, %%edin"
  1563. "shrl $2, %%ecxn"
  1564. "jz 1fn"
  1566. ".align 4n"
  1567. "0:n"
  1568. "movb %%al, %%bln"
  1569. "movl (%%esi), %%edxn"
  1570. "shrl $8, %%eaxn"
  1571. "xorb %%dl, %%bln"
  1572. "shrl $8, %%edxn"
  1573. "xorl (%%edi,%%ebx,4), %%eaxn"
  1575. "movb %%al, %%bln"
  1576. "shrl $8, %%eaxn"
  1577. "xorb %%dl, %%bln"
  1578. "shrl $8, %%edxn"
  1579. "xorl (%%edi,%%ebx,4), %%eaxn"
  1581. "movb %%al, %%bln"
  1582. "shrl $8, %%eaxn"
  1583. "xorb %%dl, %%bln"
  1584. "movb %%dh, %%dln" 
  1585. "xorl (%%edi,%%ebx,4), %%eaxn"
  1587. "movb %%al, %%bln"
  1588. "shrl $8, %%eaxn"
  1589. "xorb %%dl, %%bln"
  1590. "addl $4, %%esin"
  1591. "xorl (%%edi,%%ebx,4), %%eaxn"
  1593. "decl %%ecxn"
  1594. "jnz 0bn"
  1596. "1:n"
  1597. "movl %2, %%ecxn"
  1598. "andl $3, %%ecxn"
  1599. "jz 2fn"
  1601. "movb %%al, %%bln"
  1602. "shrl $8, %%eaxn"
  1603. "xorb (%%esi), %%bln"
  1604. "xorl (%%edi,%%ebx,4), %%eaxn"
  1606. "decl %%ecxn"
  1607. "jz 2fn"
  1609. "movb %%al, %%bln"
  1610. "shrl $8, %%eaxn"
  1611. "xorb 1(%%esi), %%bln"
  1612. "xorl (%%edi,%%ebx,4), %%eaxn"
  1614. "decl %%ecxn"
  1615. "jz 2fn"
  1617. "movb %%al, %%bln"
  1618. "shrl $8, %%eaxn"
  1619. "xorb 2(%%esi), %%bln"
  1620. "xorl (%%edi,%%ebx,4), %%eaxn"
  1621. "2:n"
  1622. :
  1623. : "a" (_crc), "g" (p), "g" (len)
  1624. : "ax", "bx", "cx", "dx", "si", "di"
  1625. );
  1627. return  _crc;
  1628. }
  1630. #else /* ASM_CRC */
  1632. static u32
  1633. calc_crc32( u32  crc,  u8  *p,  u32  len )
  1634. {
  1635. while( len-- )
  1636. crc = CRC32( *p++, crc );
  1638. return  crc;
  1639. }
  1641. #endif /* ASM_CRC */
  1644. static u32  crc32tab[] __attribute__ ((aligned(8))) = {
  1645. 0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
  1646. 0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
  1647. 0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
  1648. 0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
  1649. 0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
  1650. 0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
  1651. 0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
  1652. 0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
  1653. 0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
  1654. 0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
  1655. 0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
  1656. 0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
  1657. 0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
  1658. 0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
  1659. 0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
  1660. 0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
  1661. 0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
  1662. 0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
  1663. 0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
  1664. 0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
  1665. 0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
  1666. 0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
  1667. 0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
  1668. 0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
  1669. 0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
  1670. 0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
  1671. 0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
  1672. 0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
  1673. 0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
  1674. 0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
  1675. 0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
  1676. 0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
  1677. 0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
  1678. 0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
  1679. 0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
  1680. 0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
  1681. 0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
  1682. 0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
  1683. 0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
  1684. 0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
  1685. 0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
  1686. 0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
  1687. 0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
  1688. 0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
  1689. 0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
  1690. 0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
  1691. 0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
  1692. 0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
  1693. 0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
  1694. 0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
  1695. 0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
  1696. 0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
  1697. 0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
  1698. 0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
  1699. 0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
  1700. 0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
  1701. 0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
  1702. 0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
  1703. 0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
  1704. 0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
  1705. 0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
  1706. 0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
  1707. 0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
  1708. 0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
  1709. };