Loading...
Note: File does not exist in v6.8.
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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
41
42#include <linux/module.h>
43#include <linux/kernel.h>
44#include <linux/ptrace.h>
45#include <linux/fcntl.h>
46#include <linux/ioport.h>
47#include <linux/interrupt.h>
48#include <linux/string.h>
49#include <linux/errno.h>
50#include <linux/netdevice.h>
51#include <linux/etherdevice.h>
52#include <linux/pci.h>
53#include <linux/skbuff.h>
54#include <linux/timer.h>
55#include <linux/init.h>
56#include <linux/delay.h>
57
58#include <net/net_namespace.h>
59#include <net/arp.h>
60#include <net/Space.h>
61
62#include <asm/io.h>
63#include <asm/types.h>
64#include <asm/byteorder.h>
65#include <asm/irq.h>
66#include <linux/uaccess.h>
67
68#include "sbni.h"
69
70/* device private data */
71
72struct net_local {
73 struct timer_list watchdog;
74 struct net_device *watchdog_dev;
75
76 spinlock_t lock;
77 struct sk_buff *rx_buf_p; /* receive buffer ptr */
78 struct sk_buff *tx_buf_p; /* transmit buffer ptr */
79
80 unsigned int framelen; /* current frame length */
81 unsigned int maxframe; /* maximum valid frame length */
82 unsigned int state;
83 unsigned int inppos, outpos; /* positions in rx/tx buffers */
84
85 /* transmitting frame number - from frames qty to 1 */
86 unsigned int tx_frameno;
87
88 /* expected number of next receiving frame */
89 unsigned int wait_frameno;
90
91 /* count of failed attempts to frame send - 32 attempts do before
92 error - while receiver tunes on opposite side of wire */
93 unsigned int trans_errors;
94
95 /* idle time; send pong when limit exceeded */
96 unsigned int timer_ticks;
97
98 /* fields used for receive level autoselection */
99 int delta_rxl;
100 unsigned int cur_rxl_index, timeout_rxl;
101 unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
102
103 struct sbni_csr1 csr1; /* current value of CSR1 */
104 struct sbni_in_stats in_stats; /* internal statistics */
105
106 struct net_device *second; /* for ISA/dual cards */
107
108#ifdef CONFIG_SBNI_MULTILINE
109 struct net_device *master;
110 struct net_device *link;
111#endif
112};
113
114
115static int sbni_card_probe( unsigned long );
116static int sbni_pci_probe( struct net_device * );
117static struct net_device *sbni_probe1(struct net_device *, unsigned long, int);
118static int sbni_open( struct net_device * );
119static int sbni_close( struct net_device * );
120static netdev_tx_t sbni_start_xmit(struct sk_buff *,
121 struct net_device * );
122static int sbni_ioctl( struct net_device *, struct ifreq *, int );
123static void set_multicast_list( struct net_device * );
124
125static irqreturn_t sbni_interrupt( int, void * );
126static void handle_channel( struct net_device * );
127static int recv_frame( struct net_device * );
128static void send_frame( struct net_device * );
129static int upload_data( struct net_device *,
130 unsigned, unsigned, unsigned, u32 );
131static void download_data( struct net_device *, u32 * );
132static void sbni_watchdog(struct timer_list *);
133static void interpret_ack( struct net_device *, unsigned );
134static int append_frame_to_pkt( struct net_device *, unsigned, u32 );
135static void indicate_pkt( struct net_device * );
136static void card_start( struct net_device * );
137static void prepare_to_send( struct sk_buff *, struct net_device * );
138static void drop_xmit_queue( struct net_device * );
139static void send_frame_header( struct net_device *, u32 * );
140static int skip_tail( unsigned int, unsigned int, u32 );
141static int check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
142static void change_level( struct net_device * );
143static void timeout_change_level( struct net_device * );
144static u32 calc_crc32( u32, u8 *, u32 );
145static struct sk_buff * get_rx_buf( struct net_device * );
146static int sbni_init( struct net_device * );
147
148#ifdef CONFIG_SBNI_MULTILINE
149static int enslave( struct net_device *, struct net_device * );
150static int emancipate( struct net_device * );
151#endif
152
153static const char version[] =
154 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
155
156static bool skip_pci_probe __initdata = false;
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 *dest[5] __initdata = { &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 pr_err("base address 0x%lx is busy, or adapter is malfunctional!\n",
204 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_rx_mode = set_multicast_list,
214 .ndo_do_ioctl = sbni_ioctl,
215 .ndo_set_mac_address = eth_mac_addr,
216 .ndo_validate_addr = eth_validate_addr,
217};
218
219static void __init sbni_devsetup(struct net_device *dev)
220{
221 ether_setup( dev );
222 dev->netdev_ops = &sbni_netdev_ops;
223}
224
225int __init sbni_probe(int unit)
226{
227 struct net_device *dev;
228 int err;
229
230 dev = alloc_netdev(sizeof(struct net_local), "sbni",
231 NET_NAME_UNKNOWN, sbni_devsetup);
232 if (!dev)
233 return -ENOMEM;
234
235 dev->netdev_ops = &sbni_netdev_ops;
236
237 sprintf(dev->name, "sbni%d", unit);
238 netdev_boot_setup_check(dev);
239
240 err = sbni_init(dev);
241 if (err) {
242 free_netdev(dev);
243 return err;
244 }
245
246 err = register_netdev(dev);
247 if (err) {
248 release_region( dev->base_addr, SBNI_IO_EXTENT );
249 free_netdev(dev);
250 return err;
251 }
252 pr_info_once("%s", version);
253 return 0;
254}
255
256static int __init sbni_init(struct net_device *dev)
257{
258 int i;
259 if( dev->base_addr )
260 return sbni_isa_probe( dev );
261 /* otherwise we have to perform search our adapter */
262
263 if( io[ num ] != -1 ) {
264 dev->base_addr = io[ num ];
265 dev->irq = irq[ num ];
266 } else if( scandone || io[ 0 ] != -1 ) {
267 return -ENODEV;
268 }
269
270 /* if io[ num ] contains non-zero address, then that is on ISA bus */
271 if( dev->base_addr )
272 return sbni_isa_probe( dev );
273
274 /* ...otherwise - scan PCI first */
275 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
276 return 0;
277
278 if( io[ num ] == -1 ) {
279 /* Auto-scan will be stopped when first ISA card were found */
280 scandone = 1;
281 if( num > 0 )
282 return -ENODEV;
283 }
284
285 for( i = 0; netcard_portlist[ i ]; ++i ) {
286 int ioaddr = netcard_portlist[ i ];
287 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name ) &&
288 sbni_probe1( dev, ioaddr, 0 ))
289 return 0;
290 }
291
292 return -ENODEV;
293}
294
295
296static int __init
297sbni_pci_probe( struct net_device *dev )
298{
299 struct pci_dev *pdev = NULL;
300
301 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
302 != NULL ) {
303 int pci_irq_line;
304 unsigned long pci_ioaddr;
305
306 if( pdev->vendor != SBNI_PCI_VENDOR &&
307 pdev->device != SBNI_PCI_DEVICE )
308 continue;
309
310 pci_ioaddr = pci_resource_start( pdev, 0 );
311 pci_irq_line = pdev->irq;
312
313 /* Avoid already found cards from previous calls */
314 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
315 if (pdev->subsystem_device != 2)
316 continue;
317
318 /* Dual adapter is present */
319 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
320 dev->name ) )
321 continue;
322 }
323
324 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
325 pr_warn(
326"WARNING: The PCI BIOS assigned this PCI card to IRQ %d, which is unlikely to work!.\n"
327"You should use the PCI BIOS setup to assign a valid IRQ line.\n",
328 pci_irq_line );
329
330 /* avoiding re-enable dual adapters */
331 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
332 release_region( pci_ioaddr, SBNI_IO_EXTENT );
333 pci_dev_put( pdev );
334 return -EIO;
335 }
336 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
337 SET_NETDEV_DEV(dev, &pdev->dev);
338 /* not the best thing to do, but this is all messed up
339 for hotplug systems anyway... */
340 pci_dev_put( pdev );
341 return 0;
342 }
343 }
344 return -ENODEV;
345}
346
347
348static struct net_device * __init
349sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
350{
351 struct net_local *nl;
352
353 if( sbni_card_probe( ioaddr ) ) {
354 release_region( ioaddr, SBNI_IO_EXTENT );
355 return NULL;
356 }
357
358 outb( 0, ioaddr + CSR0 );
359
360 if( irq < 2 ) {
361 unsigned long irq_mask;
362
363 irq_mask = probe_irq_on();
364 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
365 outb( PR_RES, ioaddr + CSR1 );
366 mdelay(50);
367 irq = probe_irq_off(irq_mask);
368 outb( 0, ioaddr + CSR0 );
369
370 if( !irq ) {
371 pr_err("%s: can't detect device irq!\n", dev->name);
372 release_region( ioaddr, SBNI_IO_EXTENT );
373 return NULL;
374 }
375 } else if( irq == 2 )
376 irq = 9;
377
378 dev->irq = irq;
379 dev->base_addr = ioaddr;
380
381 /* Fill in sbni-specific dev fields. */
382 nl = netdev_priv(dev);
383 if( !nl ) {
384 pr_err("%s: unable to get memory!\n", dev->name);
385 release_region( ioaddr, SBNI_IO_EXTENT );
386 return NULL;
387 }
388
389 memset( nl, 0, sizeof(struct net_local) );
390 spin_lock_init( &nl->lock );
391
392 /* store MAC address (generate if that isn't known) */
393 *(__be16 *)dev->dev_addr = htons( 0x00ff );
394 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
395 ((mac[num] ?
396 mac[num] :
397 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
398
399 /* store link settings (speed, receive level ) */
400 nl->maxframe = DEFAULT_FRAME_LEN;
401 nl->csr1.rate = baud[ num ];
402
403 if( (nl->cur_rxl_index = rxl[ num ]) == -1 ) {
404 /* autotune rxl */
405 nl->cur_rxl_index = DEF_RXL;
406 nl->delta_rxl = DEF_RXL_DELTA;
407 } else {
408 nl->delta_rxl = 0;
409 }
410 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
411 if( inb( ioaddr + CSR0 ) & 0x01 )
412 nl->state |= FL_SLOW_MODE;
413
414 pr_notice("%s: ioaddr %#lx, irq %d, MAC: 00:ff:01:%02x:%02x:%02x\n",
415 dev->name, dev->base_addr, dev->irq,
416 ((u8 *)dev->dev_addr)[3],
417 ((u8 *)dev->dev_addr)[4],
418 ((u8 *)dev->dev_addr)[5]);
419
420 pr_notice("%s: speed %d",
421 dev->name,
422 ((nl->state & FL_SLOW_MODE) ? 500000 : 2000000)
423 / (1 << nl->csr1.rate));
424
425 if( nl->delta_rxl == 0 )
426 pr_cont(", receive level 0x%x (fixed)\n", nl->cur_rxl_index);
427 else
428 pr_cont(", receive level (auto)\n");
429
430#ifdef CONFIG_SBNI_MULTILINE
431 nl->master = dev;
432 nl->link = NULL;
433#endif
434
435 sbni_cards[ num++ ] = dev;
436 return dev;
437}
438
439/* -------------------------------------------------------------------------- */
440
441#ifdef CONFIG_SBNI_MULTILINE
442
443static netdev_tx_t
444sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
445{
446 struct net_device *p;
447
448 netif_stop_queue( dev );
449
450 /* Looking for idle device in the list */
451 for( p = dev; p; ) {
452 struct net_local *nl = netdev_priv(p);
453 spin_lock( &nl->lock );
454 if( nl->tx_buf_p || (nl->state & FL_LINE_DOWN) ) {
455 p = nl->link;
456 spin_unlock( &nl->lock );
457 } else {
458 /* Idle dev is found */
459 prepare_to_send( skb, p );
460 spin_unlock( &nl->lock );
461 netif_start_queue( dev );
462 return NETDEV_TX_OK;
463 }
464 }
465
466 return NETDEV_TX_BUSY;
467}
468
469#else /* CONFIG_SBNI_MULTILINE */
470
471static netdev_tx_t
472sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
473{
474 struct net_local *nl = netdev_priv(dev);
475
476 netif_stop_queue( dev );
477 spin_lock( &nl->lock );
478
479 prepare_to_send( skb, dev );
480
481 spin_unlock( &nl->lock );
482 return NETDEV_TX_OK;
483}
484
485#endif /* CONFIG_SBNI_MULTILINE */
486
487/* -------------------------------------------------------------------------- */
488
489/* interrupt handler */
490
491/*
492 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
493 * be looked as two independent single-channel devices. Every channel seems
494 * as Ethernet interface but interrupt handler must be common. Really, first
495 * channel ("master") driver only registers the handler. In its struct net_local
496 * it has got pointer to "slave" channel's struct net_local and handles that's
497 * interrupts too.
498 * dev of successfully attached ISA SBNI boards is linked to list.
499 * While next board driver is initialized, it scans this list. If one
500 * has found dev with same irq and ioaddr different by 4 then it assumes
501 * this board to be "master".
502 */
503
504static irqreturn_t
505sbni_interrupt( int irq, void *dev_id )
506{
507 struct net_device *dev = dev_id;
508 struct net_local *nl = netdev_priv(dev);
509 int repeat;
510
511 spin_lock( &nl->lock );
512 if( nl->second )
513 spin_lock(&NET_LOCAL_LOCK(nl->second));
514
515 do {
516 repeat = 0;
517 if( inb( dev->base_addr + CSR0 ) & (RC_RDY | TR_RDY) ) {
518 handle_channel( dev );
519 repeat = 1;
520 }
521 if( nl->second && /* second channel present */
522 (inb( nl->second->base_addr+CSR0 ) & (RC_RDY | TR_RDY)) ) {
523 handle_channel( nl->second );
524 repeat = 1;
525 }
526 } while( repeat );
527
528 if( nl->second )
529 spin_unlock(&NET_LOCAL_LOCK(nl->second));
530 spin_unlock( &nl->lock );
531 return IRQ_HANDLED;
532}
533
534
535static void
536handle_channel( struct net_device *dev )
537{
538 struct net_local *nl = netdev_priv(dev);
539 unsigned long ioaddr = dev->base_addr;
540
541 int req_ans;
542 unsigned char csr0;
543
544#ifdef CONFIG_SBNI_MULTILINE
545 /* Lock the master device because we going to change its local data */
546 if( nl->state & FL_SLAVE )
547 spin_lock(&NET_LOCAL_LOCK(nl->master));
548#endif
549
550 outb( (inb( ioaddr + CSR0 ) & ~EN_INT) | TR_REQ, ioaddr + CSR0 );
551
552 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
553 for(;;) {
554 csr0 = inb( ioaddr + CSR0 );
555 if( ( csr0 & (RC_RDY | TR_RDY) ) == 0 )
556 break;
557
558 req_ans = !(nl->state & FL_PREV_OK);
559
560 if( csr0 & RC_RDY )
561 req_ans = recv_frame( dev );
562
563 /*
564 * TR_RDY always equals 1 here because we have owned the marker,
565 * and we set TR_REQ when disabled interrupts
566 */
567 csr0 = inb( ioaddr + CSR0 );
568 if( !(csr0 & TR_RDY) || (csr0 & RC_RDY) )
569 netdev_err(dev, "internal error!\n");
570
571 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
572 if( req_ans || nl->tx_frameno != 0 )
573 send_frame( dev );
574 else
575 /* send marker without any data */
576 outb( inb( ioaddr + CSR0 ) & ~TR_REQ, ioaddr + CSR0 );
577 }
578
579 outb( inb( ioaddr + CSR0 ) | EN_INT, ioaddr + CSR0 );
580
581#ifdef CONFIG_SBNI_MULTILINE
582 if( nl->state & FL_SLAVE )
583 spin_unlock(&NET_LOCAL_LOCK(nl->master));
584#endif
585}
586
587
588/*
589 * Routine returns 1 if it needs to acknowledge received frame.
590 * Empty frame received without errors won't be acknowledged.
591 */
592
593static int
594recv_frame( struct net_device *dev )
595{
596 struct net_local *nl = netdev_priv(dev);
597 unsigned long ioaddr = dev->base_addr;
598
599 u32 crc = CRC32_INITIAL;
600
601 unsigned framelen = 0, frameno, ack;
602 unsigned is_first, frame_ok = 0;
603
604 if( check_fhdr( ioaddr, &framelen, &frameno, &ack, &is_first, &crc ) ) {
605 frame_ok = framelen > 4
606 ? upload_data( dev, framelen, frameno, is_first, crc )
607 : skip_tail( ioaddr, framelen, crc );
608 if( frame_ok )
609 interpret_ack( dev, ack );
610 }
611
612 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
613 if( frame_ok ) {
614 nl->state |= FL_PREV_OK;
615 if( framelen > 4 )
616 nl->in_stats.all_rx_number++;
617 } else {
618 nl->state &= ~FL_PREV_OK;
619 change_level( dev );
620 nl->in_stats.all_rx_number++;
621 nl->in_stats.bad_rx_number++;
622 }
623
624 return !frame_ok || framelen > 4;
625}
626
627
628static void
629send_frame( struct net_device *dev )
630{
631 struct net_local *nl = netdev_priv(dev);
632
633 u32 crc = CRC32_INITIAL;
634
635 if( nl->state & FL_NEED_RESEND ) {
636
637 /* if frame was sended but not ACK'ed - resend it */
638 if( nl->trans_errors ) {
639 --nl->trans_errors;
640 if( nl->framelen != 0 )
641 nl->in_stats.resend_tx_number++;
642 } else {
643 /* cannot xmit with many attempts */
644#ifdef CONFIG_SBNI_MULTILINE
645 if( (nl->state & FL_SLAVE) || nl->link )
646#endif
647 nl->state |= FL_LINE_DOWN;
648 drop_xmit_queue( dev );
649 goto do_send;
650 }
651 } else
652 nl->trans_errors = TR_ERROR_COUNT;
653
654 send_frame_header( dev, &crc );
655 nl->state |= FL_NEED_RESEND;
656 /*
657 * FL_NEED_RESEND will be cleared after ACK, but if empty
658 * frame sended then in prepare_to_send next frame
659 */
660
661
662 if( nl->framelen ) {
663 download_data( dev, &crc );
664 nl->in_stats.all_tx_number++;
665 nl->state |= FL_WAIT_ACK;
666 }
667
668 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
669
670do_send:
671 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
672
673 if( nl->tx_frameno )
674 /* next frame exists - we request card to send it */
675 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
676 dev->base_addr + CSR0 );
677}
678
679
680/*
681 * Write the frame data into adapter's buffer memory, and calculate CRC.
682 * Do padding if necessary.
683 */
684
685static void
686download_data( struct net_device *dev, u32 *crc_p )
687{
688 struct net_local *nl = netdev_priv(dev);
689 struct sk_buff *skb = nl->tx_buf_p;
690
691 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
692
693 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
694 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
695
696 /* if packet too short we should write some more bytes to pad */
697 for( len = nl->framelen - len; len--; ) {
698 outb( 0, dev->base_addr + DAT );
699 *crc_p = CRC32( 0, *crc_p );
700 }
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
717 if( nl->wait_frameno == frameno ) {
718
719 if( nl->inppos + framelen <= ETHER_MAX_LEN )
720 frame_ok = append_frame_to_pkt( dev, framelen, crc );
721
722 /*
723 * if CRC is right but framelen incorrect then transmitter
724 * error was occurred... drop entire packet
725 */
726 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
727 != 0 ) {
728 nl->wait_frameno = 0;
729 nl->inppos = 0;
730#ifdef CONFIG_SBNI_MULTILINE
731 nl->master->stats.rx_errors++;
732 nl->master->stats.rx_missed_errors++;
733#else
734 dev->stats.rx_errors++;
735 dev->stats.rx_missed_errors++;
736#endif
737 }
738 /* now skip all frames until is_first != 0 */
739 } else
740 frame_ok = skip_tail( dev->base_addr, framelen, crc );
741
742 if( is_first && !frame_ok ) {
743 /*
744 * Frame has been broken, but we had already stored
745 * is_first... Drop entire packet.
746 */
747 nl->wait_frameno = 0;
748#ifdef CONFIG_SBNI_MULTILINE
749 nl->master->stats.rx_errors++;
750 nl->master->stats.rx_crc_errors++;
751#else
752 dev->stats.rx_errors++;
753 dev->stats.rx_crc_errors++;
754#endif
755 }
756
757 return frame_ok;
758}
759
760
761static inline void
762send_complete( struct net_device *dev )
763{
764 struct net_local *nl = netdev_priv(dev);
765
766#ifdef CONFIG_SBNI_MULTILINE
767 nl->master->stats.tx_packets++;
768 nl->master->stats.tx_bytes += nl->tx_buf_p->len;
769#else
770 dev->stats.tx_packets++;
771 dev->stats.tx_bytes += nl->tx_buf_p->len;
772#endif
773 dev_consume_skb_irq(nl->tx_buf_p);
774
775 nl->tx_buf_p = NULL;
776
777 nl->outpos = 0;
778 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
779 nl->framelen = 0;
780}
781
782
783static void
784interpret_ack( struct net_device *dev, unsigned ack )
785{
786 struct net_local *nl = netdev_priv(dev);
787
788 if( ack == FRAME_SENT_OK ) {
789 nl->state &= ~FL_NEED_RESEND;
790
791 if( nl->state & FL_WAIT_ACK ) {
792 nl->outpos += nl->framelen;
793
794 if( --nl->tx_frameno ) {
795 nl->framelen = min_t(unsigned int,
796 nl->maxframe,
797 nl->tx_buf_p->len - nl->outpos);
798 } else {
799 send_complete( dev );
800#ifdef CONFIG_SBNI_MULTILINE
801 netif_wake_queue( nl->master );
802#else
803 netif_wake_queue( dev );
804#endif
805 }
806 }
807 }
808
809 nl->state &= ~FL_WAIT_ACK;
810}
811
812
813/*
814 * Glue received frame with previous fragments of packet.
815 * Indicate packet when last frame would be accepted.
816 */
817
818static int
819append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
820{
821 struct net_local *nl = netdev_priv(dev);
822
823 u8 *p;
824
825 if( nl->inppos + framelen > ETHER_MAX_LEN )
826 return 0;
827
828 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
829 return 0;
830
831 p = nl->rx_buf_p->data + nl->inppos;
832 insb( dev->base_addr + DAT, p, framelen );
833 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
834 return 0;
835
836 nl->inppos += framelen - 4;
837 if( --nl->wait_frameno == 0 ) /* last frame received */
838 indicate_pkt( dev );
839
840 return 1;
841}
842
843
844/*
845 * Prepare to start output on adapter.
846 * Transmitter will be actually activated when marker is accepted.
847 */
848
849static void
850prepare_to_send( struct sk_buff *skb, struct net_device *dev )
851{
852 struct net_local *nl = netdev_priv(dev);
853
854 unsigned int len;
855
856 /* nl->tx_buf_p == NULL here! */
857 if( nl->tx_buf_p )
858 netdev_err(dev, "memory leak!\n");
859
860 nl->outpos = 0;
861 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
862
863 len = skb->len;
864 if( len < SBNI_MIN_LEN )
865 len = SBNI_MIN_LEN;
866
867 nl->tx_buf_p = skb;
868 nl->tx_frameno = DIV_ROUND_UP(len, nl->maxframe);
869 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
870
871 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
872#ifdef CONFIG_SBNI_MULTILINE
873 netif_trans_update(nl->master);
874#else
875 netif_trans_update(dev);
876#endif
877}
878
879
880static void
881drop_xmit_queue( struct net_device *dev )
882{
883 struct net_local *nl = netdev_priv(dev);
884
885 if( nl->tx_buf_p ) {
886 dev_kfree_skb_any( nl->tx_buf_p );
887 nl->tx_buf_p = NULL;
888#ifdef CONFIG_SBNI_MULTILINE
889 nl->master->stats.tx_errors++;
890 nl->master->stats.tx_carrier_errors++;
891#else
892 dev->stats.tx_errors++;
893 dev->stats.tx_carrier_errors++;
894#endif
895 }
896
897 nl->tx_frameno = 0;
898 nl->framelen = 0;
899 nl->outpos = 0;
900 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
901#ifdef CONFIG_SBNI_MULTILINE
902 netif_start_queue( nl->master );
903 netif_trans_update(nl->master);
904#else
905 netif_start_queue( dev );
906 netif_trans_update(dev);
907#endif
908}
909
910
911static void
912send_frame_header( struct net_device *dev, u32 *crc_p )
913{
914 struct net_local *nl = netdev_priv(dev);
915
916 u32 crc = *crc_p;
917 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
918 u8 value;
919
920 if( nl->state & FL_NEED_RESEND )
921 len_field |= FRAME_RETRY; /* non-first attempt... */
922
923 if( nl->outpos == 0 )
924 len_field |= FRAME_FIRST;
925
926 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
927 outb( SBNI_SIG, dev->base_addr + DAT );
928
929 value = (u8) len_field;
930 outb( value, dev->base_addr + DAT );
931 crc = CRC32( value, crc );
932 value = (u8) (len_field >> 8);
933 outb( value, dev->base_addr + DAT );
934 crc = CRC32( value, crc );
935
936 outb( nl->tx_frameno, dev->base_addr + DAT );
937 crc = CRC32( nl->tx_frameno, crc );
938 outb( 0, dev->base_addr + DAT );
939 crc = CRC32( 0, crc );
940 *crc_p = crc;
941}
942
943
944/*
945 * if frame tail not needed (incorrect number or received twice),
946 * it won't store, but CRC will be calculated
947 */
948
949static int
950skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
951{
952 while( tail_len-- )
953 crc = CRC32( inb( ioaddr + DAT ), crc );
954
955 return crc == CRC32_REMAINDER;
956}
957
958
959/*
960 * Preliminary checks if frame header is correct, calculates its CRC
961 * and split it to simple fields
962 */
963
964static int
965check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
966 u32 *is_first, u32 *crc_p )
967{
968 u32 crc = *crc_p;
969 u8 value;
970
971 if( inb( ioaddr + DAT ) != SBNI_SIG )
972 return 0;
973
974 value = inb( ioaddr + DAT );
975 *framelen = (u32)value;
976 crc = CRC32( value, crc );
977 value = inb( ioaddr + DAT );
978 *framelen |= ((u32)value) << 8;
979 crc = CRC32( value, crc );
980
981 *ack = *framelen & FRAME_ACK_MASK;
982 *is_first = (*framelen & FRAME_FIRST) != 0;
983
984 if( (*framelen &= FRAME_LEN_MASK) < 6 ||
985 *framelen > SBNI_MAX_FRAME - 3 )
986 return 0;
987
988 value = inb( ioaddr + DAT );
989 *frameno = (u32)value;
990 crc = CRC32( value, crc );
991
992 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
993 *framelen -= 2;
994
995 *crc_p = crc;
996 return 1;
997}
998
999
1000static struct sk_buff *
1001get_rx_buf( struct net_device *dev )
1002{
1003 /* +2 is to compensate for the alignment fixup below */
1004 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1005 if( !skb )
1006 return NULL;
1007
1008 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1009 return skb;
1010}
1011
1012
1013static void
1014indicate_pkt( struct net_device *dev )
1015{
1016 struct net_local *nl = netdev_priv(dev);
1017 struct sk_buff *skb = nl->rx_buf_p;
1018
1019 skb_put( skb, nl->inppos );
1020
1021#ifdef CONFIG_SBNI_MULTILINE
1022 skb->protocol = eth_type_trans( skb, nl->master );
1023 netif_rx( skb );
1024 ++nl->master->stats.rx_packets;
1025 nl->master->stats.rx_bytes += nl->inppos;
1026#else
1027 skb->protocol = eth_type_trans( skb, dev );
1028 netif_rx( skb );
1029 ++dev->stats.rx_packets;
1030 dev->stats.rx_bytes += nl->inppos;
1031#endif
1032 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1033}
1034
1035
1036/* -------------------------------------------------------------------------- */
1037
1038/*
1039 * Routine checks periodically wire activity and regenerates marker if
1040 * connect was inactive for a long time.
1041 */
1042
1043static void
1044sbni_watchdog(struct timer_list *t)
1045{
1046 struct net_local *nl = from_timer(nl, t, watchdog);
1047 struct net_device *dev = nl->watchdog_dev;
1048 unsigned long flags;
1049 unsigned char csr0;
1050
1051 spin_lock_irqsave( &nl->lock, flags );
1052
1053 csr0 = inb( dev->base_addr + CSR0 );
1054 if( csr0 & RC_CHK ) {
1055
1056 if( nl->timer_ticks ) {
1057 if( csr0 & (RC_RDY | BU_EMP) )
1058 /* receiving not active */
1059 nl->timer_ticks--;
1060 } else {
1061 nl->in_stats.timeout_number++;
1062 if( nl->delta_rxl )
1063 timeout_change_level( dev );
1064
1065 outb( *(u_char *)&nl->csr1 | PR_RES,
1066 dev->base_addr + CSR1 );
1067 csr0 = inb( dev->base_addr + CSR0 );
1068 }
1069 } else
1070 nl->state &= ~FL_LINE_DOWN;
1071
1072 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1073
1074 mod_timer(t, jiffies + SBNI_TIMEOUT);
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 netdev_notice(dev, "using shared irq with %s\n",
1183 (*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 netdev_err(dev, "unable to get IRQ %d\n", dev->irq);
1191 return -EAGAIN;
1192 }
1193
1194handler_attached:
1195
1196 spin_lock( &nl->lock );
1197 memset( &dev->stats, 0, sizeof(struct net_device_stats) );
1198 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1199
1200 card_start( dev );
1201
1202 netif_start_queue( dev );
1203
1204 /* set timer watchdog */
1205 nl->watchdog_dev = dev;
1206 timer_setup(w, sbni_watchdog, 0);
1207 w->expires = jiffies + SBNI_TIMEOUT;
1208 add_timer( w );
1209
1210 spin_unlock( &nl->lock );
1211 return 0;
1212}
1213
1214
1215static int
1216sbni_close( struct net_device *dev )
1217{
1218 struct net_local *nl = netdev_priv(dev);
1219
1220 if( nl->second && nl->second->flags & IFF_UP ) {
1221 netdev_notice(dev, "Secondary channel (%s) is active!\n",
1222 nl->second->name);
1223 return -EBUSY;
1224 }
1225
1226#ifdef CONFIG_SBNI_MULTILINE
1227 if( nl->state & FL_SLAVE )
1228 emancipate( dev );
1229 else
1230 while( nl->link ) /* it's master device! */
1231 emancipate( nl->link );
1232#endif
1233
1234 spin_lock( &nl->lock );
1235
1236 nl->second = NULL;
1237 drop_xmit_queue( dev );
1238 netif_stop_queue( dev );
1239
1240 del_timer( &nl->watchdog );
1241
1242 outb( 0, dev->base_addr + CSR0 );
1243
1244 if( !(nl->state & FL_SECONDARY) )
1245 free_irq( dev->irq, dev );
1246 nl->state &= FL_SECONDARY;
1247
1248 spin_unlock( &nl->lock );
1249 return 0;
1250}
1251
1252
1253/*
1254 Valid combinations in CSR0 (for probing):
1255
1256 VALID_DECODER 0000,0011,1011,1010
1257
1258 ; 0 ; -
1259 TR_REQ ; 1 ; +
1260 TR_RDY ; 2 ; -
1261 TR_RDY TR_REQ ; 3 ; +
1262 BU_EMP ; 4 ; +
1263 BU_EMP TR_REQ ; 5 ; +
1264 BU_EMP TR_RDY ; 6 ; -
1265 BU_EMP TR_RDY TR_REQ ; 7 ; +
1266 RC_RDY ; 8 ; +
1267 RC_RDY TR_REQ ; 9 ; +
1268 RC_RDY TR_RDY ; 10 ; -
1269 RC_RDY TR_RDY TR_REQ ; 11 ; -
1270 RC_RDY BU_EMP ; 12 ; -
1271 RC_RDY BU_EMP TR_REQ ; 13 ; -
1272 RC_RDY BU_EMP TR_RDY ; 14 ; -
1273 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1274*/
1275
1276#define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1277
1278
1279static int
1280sbni_card_probe( unsigned long ioaddr )
1281{
1282 unsigned char csr0;
1283
1284 csr0 = inb( ioaddr + CSR0 );
1285 if( csr0 != 0xff && csr0 != 0x00 ) {
1286 csr0 &= ~EN_INT;
1287 if( csr0 & BU_EMP )
1288 csr0 |= EN_INT;
1289
1290 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1291 return 0;
1292 }
1293
1294 return -ENODEV;
1295}
1296
1297/* -------------------------------------------------------------------------- */
1298
1299static int
1300sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1301{
1302 struct net_local *nl = netdev_priv(dev);
1303 struct sbni_flags flags;
1304 int error = 0;
1305
1306#ifdef CONFIG_SBNI_MULTILINE
1307 struct net_device *slave_dev;
1308 char slave_name[ 8 ];
1309#endif
1310
1311 switch( cmd ) {
1312 case SIOCDEVGETINSTATS :
1313 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1314 sizeof(struct sbni_in_stats) ))
1315 error = -EFAULT;
1316 break;
1317
1318 case SIOCDEVRESINSTATS :
1319 if (!capable(CAP_NET_ADMIN))
1320 return -EPERM;
1321 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1322 break;
1323
1324 case SIOCDEVGHWSTATE :
1325 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1326 flags.rate = nl->csr1.rate;
1327 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1328 flags.rxl = nl->cur_rxl_index;
1329 flags.fixed_rxl = nl->delta_rxl == 0;
1330
1331 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1332 error = -EFAULT;
1333 break;
1334
1335 case SIOCDEVSHWSTATE :
1336 if (!capable(CAP_NET_ADMIN))
1337 return -EPERM;
1338
1339 spin_lock( &nl->lock );
1340 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1341 if( flags.fixed_rxl ) {
1342 nl->delta_rxl = 0;
1343 nl->cur_rxl_index = flags.rxl;
1344 } else {
1345 nl->delta_rxl = DEF_RXL_DELTA;
1346 nl->cur_rxl_index = DEF_RXL;
1347 }
1348
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;
1354
1355#ifdef CONFIG_SBNI_MULTILINE
1356
1357 case SIOCDEVENSLAVE :
1358 if (!capable(CAP_NET_ADMIN))
1359 return -EPERM;
1360
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 netdev_err(dev, "trying to enslave non-active device %s\n",
1366 slave_name);
1367 if (slave_dev)
1368 dev_put(slave_dev);
1369 return -EPERM;
1370 }
1371
1372 return enslave( dev, slave_dev );
1373
1374 case SIOCDEVEMANSIPATE :
1375 if (!capable(CAP_NET_ADMIN))
1376 return -EPERM;
1377
1378 return emancipate( dev );
1379
1380#endif /* CONFIG_SBNI_MULTILINE */
1381
1382 default :
1383 return -EOPNOTSUPP;
1384 }
1385
1386 return error;
1387}
1388
1389
1390#ifdef CONFIG_SBNI_MULTILINE
1391
1392static int
1393enslave( struct net_device *dev, struct net_device *slave_dev )
1394{
1395 struct net_local *nl = netdev_priv(dev);
1396 struct net_local *snl = netdev_priv(slave_dev);
1397
1398 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1399 return -EBUSY;
1400
1401 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1402 return -EBUSY;
1403
1404 spin_lock( &nl->lock );
1405 spin_lock( &snl->lock );
1406
1407 /* append to list */
1408 snl->link = nl->link;
1409 nl->link = slave_dev;
1410 snl->master = dev;
1411 snl->state |= FL_SLAVE;
1412
1413 /* Summary statistics of MultiLine operation will be stored
1414 in master's counters */
1415 memset( &slave_dev->stats, 0, sizeof(struct net_device_stats) );
1416 netif_stop_queue( slave_dev );
1417 netif_wake_queue( dev ); /* Now we are able to transmit */
1418
1419 spin_unlock( &snl->lock );
1420 spin_unlock( &nl->lock );
1421 netdev_notice(dev, "slave device (%s) attached\n", 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_hw_array(io, int, ioport, NULL, 0);
1474module_param_hw_array(irq, int, irq, 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), "sbni%d",
1490 NET_NAME_UNKNOWN, 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_strtoul( p, &p, 0 );
1539 if( !*p || *p == ')' )
1540 return 1;
1541 if( *p == ';' ) {
1542 ++p;
1543 ++n;
1544 parm = 0;
1545 } else if( *p++ != ',' ) {
1546 break;
1547 } else {
1548 if( ++parm >= 5 )
1549 break;
1550 }
1551 }
1552bad_param:
1553 pr_err("Error in sbni kernel parameter!\n");
1554 return 0;
1555}
1556
1557__setup( "sbni=", sbni_setup );
1558
1559#endif /* MODULE */
1560
1561/* -------------------------------------------------------------------------- */
1562
1563static u32
1564calc_crc32( u32 crc, u8 *p, u32 len )
1565{
1566 while( len-- )
1567 crc = CRC32( *p++, crc );
1568
1569 return crc;
1570}
1571
1572static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1573 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1574 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1575 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1576 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1577 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1578 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1579 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1580 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1581 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1582 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1583 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1584 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1585 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1586 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1587 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1588 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1589 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1590 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1591 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1592 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1593 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1594 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1595 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1596 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1597 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1598 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1599 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1600 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1601 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1602 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1603 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1604 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1605 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1606 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1607 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1608 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1609 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1610 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1611 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1612 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1613 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1614 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1615 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1616 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1617 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1618 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1619 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1620 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1621 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1622 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1623 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1624 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1625 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1626 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1627 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1628 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1629 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1630 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1631 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1632 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1633 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1634 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1635 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1636 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
1637};
1638