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