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