?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6/kvm.git] / drivers / net / wan / sbni.c
blobfc5c0c611ffd4a79f8d1b358fb8b0e8a14ba8713
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 #ifdef CONFIG_SBNI_MULTILINE
1003 skb->dev = ((struct net_local *) dev->priv)->master;
1004 #else
1005 skb->dev = dev;
1006 #endif
1007 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1008 return skb;
1009 }
1010
1011
1012 static void
1013 indicate_pkt( struct net_device *dev )
1014 {
1015 struct net_local *nl = (struct net_local *) dev->priv;
1016 struct sk_buff *skb = nl->rx_buf_p;
1017
1018 skb_put( skb, nl->inppos );
1019
1020 #ifdef CONFIG_SBNI_MULTILINE
1021 skb->protocol = eth_type_trans( skb, nl->master );
1022 netif_rx( skb );
1023 dev->last_rx = jiffies;
1024 ++((struct net_local *) nl->master->priv)->stats.rx_packets;
1025 ((struct net_local *) nl->master->priv)->stats.rx_bytes += nl->inppos;
1026 #else
1027 skb->protocol = eth_type_trans( skb, dev );
1028 netif_rx( skb );
1029 dev->last_rx = jiffies;
1030 ++nl->stats.rx_packets;
1031 nl->stats.rx_bytes += nl->inppos;
1032 #endif
1033 nl->rx_buf_p = NULL; /* protocol driver will clear this sk_buff */
1034 }
1035
1036
1037 /* -------------------------------------------------------------------------- */
1038
1039 /*
1040 * Routine checks periodically wire activity and regenerates marker if
1041 * connect was inactive for a long time.
1042 */
1043
1044 static void
1045 sbni_watchdog( unsigned long arg )
1046 {
1047 struct net_device *dev = (struct net_device *) arg;
1048 struct net_local *nl = (struct net_local *) dev->priv;
1049 struct timer_list *w = &nl->watchdog;
1050 unsigned long flags;
1051 unsigned char csr0;
1052
1053 spin_lock_irqsave( &nl->lock, flags );
1054
1055 csr0 = inb( dev->base_addr + CSR0 );
1056 if( csr0 & RC_CHK ) {
1057
1058 if( nl->timer_ticks ) {
1059 if( csr0 & (RC_RDY | BU_EMP) )
1060 /* receiving not active */
1061 nl->timer_ticks--;
1062 } else {
1063 nl->in_stats.timeout_number++;
1064 if( nl->delta_rxl )
1065 timeout_change_level( dev );
1066
1067 outb( *(u_char *)&nl->csr1 | PR_RES,
1068 dev->base_addr + CSR1 );
1069 csr0 = inb( dev->base_addr + CSR0 );
1070 }
1071 } else
1072 nl->state &= ~FL_LINE_DOWN;
1073
1074 outb( csr0 | RC_CHK, dev->base_addr + CSR0 );
1075
1076 init_timer( w );
1077 w->expires = jiffies + SBNI_TIMEOUT;
1078 w->data = arg;
1079 w->function = sbni_watchdog;
1080 add_timer( w );
1081
1082 spin_unlock_irqrestore( &nl->lock, flags );
1083 }
1084
1085
1086 static unsigned char rxl_tab[] = {
1087 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
1088 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
1089 };
1090
1091 #define SIZE_OF_TIMEOUT_RXL_TAB 4
1092 static unsigned char timeout_rxl_tab[] = {
1093 0x03, 0x05, 0x08, 0x0b
1094 };
1095
1096 /* -------------------------------------------------------------------------- */
1097
1098 static void
1099 card_start( struct net_device *dev )
1100 {
1101 struct net_local *nl = (struct net_local *) dev->priv;
1102
1103 nl->timer_ticks = CHANGE_LEVEL_START_TICKS;
1104 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
1105 nl->state |= FL_PREV_OK;
1106
1107 nl->inppos = nl->outpos = 0;
1108 nl->wait_frameno = 0;
1109 nl->tx_frameno = 0;
1110 nl->framelen = 0;
1111
1112 outb( *(u_char *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1113 outb( EN_INT, dev->base_addr + CSR0 );
1114 }
1115
1116 /* -------------------------------------------------------------------------- */
1117
1118 /* Receive level auto-selection */
1119
1120 static void
1121 change_level( struct net_device *dev )
1122 {
1123 struct net_local *nl = (struct net_local *) dev->priv;
1124
1125 if( nl->delta_rxl == 0 ) /* do not auto-negotiate RxL */
1126 return;
1127
1128 if( nl->cur_rxl_index == 0 )
1129 nl->delta_rxl = 1;
1130 else if( nl->cur_rxl_index == 15 )
1131 nl->delta_rxl = -1;
1132 else if( nl->cur_rxl_rcvd < nl->prev_rxl_rcvd )
1133 nl->delta_rxl = -nl->delta_rxl;
1134
1135 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index += nl->delta_rxl ];
1136 inb( dev->base_addr + CSR0 ); /* needs for PCI cards */
1137 outb( *(u8 *)&nl->csr1, dev->base_addr + CSR1 );
1138
1139 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1140 nl->cur_rxl_rcvd = 0;
1141 }
1142
1143
1144 static void
1145 timeout_change_level( struct net_device *dev )
1146 {
1147 struct net_local *nl = (struct net_local *) dev->priv;
1148
1149 nl->cur_rxl_index = timeout_rxl_tab[ nl->timeout_rxl ];
1150 if( ++nl->timeout_rxl >= 4 )
1151 nl->timeout_rxl = 0;
1152
1153 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1154 inb( dev->base_addr + CSR0 );
1155 outb( *(unsigned char *)&nl->csr1, dev->base_addr + CSR1 );
1156
1157 nl->prev_rxl_rcvd = nl->cur_rxl_rcvd;
1158 nl->cur_rxl_rcvd = 0;
1159 }
1160
1161 /* -------------------------------------------------------------------------- */
1162
1163 /*
1164 * Open/initialize the board.
1165 */
1166
1167 static int
1168 sbni_open( struct net_device *dev )
1169 {
1170 struct net_local *nl = (struct net_local *) dev->priv;
1171 struct timer_list *w = &nl->watchdog;
1172
1173 /*
1174 * For double ISA adapters within "common irq" mode, we have to
1175 * determine whether primary or secondary channel is initialized,
1176 * and set the irq handler only in first case.
1177 */
1178 if( dev->base_addr < 0x400 ) { /* ISA only */
1179 struct net_device **p = sbni_cards;
1180 for( ; *p && p < sbni_cards + SBNI_MAX_NUM_CARDS; ++p )
1181 if( (*p)->irq == dev->irq
1182 && ((*p)->base_addr == dev->base_addr + 4
1183 || (*p)->base_addr == dev->base_addr - 4)
1184 && (*p)->flags & IFF_UP ) {
1185
1186 ((struct net_local *) ((*p)->priv))
1187 ->second = dev;
1188 printk( KERN_NOTICE "%s: using shared irq "
1189 "with %s\n", dev->name, (*p)->name );
1190 nl->state |= FL_SECONDARY;
1191 goto handler_attached;
1192 }
1193 }
1194
1195 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1196 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1197 dev->name, dev->irq );
1198 return -EAGAIN;
1199 }
1200
1201 handler_attached:
1202
1203 spin_lock( &nl->lock );
1204 memset( &nl->stats, 0, sizeof(struct net_device_stats) );
1205 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1206
1207 card_start( dev );
1208
1209 netif_start_queue( dev );
1210
1211 /* set timer watchdog */
1212 init_timer( w );
1213 w->expires = jiffies + SBNI_TIMEOUT;
1214 w->data = (unsigned long) dev;
1215 w->function = sbni_watchdog;
1216 add_timer( w );
1217
1218 spin_unlock( &nl->lock );
1219 return 0;
1220 }
1221
1222
1223 static int
1224 sbni_close( struct net_device *dev )
1225 {
1226 struct net_local *nl = (struct net_local *) dev->priv;
1227
1228 if( nl->second && nl->second->flags & IFF_UP ) {
1229 printk( KERN_NOTICE "Secondary channel (%s) is active!\n",
1230 nl->second->name );
1231 return -EBUSY;
1232 }
1233
1234 #ifdef CONFIG_SBNI_MULTILINE
1235 if( nl->state & FL_SLAVE )
1236 emancipate( dev );
1237 else
1238 while( nl->link ) /* it's master device! */
1239 emancipate( nl->link );
1240 #endif
1241
1242 spin_lock( &nl->lock );
1243
1244 nl->second = NULL;
1245 drop_xmit_queue( dev );
1246 netif_stop_queue( dev );
1247
1248 del_timer( &nl->watchdog );
1249
1250 outb( 0, dev->base_addr + CSR0 );
1251
1252 if( !(nl->state & FL_SECONDARY) )
1253 free_irq( dev->irq, dev );
1254 nl->state &= FL_SECONDARY;
1255
1256 spin_unlock( &nl->lock );
1257 return 0;
1258 }
1259
1260
1261 /*
1262 Valid combinations in CSR0 (for probing):
1263
1264 VALID_DECODER 0000,0011,1011,1010
1265
1266 ; 0 ; -
1267 TR_REQ ; 1 ; +
1268 TR_RDY ; 2 ; -
1269 TR_RDY TR_REQ ; 3 ; +
1270 BU_EMP ; 4 ; +
1271 BU_EMP TR_REQ ; 5 ; +
1272 BU_EMP TR_RDY ; 6 ; -
1273 BU_EMP TR_RDY TR_REQ ; 7 ; +
1274 RC_RDY ; 8 ; +
1275 RC_RDY TR_REQ ; 9 ; +
1276 RC_RDY TR_RDY ; 10 ; -
1277 RC_RDY TR_RDY TR_REQ ; 11 ; -
1278 RC_RDY BU_EMP ; 12 ; -
1279 RC_RDY BU_EMP TR_REQ ; 13 ; -
1280 RC_RDY BU_EMP TR_RDY ; 14 ; -
1281 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
1282 */
1283
1284 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
1285
1286
1287 static int
1288 sbni_card_probe( unsigned long ioaddr )
1289 {
1290 unsigned char csr0;
1291
1292 csr0 = inb( ioaddr + CSR0 );
1293 if( csr0 != 0xff && csr0 != 0x00 ) {
1294 csr0 &= ~EN_INT;
1295 if( csr0 & BU_EMP )
1296 csr0 |= EN_INT;
1297
1298 if( VALID_DECODER & (1 << (csr0 >> 4)) )
1299 return 0;
1300 }
1301
1302 return -ENODEV;
1303 }
1304
1305 /* -------------------------------------------------------------------------- */
1306
1307 static int
1308 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1309 {
1310 struct net_local *nl = (struct net_local *) dev->priv;
1311 struct sbni_flags flags;
1312 int error = 0;
1313
1314 #ifdef CONFIG_SBNI_MULTILINE
1315 struct net_device *slave_dev;
1316 char slave_name[ 8 ];
1317 #endif
1318
1319 switch( cmd ) {
1320 case SIOCDEVGETINSTATS :
1321 if (copy_to_user( ifr->ifr_data, &nl->in_stats,
1322 sizeof(struct sbni_in_stats) ))
1323 error = -EFAULT;
1324 break;
1325
1326 case SIOCDEVRESINSTATS :
1327 if( current->euid != 0 ) /* root only */
1328 return -EPERM;
1329 memset( &nl->in_stats, 0, sizeof(struct sbni_in_stats) );
1330 break;
1331
1332 case SIOCDEVGHWSTATE :
1333 flags.mac_addr = *(u32 *)(dev->dev_addr + 3);
1334 flags.rate = nl->csr1.rate;
1335 flags.slow_mode = (nl->state & FL_SLOW_MODE) != 0;
1336 flags.rxl = nl->cur_rxl_index;
1337 flags.fixed_rxl = nl->delta_rxl == 0;
1338
1339 if (copy_to_user( ifr->ifr_data, &flags, sizeof flags ))
1340 error = -EFAULT;
1341 break;
1342
1343 case SIOCDEVSHWSTATE :
1344 if( current->euid != 0 ) /* root only */
1345 return -EPERM;
1346
1347 spin_lock( &nl->lock );
1348 flags = *(struct sbni_flags*) &ifr->ifr_ifru;
1349 if( flags.fixed_rxl )
1350 nl->delta_rxl = 0,
1351 nl->cur_rxl_index = flags.rxl;
1352 else
1353 nl->delta_rxl = DEF_RXL_DELTA,
1354 nl->cur_rxl_index = DEF_RXL;
1355
1356 nl->csr1.rxl = rxl_tab[ nl->cur_rxl_index ];
1357 nl->csr1.rate = flags.rate;
1358 outb( *(u8 *)&nl->csr1 | PR_RES, dev->base_addr + CSR1 );
1359 spin_unlock( &nl->lock );
1360 break;
1361
1362 #ifdef CONFIG_SBNI_MULTILINE
1363
1364 case SIOCDEVENSLAVE :
1365 if( current->euid != 0 ) /* root only */
1366 return -EPERM;
1367
1368 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1369 return -EFAULT;
1370 slave_dev = dev_get_by_name( slave_name );
1371 if( !slave_dev || !(slave_dev->flags & IFF_UP) ) {
1372 printk( KERN_ERR "%s: trying to enslave non-active "
1373 "device %s\n", dev->name, slave_name );
1374 return -EPERM;
1375 }
1376
1377 return enslave( dev, slave_dev );
1378
1379 case SIOCDEVEMANSIPATE :
1380 if( current->euid != 0 ) /* root only */
1381 return -EPERM;
1382
1383 return emancipate( dev );
1384
1385 #endif /* CONFIG_SBNI_MULTILINE */
1386
1387 default :
1388 return -EOPNOTSUPP;
1389 }
1390
1391 return error;
1392 }
1393
1394
1395 #ifdef CONFIG_SBNI_MULTILINE
1396
1397 static int
1398 enslave( struct net_device *dev, struct net_device *slave_dev )
1399 {
1400 struct net_local *nl = (struct net_local *) dev->priv;
1401 struct net_local *snl = (struct net_local *) slave_dev->priv;
1402
1403 if( nl->state & FL_SLAVE ) /* This isn't master or free device */
1404 return -EBUSY;
1405
1406 if( snl->state & FL_SLAVE ) /* That was already enslaved */
1407 return -EBUSY;
1408
1409 spin_lock( &nl->lock );
1410 spin_lock( &snl->lock );
1411
1412 /* append to list */
1413 snl->link = nl->link;
1414 nl->link = slave_dev;
1415 snl->master = dev;
1416 snl->state |= FL_SLAVE;
1417
1418 /* Summary statistics of MultiLine operation will be stored
1419 in master's counters */
1420 memset( &snl->stats, 0, sizeof(struct net_device_stats) );
1421 netif_stop_queue( slave_dev );
1422 netif_wake_queue( dev ); /* Now we are able to transmit */
1423
1424 spin_unlock( &snl->lock );
1425 spin_unlock( &nl->lock );
1426 printk( KERN_NOTICE "%s: slave device (%s) attached.\n",
1427 dev->name, slave_dev->name );
1428 return 0;
1429 }
1430
1431
1432 static int
1433 emancipate( struct net_device *dev )
1434 {
1435 struct net_local *snl = (struct net_local *) dev->priv;
1436 struct net_device *p = snl->master;
1437 struct net_local *nl = (struct net_local *) p->priv;
1438
1439 if( !(snl->state & FL_SLAVE) )
1440 return -EINVAL;
1441
1442 spin_lock( &nl->lock );
1443 spin_lock( &snl->lock );
1444 drop_xmit_queue( dev );
1445
1446 /* exclude from list */
1447 for(;;) { /* must be in list */
1448 struct net_local *t = (struct net_local *) p->priv;
1449 if( t->link == dev ) {
1450 t->link = snl->link;
1451 break;
1452 }
1453 p = t->link;
1454 }
1455
1456 snl->link = NULL;
1457 snl->master = dev;
1458 snl->state &= ~FL_SLAVE;
1459
1460 netif_start_queue( dev );
1461
1462 spin_unlock( &snl->lock );
1463 spin_unlock( &nl->lock );
1464
1465 dev_put( dev );
1466 return 0;
1467 }
1468
1469 #endif
1470
1471
1472 static struct net_device_stats *
1473 sbni_get_stats( struct net_device *dev )
1474 {
1475 return &((struct net_local *) dev->priv)->stats;
1476 }
1477
1478
1479 static void
1480 set_multicast_list( struct net_device *dev )
1481 {
1482 return; /* sbni always operate in promiscuos mode */
1483 }
1484
1485
1486 #ifdef MODULE
1487 module_param_array(io, int, NULL, 0);
1488 module_param_array(irq, int, NULL, 0);
1489 module_param_array(baud, int, NULL, 0);
1490 module_param_array(rxl, int, NULL, 0);
1491 module_param_array(mac, int, NULL, 0);
1492 module_param(skip_pci_probe, bool, 0);
1493
1494 MODULE_LICENSE("GPL");
1495
1496
1497 int __init init_module( void )
1498 {
1499 struct net_device *dev;
1500 int err;
1501
1502 while( num < SBNI_MAX_NUM_CARDS ) {
1503 dev = alloc_netdev(sizeof(struct net_local),
1504 "sbni%d", sbni_devsetup);
1505 if( !dev)
1506 break;
1507
1508 sprintf( dev->name, "sbni%d", num );
1509
1510 err = sbni_init(dev);
1511 if (err) {
1512 free_netdev(dev);
1513 break;
1514 }
1515
1516 if( register_netdev( dev ) ) {
1517 release_region( dev->base_addr, SBNI_IO_EXTENT );
1518 free_netdev( dev );
1519 break;
1520 }
1521 }
1522
1523 return *sbni_cards ? 0 : -ENODEV;
1524 }
1525
1526 void
1527 cleanup_module( void )
1528 {
1529 struct net_device *dev;
1530 int num;
1531
1532 for( num = 0; num < SBNI_MAX_NUM_CARDS; ++num )
1533 if( (dev = sbni_cards[ num ]) != NULL ) {
1534 unregister_netdev( dev );
1535 release_region( dev->base_addr, SBNI_IO_EXTENT );
1536 free_netdev( dev );
1537 }
1538 }
1539
1540 #else /* MODULE */
1541
1542 static int __init
1543 sbni_setup( char *p )
1544 {
1545 int n, parm;
1546
1547 if( *p++ != '(' )
1548 goto bad_param;
1549
1550 for( n = 0, parm = 0; *p && n < 8; ) {
1551 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1552 if( !*p || *p == ')' )
1553 return 1;
1554 if( *p == ';' )
1555 ++p, ++n, parm = 0;
1556 else if( *p++ != ',' )
1557 break;
1558 else
1559 if( ++parm >= 5 )
1560 break;
1561 }
1562 bad_param:
1563 printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1564 return 0;
1565 }
1566
1567 __setup( "sbni=", sbni_setup );
1568
1569 #endif /* MODULE */
1570
1571 /* -------------------------------------------------------------------------- */
1572
1573 #ifdef ASM_CRC
1574
1575 static u32
1576 calc_crc32( u32 crc, u8 *p, u32 len )
1577 {
1578 register u32 _crc;
1579 _crc = crc;
1580
1581 __asm__ __volatile__ (
1582 "xorl %%ebx, %%ebx\n"
1583 "movl %2, %%esi\n"
1584 "movl %3, %%ecx\n"
1585 "movl $crc32tab, %%edi\n"
1586 "shrl $2, %%ecx\n"
1587 "jz 1f\n"
1588
1589 ".align 4\n"
1590 "0:\n"
1591 "movb %%al, %%bl\n"
1592 "movl (%%esi), %%edx\n"
1593 "shrl $8, %%eax\n"
1594 "xorb %%dl, %%bl\n"
1595 "shrl $8, %%edx\n"
1596 "xorl (%%edi,%%ebx,4), %%eax\n"
1597
1598 "movb %%al, %%bl\n"
1599 "shrl $8, %%eax\n"
1600 "xorb %%dl, %%bl\n"
1601 "shrl $8, %%edx\n"
1602 "xorl (%%edi,%%ebx,4), %%eax\n"
1603
1604 "movb %%al, %%bl\n"
1605 "shrl $8, %%eax\n"
1606 "xorb %%dl, %%bl\n"
1607 "movb %%dh, %%dl\n"
1608 "xorl (%%edi,%%ebx,4), %%eax\n"
1609
1610 "movb %%al, %%bl\n"
1611 "shrl $8, %%eax\n"
1612 "xorb %%dl, %%bl\n"
1613 "addl $4, %%esi\n"
1614 "xorl (%%edi,%%ebx,4), %%eax\n"
1615
1616 "decl %%ecx\n"
1617 "jnz 0b\n"
1618
1619 "1:\n"
1620 "movl %3, %%ecx\n"
1621 "andl $3, %%ecx\n"
1622 "jz 2f\n"
1623
1624 "movb %%al, %%bl\n"
1625 "shrl $8, %%eax\n"
1626 "xorb (%%esi), %%bl\n"
1627 "xorl (%%edi,%%ebx,4), %%eax\n"
1628
1629 "decl %%ecx\n"
1630 "jz 2f\n"
1631
1632 "movb %%al, %%bl\n"
1633 "shrl $8, %%eax\n"
1634 "xorb 1(%%esi), %%bl\n"
1635 "xorl (%%edi,%%ebx,4), %%eax\n"
1636
1637 "decl %%ecx\n"
1638 "jz 2f\n"
1639
1640 "movb %%al, %%bl\n"
1641 "shrl $8, %%eax\n"
1642 "xorb 2(%%esi), %%bl\n"
1643 "xorl (%%edi,%%ebx,4), %%eax\n"
1644 "2:\n"
1645 : "=a" (_crc)
1646 : "0" (_crc), "g" (p), "g" (len)
1647 : "bx", "cx", "dx", "si", "di"
1648 );
1649
1650 return _crc;
1651 }
1652
1653 #else /* ASM_CRC */
1654
1655 static u32
1656 calc_crc32( u32 crc, u8 *p, u32 len )
1657 {
1658 while( len-- )
1659 crc = CRC32( *p++, crc );
1660
1661 return crc;
1662 }
1663
1664 #endif /* ASM_CRC */
1665
1666
1667 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1668 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1669 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1670 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1671 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1672 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1673 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1674 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1675 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1676 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1677 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1678 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1679 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1680 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1681 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1682 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1683 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1684 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1685 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1686 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1687 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1688 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1689 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1690 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1691 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1692 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1693 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1694 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1695 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1696 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1697 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1698 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1699 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1700 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1701 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1702 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1703 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1704 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1705 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1706 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1707 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1708 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1709 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1710 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1711 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1712 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1713 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1714 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1715 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1716 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1717 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1718 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1719 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1720 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1721 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1722 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1723 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1724 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1725 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1726 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1727 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1728 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1729 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1730 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1731 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
1732 };
1733
kernel-based virtual machine