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