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