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