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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sbni.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：43k
源码类别：

嵌入式Linux

开发平台：

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>
  68. #ifndef MODULE
  69. #include <linux/string.h>
  70. #endif
  72. #include <linux/config.h>
  73. #include "sbni.h"
  76. /* device private data */
  78. struct net_local {
  79. struct net_device_stats stats;
  80. struct timer_list watchdog;
  82. spinlock_t lock;
  83. struct sk_buff  *rx_buf_p; /* receive buffer ptr */
  84. struct sk_buff  *tx_buf_p; /* transmit buffer ptr */
  86. unsigned int framelen; /* current frame length */
  87. unsigned int maxframe; /* maximum valid frame length */
  88. unsigned int state;
  89. unsigned int inppos, outpos; /* positions in rx/tx buffers */
  91. /* transmitting frame number - from frames qty to 1 */
  92. unsigned int tx_frameno;
  94. /* expected number of next receiving frame */
  95. unsigned int wait_frameno;
  97. /* count of failed attempts to frame send - 32 attempts do before
  98.    error - while receiver tunes on opposite side of wire */
  99. unsigned int trans_errors;
  101. /* idle time; send pong when limit exceeded */
  102. unsigned int timer_ticks;
  104. /* fields used for receive level autoselection */
  105. int delta_rxl;
  106. unsigned int cur_rxl_index, timeout_rxl;
  107. unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
  109. struct sbni_csr1 csr1; /* current value of CSR1 */
  110. struct sbni_in_stats in_stats;  /* internal statistics */ 
  112. struct net_device *second; /* for ISA/dual cards */
  114. #ifdef CONFIG_SBNI_MULTILINE
  115. struct net_device *master;
  116. struct net_device *link;
  117. #endif
  118. };
  121. static int  sbni_card_probe( unsigned long );
  122. static int  sbni_pci_probe( struct net_device  * );
  123. static struct net_device  *sbni_probe1(struct net_device *, unsigned long, int);
  124. static int  sbni_open( struct net_device * );
  125. static int  sbni_close( struct net_device * );
  126. static int  sbni_start_xmit( struct sk_buff *, struct net_device * );
  127. static int  sbni_ioctl( struct net_device *, struct ifreq *, int );
  128. static struct net_device_stats  *sbni_get_stats( struct net_device * );
  129. static void  set_multicast_list( struct net_device * );
  131. static void  sbni_interrupt( int, void *, struct pt_regs * );
  132. static void  handle_channel( struct net_device * );
  133. static int   recv_frame( struct net_device * );
  134. static void  send_frame( struct net_device * );
  135. static int   upload_data( struct net_device *,
  136.   unsigned, unsigned, unsigned, u32 );
  137. static void  download_data( struct net_device *, u32 * );
  138. static void  sbni_watchdog( unsigned long );
  139. static void  interpret_ack( struct net_device *, unsigned );
  140. static int   append_frame_to_pkt( struct net_device *, unsigned, u32 );
  141. static void  indicate_pkt( struct net_device * );
  142. static void  card_start( struct net_device * );
  143. static void  prepare_to_send( struct sk_buff *, struct net_device * );
  144. static void  drop_xmit_queue( struct net_device * );
  145. static void  send_frame_header( struct net_device *, u32 * );
  146. static int   skip_tail( unsigned int, unsigned int, u32 );
  147. static int   check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
  148. static void  change_level( struct net_device * );
  149. static void  timeout_change_level( struct net_device * );
  150. static u32   calc_crc32( u32, u8 *, u32 );
  151. static struct sk_buff *  get_rx_buf( struct net_device * );
  153. #ifdef CONFIG_SBNI_MULTILINE
  154. static int  enslave( struct net_device *, struct net_device * );
  155. static int  emancipate( struct net_device * );
  156. #endif
  158. #ifdef __i386__
  159. #define ASM_CRC 1
  160. #endif
  162. static const char  version[] =
  163. "Granch SBNI12 driver ver 5.0.1  Jun 22 2001  Denis I.Timofeev.n";
  165. static int  skip_pci_probe __initdata = 0;
  166. static int  scandone __initdata = 0;
  167. static int  num __initdata = 0;
  169. static unsigned char  rxl_tab[];
  170. static u32  crc32tab[];
  172. /* A list of all installed devices, for removing the driver module. */
  173. static struct net_device  *sbni_cards[ SBNI_MAX_NUM_CARDS ];
  175. /* Lists of device's parameters */
  176. static u32 io[   SBNI_MAX_NUM_CARDS ] __initdata =
  177. { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
  178. static u32 irq[  SBNI_MAX_NUM_CARDS ] __initdata;
  179. static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
  180. static u32 rxl[  SBNI_MAX_NUM_CARDS ] __initdata =
  181. { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
  182. static u32 mac[  SBNI_MAX_NUM_CARDS ] __initdata;
  184. #ifndef MODULE
  185. typedef u32  iarr[];
  186. static iarr  *dest[5] = { &io, &irq, &baud, &rxl, &mac };
  187. #endif
  189. /* A zero-terminated list of I/O addresses to be probed on ISA bus */
  190. static unsigned int  netcard_portlist[ ] __initdata = { 
  191. 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
  192. 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
  193. 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
  194. 0 };
  197. /*
  198.  * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
  199.  * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
  200.  */
  202. static inline int __init
  203. sbni_isa_probe( struct net_device  *dev )
  204. {
  205. if( dev->base_addr > 0x1ff
  206.     &&  !check_region( dev->base_addr, SBNI_IO_EXTENT )
  207.     &&  sbni_probe1( dev, dev->base_addr, dev->irq ) )
  209. return  0;
  210. else {
  211. printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
  212. "is malfunctional!n", dev->base_addr );
  213. return  -ENODEV;
  214. }
  215. }
  218. int __init
  219. sbni_probe( struct net_device  *dev )
  220. {
  221. int  i;
  223. static unsigned  version_printed __initdata = 0;
  224. if( version_printed++ == 0 )
  225. printk( KERN_INFO "%s", version );
  227. if( !dev ) { /* simple sanity check */
  228. printk( KERN_ERR "sbni: NULL device!n" );
  229. return  -ENODEV;
  230. }
  232. SET_MODULE_OWNER( dev );
  234. if( dev->base_addr )
  235. return  sbni_isa_probe( dev );
  236. /* otherwise we have to perform search our adapter */
  238. if( io[ num ] != -1 )
  239. dev->base_addr = io[ num ],
  240. dev->irq = irq[ num ];
  241. else if( scandone  ||  io[ 0 ] != -1 )
  242. return  -ENODEV;
  244. /* if io[ num ] contains non-zero address, then that is on ISA bus */
  245. if( dev->base_addr )
  246. return  sbni_isa_probe( dev );
  248. /* ...otherwise - scan PCI first */
  249. if( !skip_pci_probe  &&  !sbni_pci_probe( dev ) )
  250. return  0;
  252. if( io[ num ] == -1 ) {
  253. /* Auto-scan will be stopped when first ISA card were found */
  254. scandone = 1;
  255. if( num > 0 )
  256. return  -ENODEV;
  257. }
  259. for( i = 0;  netcard_portlist[ i ];  ++i ) {
  260. int  ioaddr = netcard_portlist[ i ];
  261. if( !check_region( ioaddr, SBNI_IO_EXTENT )
  262.     &&  sbni_probe1( dev, ioaddr, 0 ))
  263. return 0;
  264. }
  266. return  -ENODEV;
  267. }
  270. int __init
  271. sbni_pci_probe( struct net_device  *dev )
  272. {
  273. struct pci_dev  *pdev = NULL;
  275. if( !pci_present( ) )
  276. return  -ENODEV;
  278. while( (pdev = pci_find_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
  279.        != NULL ) {
  280. int  pci_irq_line;
  281. unsigned long  pci_ioaddr;
  282. u16  subsys;
  284. if( pdev->vendor != SBNI_PCI_VENDOR
  285.     &&  pdev->device != SBNI_PCI_DEVICE )
  286. continue;
  288. pci_ioaddr = pci_resource_start( pdev, 0 );
  289. pci_irq_line = pdev->irq;
  291. /* Avoid already found cards from previous calls */
  292. if( check_region( pci_ioaddr, SBNI_IO_EXTENT ) ) {
  293. pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
  294. if( subsys != 2  || /* Dual adapter is present */
  295.     check_region( pci_ioaddr += 4, SBNI_IO_EXTENT ) )
  296. continue;
  297. }
  299. if( pci_irq_line <= 0  ||  pci_irq_line >= NR_IRQS )
  300. printk( KERN_WARNING "  WARNING: The PCI BIOS assigned "
  301. "this PCI card to IRQ %d, which is unlikely "
  302. "to work!.n"
  303. KERN_WARNING " You should use the PCI BIOS "
  304. "setup to assign a valid IRQ line.n",
  305. pci_irq_line );
  307. /* avoiding re-enable dual adapters */
  308. if( (pci_ioaddr & 7) == 0  &&  pci_enable_device( pdev ) )
  309. return  -EIO;
  310. if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) )
  311. return  0;
  312. }
  313. return  -ENODEV;
  314. }
  317. static struct net_device * __init
  318. sbni_probe1( struct net_device  *dev,  unsigned long  ioaddr,  int  irq )
  319. {
  320. struct net_local  *nl;
  322. if( !request_region( ioaddr, SBNI_IO_EXTENT, dev->name ) )
  323. return  0;
  325. if( sbni_card_probe( ioaddr ) ) {
  326. release_region( ioaddr, SBNI_IO_EXTENT );
  327. return  0;
  328. }
  330. outb( 0, ioaddr + CSR0 );
  332. if( irq < 2 ) {
  333. autoirq_setup( 5 );
  334. outb( EN_INT | TR_REQ, ioaddr + CSR0 );
  335. outb( PR_RES, ioaddr + CSR1 );
  336. irq = autoirq_report( 5 );
  337. outb( 0, ioaddr + CSR0 );
  339. if( !irq ) {
  340. printk( KERN_ERR "%s: can't detect device irq!n",
  341. dev->name );
  342. release_region( ioaddr, SBNI_IO_EXTENT );
  343. return  0;
  344. }
  345. } else if( irq == 2 )
  346. irq = 9;
  348. dev->irq = irq;
  349. dev->base_addr = ioaddr;
  351. /* Allocate dev->priv and fill in sbni-specific dev fields. */
  352. nl = (struct net_local *) kmalloc(sizeof(struct net_local), GFP_KERNEL);
  353. if( !nl ) {
  354. printk( KERN_ERR "%s: unable to get memory!n", dev->name );
  355. release_region( ioaddr, SBNI_IO_EXTENT );
  356. return  0;
  357. }
  359. dev->priv = nl;
  360. memset( nl, 0, sizeof(struct net_local) );
  361. spin_lock_init( &nl->lock );
  363. /* store MAC address (generate if that isn't known) */
  364. *(u16 *)dev->dev_addr = htons( 0x00ff );
  365. *(u32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
  366. ( (mac[num]  ?  mac[num]  :  (u32)((long)dev->priv)) & 0x00ffffff) );
  368. /* store link settings (speed, receive level ) */
  369. nl->maxframe  = DEFAULT_FRAME_LEN;
  370. nl->csr1.rate = baud[ num ];
  372. if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
  373. /* autotune rxl */
  374. nl->cur_rxl_index = DEF_RXL,
  375. nl->delta_rxl = DEF_RXL_DELTA;
  376. else
  377. nl->delta_rxl = 0;
  378. nl->csr1.rxl  = rxl_tab[ nl->cur_rxl_index ];
  379. if( inb( ioaddr + CSR0 ) & 0x01 )
  380. nl->state |= FL_SLOW_MODE;
  382. printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
  383. "MAC: 00:ff:01:%02x:%02x:%02xn", 
  384. dev->name, dev->base_addr, dev->irq,
  385. ((u8 *) dev->dev_addr) [3],
  386. ((u8 *) dev->dev_addr) [4],
  387. ((u8 *) dev->dev_addr) [5] );
  389. printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
  390. ( (nl->state & FL_SLOW_MODE)  ?  500000 : 2000000)
  391. / (1 << nl->csr1.rate) );
  393. if( nl->delta_rxl == 0 )
  394. printk( "0x%x (fixed)n", nl->cur_rxl_index ); 
  395. else
  396. printk( "(auto)n");
  398. #ifdef CONFIG_SBNI_MULTILINE
  399. nl->master = dev;
  400. nl->link   = NULL;
  401. #endif
  402.    
  403. dev->open = &sbni_open;
  404. dev->stop = &sbni_close;
  405. dev->hard_start_xmit = &sbni_start_xmit;
  406. dev->get_stats = &sbni_get_stats;
  407. dev->set_multicast_list = &set_multicast_list;
  408. dev->do_ioctl = &sbni_ioctl;
  409. ether_setup( dev );
  411. sbni_cards[ num++ ] = dev;
  412. return  dev;
  413. }
  415. /* -------------------------------------------------------------------------- */
  417. #ifdef CONFIG_SBNI_MULTILINE
  419. static int
  420. sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
  421. {
  422. struct net_device  *p;
  424. netif_stop_queue( dev );
  426. /* Looking for idle device in the list */
  427. for( p = dev;  p; ) {
  428. struct net_local  *nl = (struct net_local *) p->priv;
  429. spin_lock( &nl->lock );
  430. if( nl->tx_buf_p  ||  (nl->state & FL_LINE_DOWN) ) {
  431. p = nl->link;
  432. spin_unlock( &nl->lock );
  433. } else {
  434. /* Idle dev is found */
  435. prepare_to_send( skb, p );
  436. spin_unlock( &nl->lock );
  437. netif_start_queue( dev );
  438. return  0;
  439. }
  440. }
  442. return  1;
  443. }
  445. #else /* CONFIG_SBNI_MULTILINE */
  447. static int
  448. sbni_start_xmit( struct sk_buff  *skb,  struct net_device  *dev )
  449. {
  450. struct net_local  *nl  = (struct net_local *) dev->priv;
  452. netif_stop_queue( dev );
  453. spin_lock( &nl->lock );
  455. prepare_to_send( skb, dev );
  457. spin_unlock( &nl->lock );
  458. return  0;
  459. }
  461. #endif /* CONFIG_SBNI_MULTILINE */
  463. /* -------------------------------------------------------------------------- */
  465. /* interrupt handler */
  467. /*
  468.  *  SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
  469.  * be looked as two independent single-channel devices. Every channel seems
  470.  * as Ethernet interface but interrupt handler must be common. Really, first
  471.  * channel ("master") driver only registers the handler. In its struct net_local
  472.  * it has got pointer to "slave" channel's struct net_local and handles that's
  473.  * interrupts too.
  474.  * dev of successfully attached ISA SBNI boards is linked to list.
  475.  * While next board driver is initialized, it scans this list. If one
  476.  * has found dev with same irq and ioaddr different by 4 then it assumes
  477.  * this board to be "master".
  478.  */ 
  480. static void
  481. sbni_interrupt( int  irq,  void  *dev_id,  struct pt_regs  *regs )
  482. {
  483. struct net_device   *dev = (struct net_device *) dev_id;
  484. struct net_local  *nl  = (struct net_local *) dev->priv;
  485. int repeat;
  487. spin_lock( &nl->lock );
  488. if( nl->second )
  489. spin_lock( &((struct net_local *) nl->second->priv)->lock );
  491. do {
  492. repeat = 0;
  493. if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
  494. handle_channel( dev ),
  495. repeat = 1;
  496. if( nl->second  &&  /* second channel present */
  497.     (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
  498. handle_channel( nl->second ),
  499. repeat = 1;
  500. } while( repeat );
  502. if( nl->second )
  503. spin_unlock( &((struct net_local *)nl->second->priv)->lock );
  504. spin_unlock( &nl->lock );
  505. }
  508. static void
  509. handle_channel( struct net_device  *dev )
  510. {
  511. struct net_local *nl    = (struct net_local *) dev->priv;
  512. unsigned long ioaddr = dev->base_addr;
  514. int  req_ans;
  515. unsigned char  csr0;
  517. #ifdef CONFIG_SBNI_MULTILINE
  518. /* Lock the master device because we going to change its local data */
  519. if( nl->state & FL_SLAVE )
  520. spin_lock( &((struct net_local *) nl->master->priv)->lock );
  521. #endif
  523. outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
  525. nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
  526. for(;;) {
  527. csr0 = inb( ioaddr + CSR0 );
  528. if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
  529. break;
  531. req_ans = !(nl->state & FL_PREV_OK);
  533. if( csr0 & RC_RDY )
  534. req_ans = recv_frame( dev );
  536. /*
  537.  * TR_RDY always equals 1 here because we have owned the marker,
  538.  * and we set TR_REQ when disabled interrupts
  539.  */
  540. csr0 = inb( ioaddr + CSR0 );
  541. if( !(csr0 & TR_RDY)  ||  (csr0 & RC_RDY) )
  542. printk( KERN_ERR "%s: internal error!n", dev->name );
  544. /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
  545. if( req_ans  ||  nl->tx_frameno != 0 )
  546. send_frame( dev );
  547. else
  548. /* send marker without any data */
  549. outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
  550. }
  552. outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
  554. #ifdef CONFIG_SBNI_MULTILINE
  555. if( nl->state & FL_SLAVE )
  556. spin_unlock( &((struct net_local *) nl->master->priv)->lock );
  557. #endif
  558. }
  561. /*
  562.  * Routine returns 1 if it need to acknoweledge received frame.
  563.  * Empty frame received without errors won't be acknoweledged.
  564.  */
  566. static int
  567. recv_frame( struct net_device  *dev )
  568. {
  569. struct net_local  *nl   = (struct net_local *) dev->priv;
  570. unsigned long  ioaddr = dev->base_addr;
  572. u32  crc = CRC32_INITIAL;
  574. unsigned  framelen, frameno, ack;
  575. unsigned  is_first, frame_ok;
  577. if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
  578. frame_ok = framelen > 4
  579. ?  upload_data( dev, framelen, frameno, is_first, crc )
  580. :  skip_tail( ioaddr, framelen, crc );
  581. if( frame_ok )
  582. interpret_ack( dev, ack );
  583. } else
  584. frame_ok = 0;
  586. outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
  587. if( frame_ok ) {
  588. nl->state |= FL_PREV_OK;
  589. if( framelen > 4 )
  590. nl->in_stats.all_rx_number++;
  591. } else
  592. nl->state &= ~FL_PREV_OK,
  593. change_level( dev ),
  594. nl->in_stats.all_rx_number++,
  595. nl->in_stats.bad_rx_number++;
  597. return  !frame_ok  ||  framelen > 4;
  598. }
  601. static void
  602. send_frame( struct net_device  *dev )
  603. {
  604. struct net_local  *nl    = (struct net_local *) dev->priv;
  606. u32  crc = CRC32_INITIAL;
  608. if( nl->state & FL_NEED_RESEND ) {
  610. /* if frame was sended but not ACK'ed - resend it */
  611. if( nl->trans_errors ) {
  612. --nl->trans_errors;
  613. if( nl->framelen != 0 )
  614. nl->in_stats.resend_tx_number++;
  615. } else {
  616. /* cannot xmit with many attempts */
  617. #ifdef CONFIG_SBNI_MULTILINE
  618. if( (nl->state & FL_SLAVE)  ||  nl->link )
  619. #endif
  620. nl->state |= FL_LINE_DOWN;
  621. drop_xmit_queue( dev );
  622. goto  do_send;
  623. }
  624. } else
  625. nl->trans_errors = TR_ERROR_COUNT;
  627. send_frame_header( dev, &crc );
  628. nl->state |= FL_NEED_RESEND;
  629. /*
  630.  * FL_NEED_RESEND will be cleared after ACK, but if empty
  631.  * frame sended then in prepare_to_send next frame
  632.  */
  635. if( nl->framelen ) {
  636. download_data( dev, &crc );
  637. nl->in_stats.all_tx_number++;
  638. nl->state |= FL_WAIT_ACK;
  639. }
  641. outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
  643. do_send:
  644. outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
  646. if( nl->tx_frameno )
  647. /* next frame exists - we request card to send it */
  648. outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
  649.       dev->base_addr + CSR0 );
  650. }
  653. /*
  654.  * Write the frame data into adapter's buffer memory, and calculate CRC.
  655.  * Do padding if necessary.
  656.  */
  658. static void
  659. download_data( struct net_device  *dev,  u32  *crc_p )
  660. {
  661. struct net_local  *nl    = (struct net_local *) dev->priv;
  662. struct sk_buff    *skb  = nl->tx_buf_p;
  664. unsigned  len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
  666. outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
  667. *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
  669. /* if packet too short we should write some more bytes to pad */
  670. for( len = nl->framelen - len;  len--; )
  671. outb( 0, dev->base_addr + DAT ),
  672. *crc_p = CRC32( 0, *crc_p );
  673. }
  676. static int
  677. upload_data( struct net_device  *dev,  unsigned  framelen,  unsigned  frameno,
  678.      unsigned  is_first,  u32  crc )
  679. {
  680. struct net_local  *nl = (struct net_local *) dev->priv;
  682. int  frame_ok;
  684. if( is_first )
  685. nl->wait_frameno = frameno,
  686. nl->inppos = 0;
  688. if( nl->wait_frameno == frameno ) {
  690. if( nl->inppos + framelen  <=  ETHER_MAX_LEN )
  691. frame_ok = append_frame_to_pkt( dev, framelen, crc );
  693. /*
  694.  * if CRC is right but framelen incorrect then transmitter
  695.  * error was occured... drop entire packet
  696.  */
  697. else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
  698.  != 0 )
  699. nl->wait_frameno = 0,
  700. nl->inppos = 0,
  701. #ifdef CONFIG_SBNI_MULTILINE
  702. ((struct net_local *) nl->master->priv)
  703. ->stats.rx_errors++,
  704. ((struct net_local *) nl->master->priv)
  705. ->stats.rx_missed_errors++;
  706. #else
  707. nl->stats.rx_errors++,
  708. nl->stats.rx_missed_errors++;
  709. #endif
  710. /* now skip all frames until is_first != 0 */
  711. } else
  712. frame_ok = skip_tail( dev->base_addr, framelen, crc );
  714. if( is_first  &&  !frame_ok )
  715. /*
  716.  * Frame has been broken, but we had already stored
  717.  * is_first... Drop entire packet.
  718.  */
  719. nl->wait_frameno = 0,
  720. #ifdef CONFIG_SBNI_MULTILINE
  721. ((struct net_local *) nl->master->priv)->stats.rx_errors++,
  722. ((struct net_local *) nl->master->priv)->stats.rx_crc_errors++;
  723. #else
  724. nl->stats.rx_errors++,
  725. nl->stats.rx_crc_errors++;
  726. #endif
  728. return  frame_ok;
  729. }
  732. static __inline void
  733. send_complete( struct net_local  *nl )
  734. {
  735. #ifdef CONFIG_SBNI_MULTILINE
  736. ((struct net_local *) nl->master->priv)->stats.tx_packets++;
  737. ((struct net_local *) nl->master->priv)->stats.tx_bytes
  738. += nl->tx_buf_p->len;
  739. #else
  740. nl->stats.tx_packets++;
  741. nl->stats.tx_bytes += nl->tx_buf_p->len;
  742. #endif
  743. dev_kfree_skb_irq( nl->tx_buf_p );
  745. nl->tx_buf_p = NULL;
  747. nl->outpos = 0;
  748. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  749. nl->framelen   = 0;
  750. }
  753. static void
  754. interpret_ack( struct net_device  *dev,  unsigned  ack )
  755. {
  756. struct net_local  *nl = (struct net_local *) dev->priv;
  758. if( ack == FRAME_SENT_OK ) {
  759. nl->state &= ~FL_NEED_RESEND;
  761. if( nl->state & FL_WAIT_ACK ) {
  762. nl->outpos += nl->framelen;
  764. if( --nl->tx_frameno )
  765. nl->framelen = min_t(unsigned int,
  766.    nl->maxframe,
  767.    nl->tx_buf_p->len - nl->outpos);
  768. else
  769. send_complete( nl ),
  770. #ifdef CONFIG_SBNI_MULTILINE
  771. netif_wake_queue( nl->master );
  772. #else
  773. netif_wake_queue( dev );
  774. #endif
  775. }
  776. }
  778. nl->state &= ~FL_WAIT_ACK;
  779. }
  782. /*
  783.  * Glue received frame with previous fragments of packet.
  784.  * Indicate packet when last frame would be accepted.
  785.  */
  787. static int
  788. append_frame_to_pkt( struct net_device  *dev,  unsigned  framelen,  u32  crc )
  789. {
  790. struct net_local  *nl = (struct net_local *) dev->priv;
  792. u8  *p;
  794. if( nl->inppos + framelen  >  ETHER_MAX_LEN )
  795. return  0;
  797. if( !nl->rx_buf_p  &&  !(nl->rx_buf_p = get_rx_buf( dev )) )
  798. return  0;
  800. p = nl->rx_buf_p->data + nl->inppos;
  801. insb( dev->base_addr + DAT, p, framelen );
  802. if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
  803. return  0;
  805. nl->inppos += framelen - 4;
  806. if( --nl->wait_frameno == 0 ) /* last frame received */
  807. indicate_pkt( dev );
  809. return  1;
  810. }
  813. /*
  814.  * Prepare to start output on adapter.
  815.  * Transmitter will be actually activated when marker is accepted.
  816.  */
  818. static void
  819. prepare_to_send( struct sk_buff  *skb,  struct net_device  *dev )
  820. {
  821. struct net_local  *nl = (struct net_local *) dev->priv;
  823. unsigned int  len;
  825. /* nl->tx_buf_p == NULL here! */
  826. if( nl->tx_buf_p )
  827. printk( KERN_ERR "%s: memory leak!n", dev->name );
  829. nl->outpos = 0;
  830. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  832. len = skb->len;
  833. if( len < SBNI_MIN_LEN )
  834. len = SBNI_MIN_LEN;
  836. nl->tx_buf_p = skb;
  837. nl->tx_frameno = (len + nl->maxframe - 1) / nl->maxframe;
  838. nl->framelen = len < nl->maxframe  ?  len  :  nl->maxframe;
  840. outb( inb( dev->base_addr + CSR0 ) | TR_REQ,  dev->base_addr + CSR0 );
  841. #ifdef CONFIG_SBNI_MULTILINE
  842. nl->master->trans_start = jiffies;
  843. #else
  844. dev->trans_start = jiffies;
  845. #endif
  846. }
  849. static void
  850. drop_xmit_queue( struct net_device  *dev )
  851. {
  852. struct net_local  *nl = (struct net_local *) dev->priv;
  854. if( nl->tx_buf_p )
  855. dev_kfree_skb_any( nl->tx_buf_p ),
  856. nl->tx_buf_p = NULL,
  857. #ifdef CONFIG_SBNI_MULTILINE
  858. ((struct net_local *) nl->master->priv)
  859. ->stats.tx_errors++,
  860. ((struct net_local *) nl->master->priv)
  861. ->stats.tx_carrier_errors++;
  862. #else
  863. nl->stats.tx_errors++,
  864. nl->stats.tx_carrier_errors++;
  865. #endif
  867. nl->tx_frameno = 0;
  868. nl->framelen = 0;
  869. nl->outpos = 0;
  870. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  871. #ifdef CONFIG_SBNI_MULTILINE
  872. netif_start_queue( nl->master );
  873. nl->master->trans_start = jiffies;
  874. #else
  875. netif_start_queue( dev );
  876. dev->trans_start = jiffies;
  877. #endif
  878. }
  881. static void
  882. send_frame_header( struct net_device  *dev,  u32  *crc_p )
  883. {
  884. struct net_local  *nl  = (struct net_local *) dev->priv;
  886. u32  crc = *crc_p;
  887. u32  len_field = nl->framelen + 6; /* CRC + frameno + reserved */
  888. u8   value;
  890. if( nl->state & FL_NEED_RESEND )
  891. len_field |= FRAME_RETRY; /* non-first attempt... */
  893. if( nl->outpos == 0 )
  894. len_field |= FRAME_FIRST;
  896. len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
  897. outb( SBNI_SIG, dev->base_addr + DAT );
  899. value = (u8) len_field;
  900. outb( value, dev->base_addr + DAT );
  901. crc = CRC32( value, crc );
  902. value = (u8) (len_field >> 8);
  903. outb( value, dev->base_addr + DAT );
  904. crc = CRC32( value, crc );
  906. outb( nl->tx_frameno, dev->base_addr + DAT );
  907. crc = CRC32( nl->tx_frameno, crc );
  908. outb( 0, dev->base_addr + DAT );
  909. crc = CRC32( 0, crc );
  910. *crc_p = crc;
  911. }
  914. /*
  915.  * if frame tail not needed (incorrect number or received twice),
  916.  * it won't store, but CRC will be calculated
  917.  */
  919. static int
  920. skip_tail( unsigned int  ioaddr,  unsigned int  tail_len,  u32 crc )
  921. {
  922. while( tail_len-- )
  923. crc = CRC32( inb( ioaddr + DAT ), crc );
  925. return  crc == CRC32_REMAINDER;
  926. }
  929. /*
  930.  * Preliminary checks if frame header is correct, calculates its CRC
  931.  * and split it to simple fields
  932.  */
  934. static int
  935. check_fhdr( u32  ioaddr,  u32  *framelen,  u32  *frameno,  u32  *ack,
  936.     u32  *is_first,  u32  *crc_p )
  937. {
  938. u32  crc = *crc_p;
  939. u8   value;
  941. if( inb( ioaddr + DAT ) != SBNI_SIG )
  942. return  0;
  944. value = inb( ioaddr + DAT );
  945. *framelen = (u32)value;
  946. crc = CRC32( value, crc );
  947. value = inb( ioaddr + DAT );
  948. *framelen |= ((u32)value) << 8;
  949. crc = CRC32( value, crc );
  951. *ack = *framelen & FRAME_ACK_MASK;
  952. *is_first = (*framelen & FRAME_FIRST) != 0;
  954. if( (*framelen &= FRAME_LEN_MASK) < 6
  955.     ||  *framelen > SBNI_MAX_FRAME - 3 )
  956. return  0;
  958. value = inb( ioaddr + DAT );
  959. *frameno = (u32)value;
  960. crc = CRC32( value, crc );
  962. crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
  963. *framelen -= 2;
  965. *crc_p = crc;
  966. return  1;
  967. }
  970. static struct sk_buff *
  971. get_rx_buf( struct net_device  *dev )
  972. {
  973. /* +2 is to compensate for the alignment fixup below */
  974. struct sk_buff  *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
  975. if( !skb )
  976. return  NULL;
  978. #ifdef CONFIG_SBNI_MULTILINE
  979. skb->dev = ((struct net_local *) dev->priv)->master;
  980. #else
  981. skb->dev = dev;
  982. #endif
  983. skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
  984. return  skb;
  985. }
  988. static void
  989. indicate_pkt( struct net_device  *dev )
  990. {
  991. struct net_local  *nl  = (struct net_local *) dev->priv;
  992. struct sk_buff    *skb = nl->rx_buf_p;
  994. skb_put( skb, nl->inppos );
  996. #ifdef CONFIG_SBNI_MULTILINE
  997. skb->protocol = eth_type_trans( skb, nl->master );
  998. netif_rx( skb );
  999. dev->last_rx = jiffies;
  1000. ++((struct net_local *) nl->master->priv)->stats.rx_packets;
  1001. ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
  1002. #else
  1003. skb->protocol = eth_type_trans( skb, dev );
  1004. netif_rx( skb );
  1005. dev->last_rx = jiffies;
  1006. ++nl->stats.rx_packets;
  1007. nl->stats.rx_bytes += nl->inppos;
  1008. #endif
  1009. nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
  1010. }
  1013. /* -------------------------------------------------------------------------- */
  1015. /*
  1016.  * Routine checks periodically wire activity and regenerates marker if
  1017.  * connect was inactive for a long time.
  1018.  */
  1020. static void
  1021. sbni_watchdog( unsigned long  arg )
  1022. {
  1023. struct net_device  *dev = (struct net_device *) arg;
  1024. struct net_local   *nl  = (struct net_local *) dev->priv;
  1025. struct timer_list  *w   = &nl->watchdog; 
  1026. unsigned long    flags;
  1027. unsigned char    csr0;
  1029. spin_lock_irqsave( &nl->lock, flags );
  1031. csr0 = inb( dev->base_addr + CSR0 );
  1032. if( csr0 & RC_CHK ) {
  1034. if( nl->timer_ticks ) {
  1035. if( csr0 & (RC_RDY | BU_EMP) )
  1036. /* receiving not active */
  1037. nl->timer_ticks--;
  1038. } else {
  1039. nl->in_stats.timeout_number++;
  1040. if( nl->delta_rxl )
  1041. timeout_change_level( dev );
  1043. outb( *(u_char *)&nl->csr1 | PR_RES,
  1044.       dev->base_addr + CSR1 );
  1045. csr0 = inb( dev->base_addr + CSR0 );
  1046. }
  1047. } else
  1048. nl->state &= ~FL_LINE_DOWN;
  1050. outb( csr0 | RC_CHK, dev->base_addr + CSR0 ); 
  1052. init_timer( w );
  1053. w->expires = jiffies + SBNI_TIMEOUT;
  1054. w->data = arg;
  1055. w->function = sbni_watchdog;
  1056. add_timer( w );
  1058. spin_unlock_irqrestore( &nl->lock, flags );
  1059. }
  1062. static unsigned char  rxl_tab[] = {
  1063. 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
  1064. 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
  1065. };
  1067. #define SIZE_OF_TIMEOUT_RXL_TAB 4
  1068. static unsigned char  timeout_rxl_tab[] = {
  1069. 0x03, 0x05, 0x08, 0x0b
  1070. };
  1072. /* -------------------------------------------------------------------------- */
  1074. static void
  1075. card_start( struct net_device  *dev )
  1076. {
  1077. struct net_local  *nl = (struct net_local *) dev->priv;
  1079. nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
  1080. nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
  1081. nl->state |= FL_PREV_OK;
  1083. nl->inppos = nl->outpos = 0;
  1084. nl->wait_frameno = 0;
  1085. nl->tx_frameno  = 0;
  1086. nl->framelen  = 0;
  1088. outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
  1089. outb( EN_INT, dev->base_addr + CSR0 );
  1090. }
  1092. /* -------------------------------------------------------------------------- */
  1094. /* Receive level auto-selection */
  1096. static void
  1097. change_level( struct net_device  *dev )
  1098. {
  1099. struct net_local  *nl = (struct net_local *) dev->priv;
  1101. if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
  1102. return;
  1104. if( nl->cur_rxl_index == 0 )
  1105. nl->delta_rxl = 1;
  1106. else if( nl->cur_rxl_index == 15 )
  1107. nl->delta_rxl = -1;
  1108. else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
  1109. nl->delta_rxl = -nl->delta_rxl;
  1111. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
  1112. inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
  1113. outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
  1115. nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
  1116. nl->cur_rxl_rcvd  = 0;
  1117. }
  1120. static void
  1121. timeout_change_level( struct net_device  *dev )
  1122. {
  1123. struct net_local  *nl = (struct net_local *) dev->priv;
  1125. nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
  1126. if( ++nl->timeout_rxl >= 4 )
  1127. nl->timeout_rxl = 0;
  1129. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
  1130. inb( dev->base_addr + CSR0 );
  1131. outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
  1133. nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
  1134. nl->cur_rxl_rcvd  = 0;
  1135. }
  1137. /* -------------------------------------------------------------------------- */
  1139. /*
  1140.  * Open/initialize the board. 
  1141.  */
  1143. static int
  1144. sbni_open( struct net_device  *dev )
  1145. {
  1146. struct net_local *nl = (struct net_local *) dev->priv;
  1147. struct timer_list *w  = &nl->watchdog;
  1149. /*
  1150.  * For double ISA adapters within "common irq" mode, we have to
  1151.  * determine whether primary or secondary channel is initialized,
  1152.  * and set the irq handler only in first case.
  1153.  */
  1154. if( dev->base_addr < 0x400 ) { /* ISA only */
  1155. struct net_device  **p = sbni_cards;
  1156. for( ;  *p  &&  p < sbni_cards + SBNI_MAX_NUM_CARDS;  ++p )
  1157. if( (*p)->irq == dev->irq
  1158.     &&  ((*p)->base_addr == dev->base_addr + 4
  1159.  ||  (*p)->base_addr == dev->base_addr - 4)
  1160.     &&  (*p)->flags & IFF_UP ) {
  1162. ((struct net_local *) ((*p)->priv))
  1163. ->second = dev;
  1164. printk( KERN_NOTICE "%s: using shared irq "
  1165. "with %sn", dev->name, (*p)->name );
  1166. nl->state |= FL_SECONDARY;
  1167. goto  handler_attached;
  1168. }
  1169. }
  1171. if( request_irq(dev->irq, sbni_interrupt, SA_SHIRQ, dev->name, dev) ) {
  1172. printk( KERN_ERR "%s: unable to get IRQ %d.n",
  1173. dev->name, dev->irq );
  1174. return  -EAGAIN;
  1175. }
  1177. handler_attached:
  1179. spin_lock( &nl->lock );
  1180. memset( &nl->stats, 0, sizeof(struct net_device_stats) );
  1181. memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
  1183. card_start( dev );
  1185. netif_start_queue( dev );
  1187. /* set timer watchdog */
  1188. init_timer( w );
  1189. w->expires = jiffies + SBNI_TIMEOUT;
  1190. w->data = (unsigned long) dev;
  1191. w->function = sbni_watchdog;
  1192. add_timer( w );
  1193.    
  1194. spin_unlock( &nl->lock );
  1195. return 0;
  1196. }
  1199. static int
  1200. sbni_close( struct net_device  *dev )
  1201. {
  1202. struct net_local  *nl = (struct net_local *) dev->priv;
  1204. if( nl->second  &&  nl->second->flags & IFF_UP ) {
  1205. printk( KERN_NOTICE "Secondary channel (%s) is active!n",
  1206. nl->second->name );
  1207. return  -EBUSY;
  1208. }
  1210. #ifdef CONFIG_SBNI_MULTILINE
  1211. if( nl->state & FL_SLAVE )
  1212. emancipate( dev );
  1213. else
  1214. while( nl->link ) /* it's master device! */
  1215. emancipate( nl->link );
  1216. #endif
  1218. spin_lock( &nl->lock );
  1220. nl->second = NULL;
  1221. drop_xmit_queue( dev );
  1222. netif_stop_queue( dev );
  1223.    
  1224. del_timer( &nl->watchdog );
  1226. outb( 0, dev->base_addr + CSR0 );
  1228. if( !(nl->state & FL_SECONDARY) )
  1229. free_irq( dev->irq, dev );
  1230. nl->state &= FL_SECONDARY;
  1232. spin_unlock( &nl->lock );
  1233. return 0;
  1234. }
  1237. /*
  1238. Valid combinations in CSR0 (for probing):
  1240. VALID_DECODER 0000,0011,1011,1010
  1242.      ; 0   ; -
  1243. TR_REQ ; 1   ; +
  1244. TR_RDY      ; 2   ; -
  1245. TR_RDY TR_REQ ; 3   ; +
  1246. BU_EMP      ; 4   ; +
  1247. BU_EMP       TR_REQ ; 5   ; +
  1248. BU_EMP TR_RDY      ; 6   ; -
  1249. BU_EMP TR_RDY TR_REQ ; 7   ; +
  1250. RC_RDY        ; 8   ; +
  1251. RC_RDY TR_REQ ; 9   ; +
  1252. RC_RDY TR_RDY ; 10  ; -
  1253. RC_RDY TR_RDY TR_REQ ; 11  ; -
  1254. RC_RDY BU_EMP ; 12  ; -
  1255. RC_RDY BU_EMP TR_REQ ; 13  ; -
  1256. RC_RDY BU_EMP TR_RDY ; 14  ; -
  1257. RC_RDY BU_EMP TR_RDY TR_REQ ; 15  ; -
  1258. */
  1260. #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
  1263. static int
  1264. sbni_card_probe( unsigned long  ioaddr )
  1265. {
  1266. unsigned char  csr0;
  1268. csr0 = inb( ioaddr + CSR0 );
  1269. if( csr0 != 0xff  &&  csr0 != 0x00 ) {
  1270. csr0 &= ~EN_INT;
  1271. if( csr0 & BU_EMP )
  1272. csr0 |= EN_INT;
  1273.       
  1274. if( VALID_DECODER & (1 << (csr0 >> 4)) )
  1275. return  0;
  1276. }
  1277.    
  1278. return  -ENODEV;
  1279. }
  1281. /* -------------------------------------------------------------------------- */
  1283. static int
  1284. sbni_ioctl( struct net_device  *dev,  struct ifreq  *ifr,  int  cmd )
  1285. {
  1286. struct net_local  *nl = (struct net_local *) dev->priv; 
  1287. struct sbni_flags  flags;
  1288. int  error = 0;
  1290. #ifdef CONFIG_SBNI_MULTILINE
  1291. struct net_device  *slave_dev;
  1292. char  slave_name[ 8 ];
  1293. #endif
  1294.   
  1295. switch( cmd ) {
  1296. case  SIOCDEVGETINSTATS :
  1297. error = verify_area( VERIFY_WRITE, ifr->ifr_data,
  1298.      sizeof(struct sbni_in_stats) );
  1299. if( !error )
  1300. copy_to_user( ifr->ifr_data, &nl->in_stats,
  1301.       sizeof(struct sbni_in_stats) );
  1302. break;
  1304. case  SIOCDEVRESINSTATS :
  1305. if( current->euid != 0 ) /* root only */
  1306. return  -EPERM;
  1307. memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
  1308. break;
  1310. case  SIOCDEVGHWSTATE :
  1311. flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
  1312. flags.rate = nl->csr1.rate;
  1313. flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
  1314. flags.rxl = nl->cur_rxl_index;
  1315. flags.fixed_rxl = nl->delta_rxl == 0;
  1317. error = verify_area( VERIFY_WRITE, ifr->ifr_data,
  1318.      sizeof flags );
  1319. if( !error )
  1320. copy_to_user( ifr->ifr_data, &flags, sizeof flags );
  1321. break;
  1323. case  SIOCDEVSHWSTATE :
  1324. if( current->euid != 0 ) /* root only */
  1325. return  -EPERM;
  1327. spin_lock( &nl->lock );
  1328. flags = *(struct sbni_flags*) &ifr->ifr_data;
  1329. if( flags.fixed_rxl )
  1330. nl->delta_rxl = 0,
  1331. nl->cur_rxl_index = flags.rxl;
  1332. else
  1333. nl->delta_rxl = DEF_RXL_DELTA,
  1334. nl->cur_rxl_index = DEF_RXL;
  1336. nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
  1337. nl->csr1.rate = flags.rate;
  1338. outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
  1339. spin_unlock( &nl->lock );
  1340. break;
  1342. #ifdef CONFIG_SBNI_MULTILINE
  1344. case  SIOCDEVENSLAVE :
  1345. if( current->euid != 0 ) /* root only */
  1346. return  -EPERM;
  1348. if( (error = verify_area( VERIFY_READ, ifr->ifr_data,
  1349.   sizeof slave_name )) != 0 )
  1350. return  error;
  1352. copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name );
  1353. slave_dev = dev_get_by_name( slave_name );
  1354. if( !slave_dev  ||  !(slave_dev->flags & IFF_UP) ) {
  1355. printk( KERN_ERR "%s: trying to enslave non-active "
  1356. "device %sn", dev->name, slave_name );
  1357. return  -EPERM;
  1358. }
  1360. return  enslave( dev, slave_dev );
  1362. case  SIOCDEVEMANSIPATE :
  1363. if( current->euid != 0 ) /* root only */
  1364. return  -EPERM;
  1366. return  emancipate( dev );
  1368. #endif /* CONFIG_SBNI_MULTILINE */
  1370. default :
  1371. return  -EOPNOTSUPP;
  1372. }
  1374. return  error;
  1375. }
  1378. #ifdef CONFIG_SBNI_MULTILINE
  1380. static int
  1381. enslave( struct net_device  *dev,  struct net_device  *slave_dev )
  1382. {
  1383. struct net_local  *nl  = (struct net_local *) dev->priv;
  1384. struct net_local  *snl = (struct net_local *) slave_dev->priv;
  1386. if( nl->state & FL_SLAVE ) /* This isn't master or free device */
  1387. return  -EBUSY;
  1389. if( snl->state & FL_SLAVE ) /* That was already enslaved */
  1390. return  -EBUSY;
  1392. spin_lock( &nl->lock );
  1393. spin_lock( &snl->lock );
  1395. /* append to list */
  1396. snl->link = nl->link;
  1397. nl->link  = slave_dev;
  1398. snl->master = dev;
  1399. snl->state |= FL_SLAVE;
  1401. /* Summary statistics of MultiLine operation will be stored
  1402.    in master's counters */
  1403. memset( &snl->stats, 0, sizeof(struct net_device_stats) );
  1404. netif_stop_queue( slave_dev );
  1405. netif_wake_queue( dev ); /* Now we are able to transmit */
  1407. spin_unlock( &snl->lock );
  1408. spin_unlock( &nl->lock );
  1409. printk( KERN_NOTICE "%s: slave device (%s) attached.n",
  1410. dev->name, slave_dev->name );
  1411. return  0;
  1412. }
  1415. static int
  1416. emancipate( struct net_device  *dev )
  1417. {
  1418. struct net_local   *snl = (struct net_local *) dev->priv;
  1419. struct net_device  *p   = snl->master;
  1420. struct net_local   *nl  = (struct net_local *) p->priv;
  1422. if( !(snl->state & FL_SLAVE) )
  1423. return  -EINVAL;
  1425. spin_lock( &nl->lock );
  1426. spin_lock( &snl->lock );
  1427. drop_xmit_queue( dev );
  1429. /* exclude from list */
  1430. for(;;) { /* must be in list */
  1431. struct net_local  *t = (struct net_local *) p->priv;
  1432. if( t->link == dev ) {
  1433. t->link = snl->link;
  1434. break;
  1435. }
  1436. p = t->link;
  1437. }
  1439. snl->link = NULL;
  1440. snl->master = dev;
  1441. snl->state &= ~FL_SLAVE;
  1443. netif_start_queue( dev );
  1445. spin_unlock( &snl->lock );
  1446. spin_unlock( &nl->lock );
  1448. dev_put( dev );
  1449. return  0;
  1450. }
  1452. #endif
  1455. static struct net_device_stats *
  1456. sbni_get_stats( struct net_device  *dev )
  1457. {
  1458. return  &((struct net_local *) dev->priv)->stats;
  1459. }
  1462. static void
  1463. set_multicast_list( struct net_device  *dev )
  1464. {
  1465. return; /* sbni always operate in promiscuos mode */
  1466. }
  1469. #ifdef MODULE
  1471. MODULE_PARM( io, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1472. MODULE_PARM( irq, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1473. MODULE_PARM( baud, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1474. MODULE_PARM( rxl, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1475. MODULE_PARM( mac, "1-" __MODULE_STRING( SBNI_MAX_NUM_CARDS ) "i" );
  1477. MODULE_PARM( skip_pci_probe, "i" );
  1479. MODULE_LICENSE("GPL");
  1482. int
  1483. init_module( void )
  1484. {
  1485. struct net_device  *dev;
  1487. while( num < SBNI_MAX_NUM_CARDS ) {
  1488. if( !(dev = kmalloc(sizeof(struct net_device), GFP_KERNEL)) ){
  1489. printk( KERN_ERR "sbni: unable to allocate device!n" );
  1490. return  -ENOMEM;
  1491. }
  1493. memset( dev, 0, sizeof(struct net_device) );
  1494. sprintf( dev->name, "sbni%d", num );
  1496. dev->init = sbni_probe;
  1497. if( register_netdev( dev ) ) {
  1498. kfree( dev );
  1499. break;
  1500. }
  1501. }
  1503. return  *sbni_cards  ?  0  :  -ENODEV;
  1504. }
  1506. void
  1507. cleanup_module( void )
  1508. {
  1509. struct net_device  *dev;
  1510. int  num;
  1512. /* No need to check MOD_IN_USE, as sys_delete_module( ) checks. */
  1513. for( num = 0;  num < SBNI_MAX_NUM_CARDS;  ++num )
  1514. if( (dev = sbni_cards[ num ]) != NULL ) {
  1515. unregister_netdev( dev );
  1516. release_region( dev->base_addr, SBNI_IO_EXTENT );
  1517. kfree( dev->priv );
  1518. kfree( dev );
  1519. }
  1520. }
  1522. #else /* MODULE */
  1524. static int __init
  1525. sbni_setup( char  *p )
  1526. {
  1527. int  n, parm;
  1529. if( *p++ != '(' )
  1530. goto  bad_param;
  1532. for( n = 0, parm = 0;  *p  &&  n < 8; ) {
  1533. (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
  1534. if( !*p  ||  *p == ')' )
  1535. return 1;
  1536. if( *p == ';' )
  1537. ++p, ++n, parm = 0;
  1538. else if( *p++ != ',' )
  1539. break;
  1540. else
  1541. if( ++parm >= 5 )
  1542. break;
  1543. }
  1544. bad_param:
  1545. printk( KERN_ERR "Error in sbni kernel parameter!n" );
  1546. return 0;
  1547. }
  1549. __setup( "sbni=", sbni_setup );
  1551. #endif /* MODULE */
  1553. /* -------------------------------------------------------------------------- */
  1555. #ifdef ASM_CRC
  1557. static u32
  1558. calc_crc32( u32  crc,  u8  *p,  u32  len )
  1559. {
  1560. register u32  _crc __asm ( "ax" );
  1561. _crc = crc;
  1563. __asm __volatile (
  1564. "xorl %%ebx, %%ebxn"
  1565. "movl %1, %%esin" 
  1566. "movl %2, %%ecxn" 
  1567. "movl $crc32tab, %%edin"
  1568. "shrl $2, %%ecxn"
  1569. "jz 1fn"
  1571. ".align 4n"
  1572. "0:n"
  1573. "movb %%al, %%bln"
  1574. "movl (%%esi), %%edxn"
  1575. "shrl $8, %%eaxn"
  1576. "xorb %%dl, %%bln"
  1577. "shrl $8, %%edxn"
  1578. "xorl (%%edi,%%ebx,4), %%eaxn"
  1580. "movb %%al, %%bln"
  1581. "shrl $8, %%eaxn"
  1582. "xorb %%dl, %%bln"
  1583. "shrl $8, %%edxn"
  1584. "xorl (%%edi,%%ebx,4), %%eaxn"
  1586. "movb %%al, %%bln"
  1587. "shrl $8, %%eaxn"
  1588. "xorb %%dl, %%bln"
  1589. "movb %%dh, %%dln" 
  1590. "xorl (%%edi,%%ebx,4), %%eaxn"
  1592. "movb %%al, %%bln"
  1593. "shrl $8, %%eaxn"
  1594. "xorb %%dl, %%bln"
  1595. "addl $4, %%esin"
  1596. "xorl (%%edi,%%ebx,4), %%eaxn"
  1598. "decl %%ecxn"
  1599. "jnz 0bn"
  1601. "1:n"
  1602. "movl %2, %%ecxn"
  1603. "andl $3, %%ecxn"
  1604. "jz 2fn"
  1606. "movb %%al, %%bln"
  1607. "shrl $8, %%eaxn"
  1608. "xorb (%%esi), %%bln"
  1609. "xorl (%%edi,%%ebx,4), %%eaxn"
  1611. "decl %%ecxn"
  1612. "jz 2fn"
  1614. "movb %%al, %%bln"
  1615. "shrl $8, %%eaxn"
  1616. "xorb 1(%%esi), %%bln"
  1617. "xorl (%%edi,%%ebx,4), %%eaxn"
  1619. "decl %%ecxn"
  1620. "jz 2fn"
  1622. "movb %%al, %%bln"
  1623. "shrl $8, %%eaxn"
  1624. "xorb 2(%%esi), %%bln"
  1625. "xorl (%%edi,%%ebx,4), %%eaxn"
  1626. "2:n"
  1627. :
  1628. : "a" (_crc), "g" (p), "g" (len)
  1629. : "ax", "bx", "cx", "dx", "si", "di"
  1630. );
  1632. return  _crc;
  1633. }
  1635. #else /* ASM_CRC */
  1637. static u32
  1638. calc_crc32( u32  crc,  u8  *p,  u32  len )
  1639. {
  1640. while( len-- )
  1641. crc = CRC32( *p++, crc );
  1643. return  crc;
  1644. }
  1646. #endif /* ASM_CRC */
  1649. static u32  crc32tab[] __attribute__ ((aligned(8))) = {
  1650. 0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
  1651. 0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
  1652. 0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
  1653. 0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
  1654. 0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
  1655. 0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
  1656. 0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
  1657. 0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
  1658. 0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
  1659. 0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
  1660. 0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
  1661. 0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
  1662. 0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
  1663. 0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
  1664. 0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
  1665. 0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
  1666. 0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
  1667. 0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
  1668. 0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
  1669. 0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
  1670. 0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
  1671. 0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
  1672. 0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
  1673. 0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
  1674. 0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
  1675. 0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
  1676. 0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
  1677. 0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
  1678. 0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
  1679. 0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
  1680. 0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
  1681. 0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
  1682. 0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
  1683. 0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
  1684. 0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
  1685. 0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
  1686. 0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
  1687. 0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
  1688. 0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
  1689. 0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
  1690. 0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
  1691. 0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
  1692. 0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
  1693. 0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
  1694. 0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
  1695. 0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
  1696. 0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
  1697. 0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
  1698. 0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
  1699. 0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
  1700. 0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
  1701. 0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
  1702. 0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
  1703. 0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
  1704. 0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
  1705. 0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
  1706. 0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
  1707. 0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
  1708. 0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
  1709. 0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
  1710. 0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
  1711. 0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
  1712. 0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
  1713. 0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
  1714. };