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