ALSA: ASoC: TLV320AIC3X: Modify only interface related bits in aic3x_set_dai_fmt
[linux-ginger.git] / drivers / net / wan / sbni.c
blobe59255a155a91e34719b11e70c9a471d4fd36e6d
1 /* sbni.c: Granch SBNI12 leased line adapters driver for linux
3 * Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
5 * Previous versions were written by Yaroslav Polyakov,
6 * Alexey Zverev and Max Khon.
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)
13 * This software may be used and distributed according to the terms
14 * of the GNU General Public License.
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,
37 * Known problem: this driver wasn't tested on multiprocessor machine.
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/ptrace.h>
43 #include <linux/fcntl.h>
44 #include <linux/ioport.h>
45 #include <linux/interrupt.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/errno.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/pci.h>
52 #include <linux/skbuff.h>
53 #include <linux/timer.h>
54 #include <linux/init.h>
55 #include <linux/delay.h>
57 #include <net/net_namespace.h>
58 #include <net/arp.h>
60 #include <asm/io.h>
61 #include <asm/types.h>
62 #include <asm/byteorder.h>
63 #include <asm/irq.h>
64 #include <asm/uaccess.h>
66 #include "sbni.h"
68 /* device private data */
70 struct net_local {
71 struct net_device_stats stats;
72 struct timer_list watchdog;
74 spinlock_t lock;
75 struct sk_buff *rx_buf_p; /* receive buffer ptr */
76 struct sk_buff *tx_buf_p; /* transmit buffer ptr */
78 unsigned int framelen; /* current frame length */
79 unsigned int maxframe; /* maximum valid frame length */
80 unsigned int state;
81 unsigned int inppos, outpos; /* positions in rx/tx buffers */
83 /* transmitting frame number - from frames qty to 1 */
84 unsigned int tx_frameno;
86 /* expected number of next receiving frame */
87 unsigned int wait_frameno;
89 /* count of failed attempts to frame send - 32 attempts do before
90 error - while receiver tunes on opposite side of wire */
91 unsigned int trans_errors;
93 /* idle time; send pong when limit exceeded */
94 unsigned int timer_ticks;
96 /* fields used for receive level autoselection */
97 int delta_rxl;
98 unsigned int cur_rxl_index, timeout_rxl;
99 unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
101 struct sbni_csr1 csr1; /* current value of CSR1 */
102 struct sbni_in_stats in_stats; /* internal statistics */
104 struct net_device *second; /* for ISA/dual cards */
106 #ifdef CONFIG_SBNI_MULTILINE
107 struct net_device *master;
108 struct net_device *link;
109 #endif
113 static int sbni_card_probe( unsigned long );
114 static int sbni_pci_probe( struct net_device * );
115 static struct net_device *sbni_probe1(struct net_device *, unsigned long, int);
116 static int sbni_open( struct net_device * );
117 static int sbni_close( struct net_device * );
118 static int sbni_start_xmit( struct sk_buff *, struct net_device * );
119 static int sbni_ioctl( struct net_device *, struct ifreq *, int );
120 static struct net_device_stats *sbni_get_stats( struct net_device * );
121 static void set_multicast_list( struct net_device * );
123 static irqreturn_t sbni_interrupt( int, void * );
124 static void handle_channel( struct net_device * );
125 static int recv_frame( struct net_device * );
126 static void send_frame( struct net_device * );
127 static int upload_data( struct net_device *,
128 unsigned, unsigned, unsigned, u32 );
129 static void download_data( struct net_device *, u32 * );
130 static void sbni_watchdog( unsigned long );
131 static void interpret_ack( struct net_device *, unsigned );
132 static int append_frame_to_pkt( struct net_device *, unsigned, u32 );
133 static void indicate_pkt( struct net_device * );
134 static void card_start( struct net_device * );
135 static void prepare_to_send( struct sk_buff *, struct net_device * );
136 static void drop_xmit_queue( struct net_device * );
137 static void send_frame_header( struct net_device *, u32 * );
138 static int skip_tail( unsigned int, unsigned int, u32 );
139 static int check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
140 static void change_level( struct net_device * );
141 static void timeout_change_level( struct net_device * );
142 static u32 calc_crc32( u32, u8 *, u32 );
143 static struct sk_buff * get_rx_buf( struct net_device * );
144 static int sbni_init( struct net_device * );
146 #ifdef CONFIG_SBNI_MULTILINE
147 static int enslave( struct net_device *, struct net_device * );
148 static int emancipate( struct net_device * );
149 #endif
151 #ifdef __i386__
152 #define ASM_CRC 1
153 #endif
155 static const char version[] =
156 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
158 static int skip_pci_probe __initdata = 0;
159 static int scandone __initdata = 0;
160 static int num __initdata = 0;
162 static unsigned char rxl_tab[];
163 static u32 crc32tab[];
165 /* A list of all installed devices, for removing the driver module. */
166 static struct net_device *sbni_cards[ SBNI_MAX_NUM_CARDS ];
168 /* Lists of device's parameters */
169 static u32 io[ SBNI_MAX_NUM_CARDS ] __initdata =
170 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
171 static u32 irq[ SBNI_MAX_NUM_CARDS ] __initdata;
172 static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
173 static u32 rxl[ SBNI_MAX_NUM_CARDS ] __initdata =
174 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
175 static u32 mac[ SBNI_MAX_NUM_CARDS ] __initdata;
177 #ifndef MODULE
178 typedef u32 iarr[];
179 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
180 #endif
182 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
183 static unsigned int netcard_portlist[ ] __initdata = {
184 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
185 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
186 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
187 0 };
191 * Look for SBNI card which addr stored in dev->base_addr, if nonzero.
192 * Otherwise, look through PCI bus. If none PCI-card was found, scan ISA.
195 static inline int __init
196 sbni_isa_probe( struct net_device *dev )
198 if( dev->base_addr > 0x1ff
199 && request_region( dev->base_addr, SBNI_IO_EXTENT, dev->name )
200 && sbni_probe1( dev, dev->base_addr, dev->irq ) )
202 return 0;
203 else {
204 printk( KERN_ERR "sbni: base address 0x%lx is busy, or adapter "
205 "is malfunctional!\n", dev->base_addr );
206 return -ENODEV;
210 static void __init sbni_devsetup(struct net_device *dev)
212 ether_setup( dev );
213 dev->open = &sbni_open;
214 dev->stop = &sbni_close;
215 dev->hard_start_xmit = &sbni_start_xmit;
216 dev->get_stats = &sbni_get_stats;
217 dev->set_multicast_list = &set_multicast_list;
218 dev->do_ioctl = &sbni_ioctl;
221 int __init sbni_probe(int unit)
223 struct net_device *dev;
224 static unsigned version_printed __initdata = 0;
225 int err;
227 dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
228 if (!dev)
229 return -ENOMEM;
231 sprintf(dev->name, "sbni%d", unit);
232 netdev_boot_setup_check(dev);
234 err = sbni_init(dev);
235 if (err) {
236 free_netdev(dev);
237 return err;
240 err = register_netdev(dev);
241 if (err) {
242 release_region( dev->base_addr, SBNI_IO_EXTENT );
243 free_netdev(dev);
244 return err;
246 if( version_printed++ == 0 )
247 printk( KERN_INFO "%s", version );
248 return 0;
251 static int __init sbni_init(struct net_device *dev)
253 int i;
254 if( dev->base_addr )
255 return sbni_isa_probe( dev );
256 /* otherwise we have to perform search our adapter */
258 if( io[ num ] != -1 )
259 dev->base_addr = io[ num ],
260 dev->irq = irq[ num ];
261 else if( scandone || io[ 0 ] != -1 )
262 return -ENODEV;
264 /* if io[ num ] contains non-zero address, then that is on ISA bus */
265 if( dev->base_addr )
266 return sbni_isa_probe( dev );
268 /* ...otherwise - scan PCI first */
269 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
270 return 0;
272 if( io[ num ] == -1 ) {
273 /* Auto-scan will be stopped when first ISA card were found */
274 scandone = 1;
275 if( num > 0 )
276 return -ENODEV;
279 for( i = 0; netcard_portlist[ i ]; ++i ) {
280 int ioaddr = netcard_portlist[ i ];
281 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
282 && sbni_probe1( dev, ioaddr, 0 ))
283 return 0;
286 return -ENODEV;
290 int __init
291 sbni_pci_probe( struct net_device *dev )
293 struct pci_dev *pdev = NULL;
295 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
296 != NULL ) {
297 int pci_irq_line;
298 unsigned long pci_ioaddr;
299 u16 subsys;
301 if( pdev->vendor != SBNI_PCI_VENDOR
302 && pdev->device != SBNI_PCI_DEVICE )
303 continue;
305 pci_ioaddr = pci_resource_start( pdev, 0 );
306 pci_irq_line = pdev->irq;
308 /* Avoid already found cards from previous calls */
309 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
310 pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
312 if (subsys != 2)
313 continue;
315 /* Dual adapter is present */
316 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
317 dev->name ) )
318 continue;
321 if( pci_irq_line <= 0 || pci_irq_line >= NR_IRQS )
322 printk( KERN_WARNING " WARNING: The PCI BIOS assigned "
323 "this PCI card to IRQ %d, which is unlikely "
324 "to work!.\n"
325 KERN_WARNING " You should use the PCI BIOS "
326 "setup to assign a valid IRQ line.\n",
327 pci_irq_line );
329 /* avoiding re-enable dual adapters */
330 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
331 release_region( pci_ioaddr, SBNI_IO_EXTENT );
332 pci_dev_put( pdev );
333 return -EIO;
335 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
336 SET_NETDEV_DEV(dev, &pdev->dev);
337 /* not the best thing to do, but this is all messed up
338 for hotplug systems anyway... */
339 pci_dev_put( pdev );
340 return 0;
343 return -ENODEV;
347 static struct net_device * __init
348 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
350 struct net_local *nl;
352 if( sbni_card_probe( ioaddr ) ) {
353 release_region( ioaddr, SBNI_IO_EXTENT );
354 return NULL;
357 outb( 0, ioaddr + CSR0 );
359 if( irq < 2 ) {
360 unsigned long irq_mask;
362 irq_mask = probe_irq_on();
363 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
364 outb( PR_RES, ioaddr + CSR1 );
365 mdelay(50);
366 irq = probe_irq_off(irq_mask);
367 outb( 0, ioaddr + CSR0 );
369 if( !irq ) {
370 printk( KERN_ERR "%s: can't detect device irq!\n",
371 dev->name );
372 release_region( ioaddr, SBNI_IO_EXTENT );
373 return NULL;
375 } else if( irq == 2 )
376 irq = 9;
378 dev->irq = irq;
379 dev->base_addr = ioaddr;
381 /* Allocate dev->priv and fill in sbni-specific dev fields. */
382 nl = dev->priv;
383 if( !nl ) {
384 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
385 release_region( ioaddr, SBNI_IO_EXTENT );
386 return NULL;
389 dev->priv = nl;
390 memset( nl, 0, sizeof(struct net_local) );
391 spin_lock_init( &nl->lock );
393 /* store MAC address (generate if that isn't known) */
394 *(__be16 *)dev->dev_addr = htons( 0x00ff );
395 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
396 ( (mac[num] ? mac[num] : (u32)((long)dev->priv)) & 0x00ffffff) );
398 /* store link settings (speed, receive level ) */
399 nl->maxframe = DEFAULT_FRAME_LEN;
400 nl->csr1.rate = baud[ num ];
402 if( (nl->cur_rxl_index = rxl[ num ]) == -1 )
403 /* autotune rxl */
404 nl->cur_rxl_index = DEF_RXL,
405 nl->delta_rxl = DEF_RXL_DELTA;
406 else
407 nl->delta_rxl = 0;
408 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
409 if( inb( ioaddr + CSR0 ) & 0x01 )
410 nl->state |= FL_SLOW_MODE;
412 printk( KERN_NOTICE "%s: ioaddr %#lx, irq %d, "
413 "MAC: 00:ff:01:%02x:%02x:%02x\n",
414 dev->name, dev->base_addr, dev->irq,
415 ((u8 *) dev->dev_addr) [3],
416 ((u8 *) dev->dev_addr) [4],
417 ((u8 *) dev->dev_addr) [5] );
419 printk( KERN_NOTICE "%s: speed %d, receive level ", dev->name,
420 ( (nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
421 / (1 << nl->csr1.rate) );
423 if( nl->delta_rxl == 0 )
424 printk( "0x%x (fixed)\n", nl->cur_rxl_index );
425 else
426 printk( "(auto)\n");
428 #ifdef CONFIG_SBNI_MULTILINE
429 nl->master = dev;
430 nl->link = NULL;
431 #endif
433 sbni_cards[ num++ ] = dev;
434 return dev;
437 /* -------------------------------------------------------------------------- */
439 #ifdef CONFIG_SBNI_MULTILINE
441 static int
442 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
444 struct net_device *p;
446 netif_stop_queue( dev );
448 /* Looking for idle device in the list */
449 for( p = dev; p; ) {
450 struct net_local *nl = (struct net_local *) p->priv;
451 spin_lock( &nl->lock );
452 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
453 p = nl->link;
454 spin_unlock( &nl->lock );
455 } else {
456 /* Idle dev is found */
457 prepare_to_send( skb, p );
458 spin_unlock( &nl->lock );
459 netif_start_queue( dev );
460 return 0;
464 return 1;
467 #else /* CONFIG_SBNI_MULTILINE */
469 static int
470 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
472 struct net_local *nl = (struct net_local *) dev->priv;
474 netif_stop_queue( dev );
475 spin_lock( &nl->lock );
477 prepare_to_send( skb, dev );
479 spin_unlock( &nl->lock );
480 return 0;
483 #endif /* CONFIG_SBNI_MULTILINE */
485 /* -------------------------------------------------------------------------- */
487 /* interrupt handler */
490 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
491 * be looked as two independent single-channel devices. Every channel seems
492 * as Ethernet interface but interrupt handler must be common. Really, first
493 * channel ("master") driver only registers the handler. In its struct net_local
494 * it has got pointer to "slave" channel's struct net_local and handles that's
495 * interrupts too.
496 * dev of successfully attached ISA SBNI boards is linked to list.
497 * While next board driver is initialized, it scans this list. If one
498 * has found dev with same irq and ioaddr different by 4 then it assumes
499 * this board to be "master".
502 static irqreturn_t
503 sbni_interrupt( int irq, void *dev_id )
505 struct net_device *dev = dev_id;
506 struct net_local *nl = dev->priv;
507 int repeat;
509 spin_lock( &nl->lock );
510 if( nl->second )
511 spin_lock( &((struct net_local *) nl->second->priv)->lock );
513 do {
514 repeat = 0;
515 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) )
516 handle_channel( dev ),
517 repeat = 1;
518 if( nl->second && /* second channel present */
519 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) )
520 handle_channel( nl->second ),
521 repeat = 1;
522 } while( repeat );
524 if( nl->second )
525 spin_unlock( &((struct net_local *)nl->second->priv)->lock );
526 spin_unlock( &nl->lock );
527 return IRQ_HANDLED;
531 static void
532 handle_channel( struct net_device *dev )
534 struct net_local *nl = (struct net_local *) dev->priv;
535 unsigned long ioaddr = dev->base_addr;
537 int req_ans;
538 unsigned char csr0;
540 #ifdef CONFIG_SBNI_MULTILINE
541 /* Lock the master device because we going to change its local data */
542 if( nl->state & FL_SLAVE )
543 spin_lock( &((struct net_local *) nl->master->priv)->lock );
544 #endif
546 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
548 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
549 for(;;) {
550 csr0 = inb( ioaddr + CSR0 );
551 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
552 break;
554 req_ans = !(nl->state & FL_PREV_OK);
556 if( csr0 & RC_RDY )
557 req_ans = recv_frame( dev );
560 * TR_RDY always equals 1 here because we have owned the marker,
561 * and we set TR_REQ when disabled interrupts
563 csr0 = inb( ioaddr + CSR0 );
564 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
565 printk( KERN_ERR "%s: internal error!\n", dev->name );
567 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
568 if( req_ans || nl->tx_frameno != 0 )
569 send_frame( dev );
570 else
571 /* send marker without any data */
572 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
575 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
577 #ifdef CONFIG_SBNI_MULTILINE
578 if( nl->state & FL_SLAVE )
579 spin_unlock( &((struct net_local *) nl->master->priv)->lock );
580 #endif
585 * Routine returns 1 if it need to acknoweledge received frame.
586 * Empty frame received without errors won't be acknoweledged.
589 static int
590 recv_frame( struct net_device *dev )
592 struct net_local *nl = (struct net_local *) dev->priv;
593 unsigned long ioaddr = dev->base_addr;
595 u32 crc = CRC32_INITIAL;
597 unsigned framelen = 0, frameno, ack;
598 unsigned is_first, frame_ok = 0;
600 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
601 frame_ok = framelen > 4
602 ? upload_data( dev, framelen, frameno, is_first, crc )
603 : skip_tail( ioaddr, framelen, crc );
604 if( frame_ok )
605 interpret_ack( dev, ack );
608 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
609 if( frame_ok ) {
610 nl->state |= FL_PREV_OK;
611 if( framelen > 4 )
612 nl->in_stats.all_rx_number++;
613 } else
614 nl->state &= ~FL_PREV_OK,
615 change_level( dev ),
616 nl->in_stats.all_rx_number++,
617 nl->in_stats.bad_rx_number++;
619 return !frame_ok || framelen > 4;
623 static void
624 send_frame( struct net_device *dev )
626 struct net_local *nl = (struct net_local *) dev->priv;
628 u32 crc = CRC32_INITIAL;
630 if( nl->state & FL_NEED_RESEND ) {
632 /* if frame was sended but not ACK'ed - resend it */
633 if( nl->trans_errors ) {
634 --nl->trans_errors;
635 if( nl->framelen != 0 )
636 nl->in_stats.resend_tx_number++;
637 } else {
638 /* cannot xmit with many attempts */
639 #ifdef CONFIG_SBNI_MULTILINE
640 if( (nl->state & FL_SLAVE) || nl->link )
641 #endif
642 nl->state |= FL_LINE_DOWN;
643 drop_xmit_queue( dev );
644 goto do_send;
646 } else
647 nl->trans_errors = TR_ERROR_COUNT;
649 send_frame_header( dev, &crc );
650 nl->state |= FL_NEED_RESEND;
652 * FL_NEED_RESEND will be cleared after ACK, but if empty
653 * frame sended then in prepare_to_send next frame
657 if( nl->framelen ) {
658 download_data( dev, &crc );
659 nl->in_stats.all_tx_number++;
660 nl->state |= FL_WAIT_ACK;
663 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
665 do_send:
666 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
668 if( nl->tx_frameno )
669 /* next frame exists - we request card to send it */
670 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
671 dev->base_addr + CSR0 );
676 * Write the frame data into adapter's buffer memory, and calculate CRC.
677 * Do padding if necessary.
680 static void
681 download_data( struct net_device *dev, u32 *crc_p )
683 struct net_local *nl = (struct net_local *) dev->priv;
684 struct sk_buff *skb = nl->tx_buf_p;
686 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
688 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
689 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
691 /* if packet too short we should write some more bytes to pad */
692 for( len = nl->framelen - len; len--; )
693 outb( 0, dev->base_addr + DAT ),
694 *crc_p = CRC32( 0, *crc_p );
698 static int
699 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
700 unsigned is_first, u32 crc )
702 struct net_local *nl = (struct net_local *) dev->priv;
704 int frame_ok;
706 if( is_first )
707 nl->wait_frameno = frameno,
708 nl->inppos = 0;
710 if( nl->wait_frameno == frameno ) {
712 if( nl->inppos + framelen <= ETHER_MAX_LEN )
713 frame_ok = append_frame_to_pkt( dev, framelen, crc );
716 * if CRC is right but framelen incorrect then transmitter
717 * error was occurred... drop entire packet
719 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
720 != 0 )
721 nl->wait_frameno = 0,
722 nl->inppos = 0,
723 #ifdef CONFIG_SBNI_MULTILINE
724 ((struct net_local *) nl->master->priv)
725 ->stats.rx_errors++,
726 ((struct net_local *) nl->master->priv)
727 ->stats.rx_missed_errors++;
728 #else
729 nl->stats.rx_errors++,
730 nl->stats.rx_missed_errors++;
731 #endif
732 /* now skip all frames until is_first != 0 */
733 } else
734 frame_ok = skip_tail( dev->base_addr, framelen, crc );
736 if( is_first && !frame_ok )
738 * Frame has been broken, but we had already stored
739 * is_first... Drop entire packet.
741 nl->wait_frameno = 0,
742 #ifdef CONFIG_SBNI_MULTILINE
743 ((struct net_local *) nl->master->priv)->stats.rx_errors++,
744 ((struct net_local *) nl->master->priv)->stats.rx_crc_errors++;
745 #else
746 nl->stats.rx_errors++,
747 nl->stats.rx_crc_errors++;
748 #endif
750 return frame_ok;
754 static inline void
755 send_complete( struct net_local *nl )
757 #ifdef CONFIG_SBNI_MULTILINE
758 ((struct net_local *) nl->master->priv)->stats.tx_packets++;
759 ((struct net_local *) nl->master->priv)->stats.tx_bytes
760 += nl->tx_buf_p->len;
761 #else
762 nl->stats.tx_packets++;
763 nl->stats.tx_bytes += nl->tx_buf_p->len;
764 #endif
765 dev_kfree_skb_irq( nl->tx_buf_p );
767 nl->tx_buf_p = NULL;
769 nl->outpos = 0;
770 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
771 nl->framelen = 0;
775 static void
776 interpret_ack( struct net_device *dev, unsigned ack )
778 struct net_local *nl = (struct net_local *) dev->priv;
780 if( ack == FRAME_SENT_OK ) {
781 nl->state &= ~FL_NEED_RESEND;
783 if( nl->state & FL_WAIT_ACK ) {
784 nl->outpos += nl->framelen;
786 if( --nl->tx_frameno )
787 nl->framelen = min_t(unsigned int,
788 nl->maxframe,
789 nl->tx_buf_p->len - nl->outpos);
790 else
791 send_complete( nl ),
792 #ifdef CONFIG_SBNI_MULTILINE
793 netif_wake_queue( nl->master );
794 #else
795 netif_wake_queue( dev );
796 #endif
800 nl->state &= ~FL_WAIT_ACK;
805 * Glue received frame with previous fragments of packet.
806 * Indicate packet when last frame would be accepted.
809 static int
810 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
812 struct net_local *nl = (struct net_local *) dev->priv;
814 u8 *p;
816 if( nl->inppos + framelen > ETHER_MAX_LEN )
817 return 0;
819 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
820 return 0;
822 p = nl->rx_buf_p->data + nl->inppos;
823 insb( dev->base_addr + DAT, p, framelen );
824 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
825 return 0;
827 nl->inppos += framelen - 4;
828 if( --nl->wait_frameno == 0 ) /* last frame received */
829 indicate_pkt( dev );
831 return 1;
836 * Prepare to start output on adapter.
837 * Transmitter will be actually activated when marker is accepted.
840 static void
841 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
843 struct net_local *nl = (struct net_local *) dev->priv;
845 unsigned int len;
847 /* nl->tx_buf_p == NULL here! */
848 if( nl->tx_buf_p )
849 printk( KERN_ERR "%s: memory leak!\n", dev->name );
851 nl->outpos = 0;
852 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
854 len = skb->len;
855 if( len < SBNI_MIN_LEN )
856 len = SBNI_MIN_LEN;
858 nl->tx_buf_p = skb;
859 nl->tx_frameno = (len + nl->maxframe - 1) / nl->maxframe;
860 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
862 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
863 #ifdef CONFIG_SBNI_MULTILINE
864 nl->master->trans_start = jiffies;
865 #else
866 dev->trans_start = jiffies;
867 #endif
871 static void
872 drop_xmit_queue( struct net_device *dev )
874 struct net_local *nl = (struct net_local *) dev->priv;
876 if( nl->tx_buf_p )
877 dev_kfree_skb_any( nl->tx_buf_p ),
878 nl->tx_buf_p = NULL,
879 #ifdef CONFIG_SBNI_MULTILINE
880 ((struct net_local *) nl->master->priv)
881 ->stats.tx_errors++,
882 ((struct net_local *) nl->master->priv)
883 ->stats.tx_carrier_errors++;
884 #else
885 nl->stats.tx_errors++,
886 nl->stats.tx_carrier_errors++;
887 #endif
889 nl->tx_frameno = 0;
890 nl->framelen = 0;
891 nl->outpos = 0;
892 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
893 #ifdef CONFIG_SBNI_MULTILINE
894 netif_start_queue( nl->master );
895 nl->master->trans_start = jiffies;
896 #else
897 netif_start_queue( dev );
898 dev->trans_start = jiffies;
899 #endif
903 static void
904 send_frame_header( struct net_device *dev, u32 *crc_p )
906 struct net_local *nl = (struct net_local *) dev->priv;
908 u32 crc = *crc_p;
909 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
910 u8 value;
912 if( nl->state & FL_NEED_RESEND )
913 len_field |= FRAME_RETRY; /* non-first attempt... */
915 if( nl->outpos == 0 )
916 len_field |= FRAME_FIRST;
918 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
919 outb( SBNI_SIG, dev->base_addr + DAT );
921 value = (u8) len_field;
922 outb( value, dev->base_addr + DAT );
923 crc = CRC32( value, crc );
924 value = (u8) (len_field >> 8);
925 outb( value, dev->base_addr + DAT );
926 crc = CRC32( value, crc );
928 outb( nl->tx_frameno, dev->base_addr + DAT );
929 crc = CRC32( nl->tx_frameno, crc );
930 outb( 0, dev->base_addr + DAT );
931 crc = CRC32( 0, crc );
932 *crc_p = crc;
937 * if frame tail not needed (incorrect number or received twice),
938 * it won't store, but CRC will be calculated
941 static int
942 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
944 while( tail_len-- )
945 crc = CRC32( inb( ioaddr + DAT ), crc );
947 return crc == CRC32_REMAINDER;
952 * Preliminary checks if frame header is correct, calculates its CRC
953 * and split it to simple fields
956 static int
957 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
958 u32 *is_first, u32 *crc_p )
960 u32 crc = *crc_p;
961 u8 value;
963 if( inb( ioaddr + DAT ) != SBNI_SIG )
964 return 0;
966 value = inb( ioaddr + DAT );
967 *framelen = (u32)value;
968 crc = CRC32( value, crc );
969 value = inb( ioaddr + DAT );
970 *framelen |= ((u32)value) << 8;
971 crc = CRC32( value, crc );
973 *ack = *framelen & FRAME_ACK_MASK;
974 *is_first = (*framelen & FRAME_FIRST) != 0;
976 if( (*framelen &= FRAME_LEN_MASK) < 6
977 || *framelen > SBNI_MAX_FRAME - 3 )
978 return 0;
980 value = inb( ioaddr + DAT );
981 *frameno = (u32)value;
982 crc = CRC32( value, crc );
984 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
985 *framelen -= 2;
987 *crc_p = crc;
988 return 1;
992 static struct sk_buff *
993 get_rx_buf( struct net_device *dev )
995 /* +2 is to compensate for the alignment fixup below */
996 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
997 if( !skb )
998 return NULL;
1000 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1001 return skb;
1005 static void
1006 indicate_pkt( struct net_device *dev )
1008 struct net_local *nl = (struct net_local *) dev->priv;
1009 struct sk_buff *skb = nl->rx_buf_p;
1011 skb_put( skb, nl->inppos );
1013 #ifdef CONFIG_SBNI_MULTILINE
1014 skb->protocol = eth_type_trans( skb, nl->master );
1015 netif_rx( skb );
1016 dev->last_rx = jiffies;
1017 ++((struct net_local *) nl->master->priv)->stats.rx_packets;
1018 ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
1019 #else
1020 skb->protocol = eth_type_trans( skb, dev );
1021 netif_rx( skb );
1022 dev->last_rx = jiffies;
1023 ++nl->stats.rx_packets;
1024 nl->stats.rx_bytes += nl->inppos;
1025 #endif
1026 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1030 /* -------------------------------------------------------------------------- */
1033 * Routine checks periodically wire activity and regenerates marker if
1034 * connect was inactive for a long time.
1037 static void
1038 sbni_watchdog( unsigned long arg )
1040 struct net_device *dev = (struct net_device *) arg;
1041 struct net_local *nl = (struct net_local *) dev->priv;
1042 struct timer_list *w = &nl->watchdog;
1043 unsigned long flags;
1044 unsigned char csr0;
1046 spin_lock_irqsave( &nl->lock, flags );
1048 csr0 = inb( dev->base_addr + CSR0 );
1049 if( csr0 & RC_CHK ) {
1051 if( nl->timer_ticks ) {
1052 if( csr0 & (RC_RDY | BU_EMP) )
1053 /* receiving not active */
1054 nl->timer_ticks--;
1055 } else {
1056 nl->in_stats.timeout_number++;
1057 if( nl->delta_rxl )
1058 timeout_change_level( dev );
1060 outb( *(u_char *)&nl->csr1 | PR_RES,
1061 dev->base_addr + CSR1 );
1062 csr0 = inb( dev->base_addr + CSR0 );
1064 } else
1065 nl->state &= ~FL_LINE_DOWN;
1067 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1069 init_timer( w );
1070 w->expires = jiffies + SBNI_TIMEOUT;
1071 w->data = arg;
1072 w->function = sbni_watchdog;
1073 add_timer( w );
1075 spin_unlock_irqrestore( &nl->lock, flags );
1079 static unsigned char rxl_tab[] = {
1080 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1081 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1084 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1085 static unsigned char timeout_rxl_tab[] = {
1086 0x03, 0x05, 0x08, 0x0b
1089 /* -------------------------------------------------------------------------- */
1091 static void
1092 card_start( struct net_device *dev )
1094 struct net_local *nl = (struct net_local *) dev->priv;
1096 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1097 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1098 nl->state |= FL_PREV_OK;
1100 nl->inppos = nl->outpos = 0;
1101 nl->wait_frameno = 0;
1102 nl->tx_frameno = 0;
1103 nl->framelen = 0;
1105 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1106 outb( EN_INT, dev->base_addr + CSR0 );
1109 /* -------------------------------------------------------------------------- */
1111 /* Receive level auto-selection */
1113 static void
1114 change_level( struct net_device *dev )
1116 struct net_local *nl = (struct net_local *) dev->priv;
1118 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1119 return;
1121 if( nl->cur_rxl_index == 0 )
1122 nl->delta_rxl = 1;
1123 else if( nl->cur_rxl_index == 15 )
1124 nl->delta_rxl = -1;
1125 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1126 nl->delta_rxl = -nl->delta_rxl;
1128 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1129 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1130 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1132 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1133 nl->cur_rxl_rcvd = 0;
1137 static void
1138 timeout_change_level( struct net_device *dev )
1140 struct net_local *nl = (struct net_local *) dev->priv;
1142 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1143 if( ++nl->timeout_rxl >= 4 )
1144 nl->timeout_rxl = 0;
1146 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1147 inb( dev->base_addr + CSR0 );
1148 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1150 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1151 nl->cur_rxl_rcvd = 0;
1154 /* -------------------------------------------------------------------------- */
1157 * Open/initialize the board.
1160 static int
1161 sbni_open( struct net_device *dev )
1163 struct net_local *nl = (struct net_local *) dev->priv;
1164 struct timer_list *w = &nl->watchdog;
1167 * For double ISA adapters within "common irq" mode, we have to
1168 * determine whether primary or secondary channel is initialized,
1169 * and set the irq handler only in first case.
1171 if( dev->base_addr < 0x400 ) { /* ISA only */
1172 struct net_device **p = sbni_cards;
1173 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1174 if( (*p)->irq == dev->irq
1175 && ((*p)->base_addr == dev->base_addr + 4
1176 || (*p)->base_addr == dev->base_addr - 4)
1177 && (*p)->flags & IFF_UP ) {
1179 ((struct net_local *) ((*p)->priv))
1180 ->second = dev;
1181 printk( KERN_NOTICE "%s: using shared irq "
1182 "with %s\n", dev->name, (*p)->name );
1183 nl->state |= FL_SECONDARY;
1184 goto handler_attached;
1188 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1189 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1190 dev->name, dev->irq );
1191 return -EAGAIN;
1194 handler_attached:
1196 spin_lock( &nl->lock );
1197 memset( &nl->stats, 0, sizeof(struct net_device_stats) );
1198 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1200 card_start( dev );
1202 netif_start_queue( dev );
1204 /* set timer watchdog */
1205 init_timer( w );
1206 w->expires = jiffies + SBNI_TIMEOUT;
1207 w->data = (unsigned long) dev;
1208 w->function = sbni_watchdog;
1209 add_timer( w );
1211 spin_unlock( &nl->lock );
1212 return 0;
1216 static int
1217 sbni_close( struct net_device *dev )
1219 struct net_local *nl = (struct net_local *) dev->priv;
1221 if( nl->second && nl->second->flags & IFF_UP ) {
1222 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1223 nl->second->name );
1224 return -EBUSY;
1227 #ifdef CONFIG_SBNI_MULTILINE
1228 if( nl->state & FL_SLAVE )
1229 emancipate( dev );
1230 else
1231 while( nl->link ) /* it's master device! */
1232 emancipate( nl->link );
1233 #endif
1235 spin_lock( &nl->lock );
1237 nl->second = NULL;
1238 drop_xmit_queue( dev );
1239 netif_stop_queue( dev );
1241 del_timer( &nl->watchdog );
1243 outb( 0, dev->base_addr + CSR0 );
1245 if( !(nl->state & FL_SECONDARY) )
1246 free_irq( dev->irq, dev );
1247 nl->state &= FL_SECONDARY;
1249 spin_unlock( &nl->lock );
1250 return 0;
1255 Valid combinations in CSR0 (for probing):
1257 VALID_DECODER 0000,0011,1011,1010
1259 ; 0 ; -
1260 TR_REQ ; 1 ; +
1261 TR_RDY ; 2 ; -
1262 TR_RDY TR_REQ ; 3 ; +
1263 BU_EMP ; 4 ; +
1264 BU_EMP TR_REQ ; 5 ; +
1265 BU_EMP TR_RDY ; 6 ; -
1266 BU_EMP TR_RDY TR_REQ ; 7 ; +
1267 RC_RDY ; 8 ; +
1268 RC_RDY TR_REQ ; 9 ; +
1269 RC_RDY TR_RDY ; 10 ; -
1270 RC_RDY TR_RDY TR_REQ ; 11 ; -
1271 RC_RDY BU_EMP ; 12 ; -
1272 RC_RDY BU_EMP TR_REQ ; 13 ; -
1273 RC_RDY BU_EMP TR_RDY ; 14 ; -
1274 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1277 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1280 static int
1281 sbni_card_probe( unsigned long ioaddr )
1283 unsigned char csr0;
1285 csr0 = inb( ioaddr + CSR0 );
1286 if( csr0 != 0xff && csr0 != 0x00 ) {
1287 csr0 &= ~EN_INT;
1288 if( csr0 & BU_EMP )
1289 csr0 |= EN_INT;
1291 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1292 return 0;
1295 return -ENODEV;
1298 /* -------------------------------------------------------------------------- */
1300 static int
1301 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1303 struct net_local *nl = (struct net_local *) dev->priv;
1304 struct sbni_flags flags;
1305 int error = 0;
1307 #ifdef CONFIG_SBNI_MULTILINE
1308 struct net_device *slave_dev;
1309 char slave_name[ 8 ];
1310 #endif
1312 switch( cmd ) {
1313 case SIOCDEVGETINSTATS :
1314 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1315 sizeof(struct sbni_in_stats) ))
1316 error = -EFAULT;
1317 break;
1319 case SIOCDEVRESINSTATS :
1320 if( current->euid != 0 ) /* root only */
1321 return -EPERM;
1322 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1323 break;
1325 case SIOCDEVGHWSTATE :
1326 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1327 flags.rate = nl->csr1.rate;
1328 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1329 flags.rxl = nl->cur_rxl_index;
1330 flags.fixed_rxl = nl->delta_rxl == 0;
1332 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1333 error = -EFAULT;
1334 break;
1336 case SIOCDEVSHWSTATE :
1337 if( current->euid != 0 ) /* root only */
1338 return -EPERM;
1340 spin_lock( &nl->lock );
1341 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1342 if( flags.fixed_rxl )
1343 nl->delta_rxl = 0,
1344 nl->cur_rxl_index = flags.rxl;
1345 else
1346 nl->delta_rxl = DEF_RXL_DELTA,
1347 nl->cur_rxl_index = DEF_RXL;
1349 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1350 nl->csr1.rate = flags.rate;
1351 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1352 spin_unlock( &nl->lock );
1353 break;
1355 #ifdef CONFIG_SBNI_MULTILINE
1357 case SIOCDEVENSLAVE :
1358 if( current->euid != 0 ) /* root only */
1359 return -EPERM;
1361 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1362 return -EFAULT;
1363 slave_dev = dev_get_by_name(&init_net, slave_name );
1364 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1365 printk( KERN_ERR "%s: trying to enslave non-active "
1366 "device %s\n", dev->name, slave_name );
1367 return -EPERM;
1370 return enslave( dev, slave_dev );
1372 case SIOCDEVEMANSIPATE :
1373 if( current->euid != 0 ) /* root only */
1374 return -EPERM;
1376 return emancipate( dev );
1378 #endif /* CONFIG_SBNI_MULTILINE */
1380 default :
1381 return -EOPNOTSUPP;
1384 return error;
1388 #ifdef CONFIG_SBNI_MULTILINE
1390 static int
1391 enslave( struct net_device *dev, struct net_device *slave_dev )
1393 struct net_local *nl = (struct net_local *) dev->priv;
1394 struct net_local *snl = (struct net_local *) slave_dev->priv;
1396 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1397 return -EBUSY;
1399 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1400 return -EBUSY;
1402 spin_lock( &nl->lock );
1403 spin_lock( &snl->lock );
1405 /* append to list */
1406 snl->link = nl->link;
1407 nl->link = slave_dev;
1408 snl->master = dev;
1409 snl->state |= FL_SLAVE;
1411 /* Summary statistics of MultiLine operation will be stored
1412 in master's counters */
1413 memset( &snl->stats, 0, sizeof(struct net_device_stats) );
1414 netif_stop_queue( slave_dev );
1415 netif_wake_queue( dev ); /* Now we are able to transmit */
1417 spin_unlock( &snl->lock );
1418 spin_unlock( &nl->lock );
1419 printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1420 dev->name, slave_dev->name );
1421 return 0;
1425 static int
1426 emancipate( struct net_device *dev )
1428 struct net_local *snl = (struct net_local *) dev->priv;
1429 struct net_device *p = snl->master;
1430 struct net_local *nl = (struct net_local *) p->priv;
1432 if( !(snl->state & FL_SLAVE) )
1433 return -EINVAL;
1435 spin_lock( &nl->lock );
1436 spin_lock( &snl->lock );
1437 drop_xmit_queue( dev );
1439 /* exclude from list */
1440 for(;;) { /* must be in list */
1441 struct net_local *t = (struct net_local *) p->priv;
1442 if( t->link == dev ) {
1443 t->link = snl->link;
1444 break;
1446 p = t->link;
1449 snl->link = NULL;
1450 snl->master = dev;
1451 snl->state &= ~FL_SLAVE;
1453 netif_start_queue( dev );
1455 spin_unlock( &snl->lock );
1456 spin_unlock( &nl->lock );
1458 dev_put( dev );
1459 return 0;
1462 #endif
1465 static struct net_device_stats *
1466 sbni_get_stats( struct net_device *dev )
1468 return &((struct net_local *) dev->priv)->stats;
1472 static void
1473 set_multicast_list( struct net_device *dev )
1475 return; /* sbni always operate in promiscuos mode */
1479 #ifdef MODULE
1480 module_param_array(io, int, NULL, 0);
1481 module_param_array(irq, int, NULL, 0);
1482 module_param_array(baud, int, NULL, 0);
1483 module_param_array(rxl, int, NULL, 0);
1484 module_param_array(mac, int, NULL, 0);
1485 module_param(skip_pci_probe, bool, 0);
1487 MODULE_LICENSE("GPL");
1490 int __init init_module( void )
1492 struct net_device *dev;
1493 int err;
1495 while( num < SBNI_MAX_NUM_CARDS ) {
1496 dev = alloc_netdev(sizeof(struct net_local),
1497 "sbni%d", sbni_devsetup);
1498 if( !dev)
1499 break;
1501 sprintf( dev->name, "sbni%d", num );
1503 err = sbni_init(dev);
1504 if (err) {
1505 free_netdev(dev);
1506 break;
1509 if( register_netdev( dev ) ) {
1510 release_region( dev->base_addr, SBNI_IO_EXTENT );
1511 free_netdev( dev );
1512 break;
1516 return *sbni_cards ? 0 : -ENODEV;
1519 void
1520 cleanup_module( void )
1522 struct net_device *dev;
1523 int num;
1525 for( num = 0; num < SBNI_MAX_NUM_CARDS; ++num )
1526 if( (dev = sbni_cards[ num ]) != NULL ) {
1527 unregister_netdev( dev );
1528 release_region( dev->base_addr, SBNI_IO_EXTENT );
1529 free_netdev( dev );
1533 #else /* MODULE */
1535 static int __init
1536 sbni_setup( char *p )
1538 int n, parm;
1540 if( *p++ != '(' )
1541 goto bad_param;
1543 for( n = 0, parm = 0; *p && n < 8; ) {
1544 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1545 if( !*p || *p == ')' )
1546 return 1;
1547 if( *p == ';' )
1548 ++p, ++n, parm = 0;
1549 else if( *p++ != ',' )
1550 break;
1551 else
1552 if( ++parm >= 5 )
1553 break;
1555 bad_param:
1556 printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1557 return 0;
1560 __setup( "sbni=", sbni_setup );
1562 #endif /* MODULE */
1564 /* -------------------------------------------------------------------------- */
1566 #ifdef ASM_CRC
1568 static u32
1569 calc_crc32( u32 crc, u8 *p, u32 len )
1571 register u32 _crc;
1572 _crc = crc;
1574 __asm__ __volatile__ (
1575 "xorl %%ebx, %%ebx\n"
1576 "movl %2, %%esi\n"
1577 "movl %3, %%ecx\n"
1578 "movl $crc32tab, %%edi\n"
1579 "shrl $2, %%ecx\n"
1580 "jz 1f\n"
1582 ".align 4\n"
1583 "0:\n"
1584 "movb %%al, %%bl\n"
1585 "movl (%%esi), %%edx\n"
1586 "shrl $8, %%eax\n"
1587 "xorb %%dl, %%bl\n"
1588 "shrl $8, %%edx\n"
1589 "xorl (%%edi,%%ebx,4), %%eax\n"
1591 "movb %%al, %%bl\n"
1592 "shrl $8, %%eax\n"
1593 "xorb %%dl, %%bl\n"
1594 "shrl $8, %%edx\n"
1595 "xorl (%%edi,%%ebx,4), %%eax\n"
1597 "movb %%al, %%bl\n"
1598 "shrl $8, %%eax\n"
1599 "xorb %%dl, %%bl\n"
1600 "movb %%dh, %%dl\n"
1601 "xorl (%%edi,%%ebx,4), %%eax\n"
1603 "movb %%al, %%bl\n"
1604 "shrl $8, %%eax\n"
1605 "xorb %%dl, %%bl\n"
1606 "addl $4, %%esi\n"
1607 "xorl (%%edi,%%ebx,4), %%eax\n"
1609 "decl %%ecx\n"
1610 "jnz 0b\n"
1612 "1:\n"
1613 "movl %3, %%ecx\n"
1614 "andl $3, %%ecx\n"
1615 "jz 2f\n"
1617 "movb %%al, %%bl\n"
1618 "shrl $8, %%eax\n"
1619 "xorb (%%esi), %%bl\n"
1620 "xorl (%%edi,%%ebx,4), %%eax\n"
1622 "decl %%ecx\n"
1623 "jz 2f\n"
1625 "movb %%al, %%bl\n"
1626 "shrl $8, %%eax\n"
1627 "xorb 1(%%esi), %%bl\n"
1628 "xorl (%%edi,%%ebx,4), %%eax\n"
1630 "decl %%ecx\n"
1631 "jz 2f\n"
1633 "movb %%al, %%bl\n"
1634 "shrl $8, %%eax\n"
1635 "xorb 2(%%esi), %%bl\n"
1636 "xorl (%%edi,%%ebx,4), %%eax\n"
1637 "2:\n"
1638 : "=a" (_crc)
1639 : "0" (_crc), "g" (p), "g" (len)
1640 : "bx", "cx", "dx", "si", "di"
1643 return _crc;
1646 #else /* ASM_CRC */
1648 static u32
1649 calc_crc32( u32 crc, u8 *p, u32 len )
1651 while( len-- )
1652 crc = CRC32( *p++, crc );
1654 return crc;
1657 #endif /* ASM_CRC */
1660 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1661 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1662 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1663 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1664 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1665 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1666 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1667 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1668 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1669 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1670 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1671 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1672 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1673 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1674 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1675 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1676 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1677 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1678 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1679 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1680 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1681 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1682 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1683 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1684 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1685 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1686 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1687 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1688 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1689 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1690 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1691 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1692 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1693 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1694 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1695 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1696 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1697 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1698 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1699 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1700 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1701 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1702 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1703 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1704 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1705 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1706 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1707 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1708 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1709 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1710 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1711 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1712 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1713 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1714 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1715 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1716 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1717 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1718 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1719 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1720 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1721 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1722 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1723 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1724 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000