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