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