?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: i915 needs pgprot_writecombine() and is_io_mapping_possible()
[linux-2.6/mini2440.git] / drivers / net / wan / sbni.c
blob0aa28e1d436614bc98fa1954fda862d8eeec8574
1 /* sbni.c: Granch SBNI12 leased line adapters driver for linux
2 *
3 * Written 2001 by Denis I.Timofeev (timofeev@granch.ru)
4 *
5 * Previous versions were written by Yaroslav Polyakov,
6 * Alexey Zverev and Max Khon.
7 *
8 * Driver supports SBNI12-02,-04,-05,-10,-11 cards, single and
9 * double-channel, PCI and ISA modifications.
10 * More info and useful utilities to work with SBNI12 cards you can find
11 * at http://www.granch.com (English) or http://www.granch.ru (Russian)
12 *
13 * This software may be used and distributed according to the terms
14 * of the GNU General Public License.
15 *
16 *
17 * 5.0.1 Jun 22 2001
18 * - Fixed bug in probe
19 * 5.0.0 Jun 06 2001
20 * - Driver was completely redesigned by Denis I.Timofeev,
21 * - now PCI/Dual, ISA/Dual (with single interrupt line) models are
22 * - supported
23 * 3.3.0 Thu Feb 24 21:30:28 NOVT 2000
24 * - PCI cards support
25 * 3.2.0 Mon Dec 13 22:26:53 NOVT 1999
26 * - Completely rebuilt all the packet storage system
27 * - to work in Ethernet-like style.
28 * 3.1.1 just fixed some bugs (5 aug 1999)
29 * 3.1.0 added balancing feature (26 apr 1999)
30 * 3.0.1 just fixed some bugs (14 apr 1999).
31 * 3.0.0 Initial Revision, Yaroslav Polyakov (24 Feb 1999)
32 * - added pre-calculation for CRC, fixed bug with "len-2" frames,
33 * - removed outbound fragmentation (MTU=1000), written CRC-calculation
34 * - on asm, added work with hard_headers and now we have our own cache
35 * - for them, optionally supported word-interchange on some chipsets,
36 *
37 * Known problem: this driver wasn't tested on multiprocessor machine.
38 */
39
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/ptrace.h>
43 #include <linux/fcntl.h>
44 #include <linux/ioport.h>
45 #include <linux/interrupt.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/errno.h>
49 #include <linux/netdevice.h>
50 #include <linux/etherdevice.h>
51 #include <linux/pci.h>
52 #include <linux/skbuff.h>
53 #include <linux/timer.h>
54 #include <linux/init.h>
55 #include <linux/delay.h>
56
57 #include <net/net_namespace.h>
58 #include <net/arp.h>
59
60 #include <asm/io.h>
61 #include <asm/types.h>
62 #include <asm/byteorder.h>
63 #include <asm/irq.h>
64 #include <asm/uaccess.h>
65
66 #include "sbni.h"
67
68 /* device private data */
69
70 struct net_local {
71 struct net_device_stats stats;
72 struct timer_list watchdog;
73
74 spinlock_t lock;
75 struct sk_buff *rx_buf_p; /* receive buffer ptr */
76 struct sk_buff *tx_buf_p; /* transmit buffer ptr */
77
78 unsigned int framelen; /* current frame length */
79 unsigned int maxframe; /* maximum valid frame length */
80 unsigned int state;
81 unsigned int inppos, outpos; /* positions in rx/tx buffers */
82
83 /* transmitting frame number - from frames qty to 1 */
84 unsigned int tx_frameno;
85
86 /* expected number of next receiving frame */
87 unsigned int wait_frameno;
88
89 /* count of failed attempts to frame send - 32 attempts do before
90 error - while receiver tunes on opposite side of wire */
91 unsigned int trans_errors;
92
93 /* idle time; send pong when limit exceeded */
94 unsigned int timer_ticks;
95
96 /* fields used for receive level autoselection */
97 int delta_rxl;
98 unsigned int cur_rxl_index, timeout_rxl;
99 unsigned long cur_rxl_rcvd, prev_rxl_rcvd;
100
101 struct sbni_csr1 csr1; /* current value of CSR1 */
102 struct sbni_in_stats in_stats; /* internal statistics */
103
104 struct net_device *second; /* for ISA/dual cards */
105
106 #ifdef CONFIG_SBNI_MULTILINE
107 struct net_device *master;
108 struct net_device *link;
109 #endif
110 };
111
112
113 static int sbni_card_probe( unsigned long );
114 static int sbni_pci_probe( struct net_device * );
115 static struct net_device *sbni_probe1(struct net_device *, unsigned long, int);
116 static int sbni_open( struct net_device * );
117 static int sbni_close( struct net_device * );
118 static int sbni_start_xmit( struct sk_buff *, struct net_device * );
119 static int sbni_ioctl( struct net_device *, struct ifreq *, int );
120 static struct net_device_stats *sbni_get_stats( struct net_device * );
121 static void set_multicast_list( struct net_device * );
122
123 static irqreturn_t sbni_interrupt( int, void * );
124 static void handle_channel( struct net_device * );
125 static int recv_frame( struct net_device * );
126 static void send_frame( struct net_device * );
127 static int upload_data( struct net_device *,
128 unsigned, unsigned, unsigned, u32 );
129 static void download_data( struct net_device *, u32 * );
130 static void sbni_watchdog( unsigned long );
131 static void interpret_ack( struct net_device *, unsigned );
132 static int append_frame_to_pkt( struct net_device *, unsigned, u32 );
133 static void indicate_pkt( struct net_device * );
134 static void card_start( struct net_device * );
135 static void prepare_to_send( struct sk_buff *, struct net_device * );
136 static void drop_xmit_queue( struct net_device * );
137 static void send_frame_header( struct net_device *, u32 * );
138 static int skip_tail( unsigned int, unsigned int, u32 );
139 static int check_fhdr( u32, u32 *, u32 *, u32 *, u32 *, u32 * );
140 static void change_level( struct net_device * );
141 static void timeout_change_level( struct net_device * );
142 static u32 calc_crc32( u32, u8 *, u32 );
143 static struct sk_buff * get_rx_buf( struct net_device * );
144 static int sbni_init( struct net_device * );
145
146 #ifdef CONFIG_SBNI_MULTILINE
147 static int enslave( struct net_device *, struct net_device * );
148 static int emancipate( struct net_device * );
149 #endif
150
151 #ifdef __i386__
152 #define ASM_CRC 1
153 #endif
154
155 static const char version[] =
156 "Granch SBNI12 driver ver 5.0.1 Jun 22 2001 Denis I.Timofeev.\n";
157
158 static int skip_pci_probe __initdata = 0;
159 static int scandone __initdata = 0;
160 static int num __initdata = 0;
161
162 static unsigned char rxl_tab[];
163 static u32 crc32tab[];
164
165 /* A list of all installed devices, for removing the driver module. */
166 static struct net_device *sbni_cards[ SBNI_MAX_NUM_CARDS ];
167
168 /* Lists of device's parameters */
169 static u32 io[ SBNI_MAX_NUM_CARDS ] __initdata =
170 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
171 static u32 irq[ SBNI_MAX_NUM_CARDS ] __initdata;
172 static u32 baud[ SBNI_MAX_NUM_CARDS ] __initdata;
173 static u32 rxl[ SBNI_MAX_NUM_CARDS ] __initdata =
174 { [0 ... SBNI_MAX_NUM_CARDS-1] = -1 };
175 static u32 mac[ SBNI_MAX_NUM_CARDS ] __initdata;
176
177 #ifndef MODULE
178 typedef u32 iarr[];
179 static iarr __initdata *dest[5] = { &io, &irq, &baud, &rxl, &mac };
180 #endif
181
182 /* A zero-terminated list of I/O addresses to be probed on ISA bus */
183 static unsigned int netcard_portlist[ ] __initdata = {
184 0x210, 0x214, 0x220, 0x224, 0x230, 0x234, 0x240, 0x244, 0x250, 0x254,
185 0x260, 0x264, 0x270, 0x274, 0x280, 0x284, 0x290, 0x294, 0x2a0, 0x2a4,
186 0x2b0, 0x2b4, 0x2c0, 0x2c4, 0x2d0, 0x2d4, 0x2e0, 0x2e4, 0x2f0, 0x2f4,
187 0 };
188
189 #define NET_LOCAL_LOCK(dev) (((struct net_local *)netdev_priv(dev))->lock)
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
196 static inline int __init
197 sbni_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
211 static 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;
220 }
221
222 int __init sbni_probe(int unit)
223 {
224 struct net_device *dev;
225 static unsigned version_printed __initdata = 0;
226 int err;
227
228 dev = alloc_netdev(sizeof(struct net_local), "sbni", sbni_devsetup);
229 if (!dev)
230 return -ENOMEM;
231
232 sprintf(dev->name, "sbni%d", unit);
233 netdev_boot_setup_check(dev);
234
235 err = sbni_init(dev);
236 if (err) {
237 free_netdev(dev);
238 return err;
239 }
240
241 err = register_netdev(dev);
242 if (err) {
243 release_region( dev->base_addr, SBNI_IO_EXTENT );
244 free_netdev(dev);
245 return err;
246 }
247 if( version_printed++ == 0 )
248 printk( KERN_INFO "%s", version );
249 return 0;
250 }
251
252 static int __init sbni_init(struct net_device *dev)
253 {
254 int i;
255 if( dev->base_addr )
256 return sbni_isa_probe( dev );
257 /* otherwise we have to perform search our adapter */
258
259 if( io[ num ] != -1 )
260 dev->base_addr = io[ num ],
261 dev->irq = irq[ num ];
262 else if( scandone || io[ 0 ] != -1 )
263 return -ENODEV;
264
265 /* if io[ num ] contains non-zero address, then that is on ISA bus */
266 if( dev->base_addr )
267 return sbni_isa_probe( dev );
268
269 /* ...otherwise - scan PCI first */
270 if( !skip_pci_probe && !sbni_pci_probe( dev ) )
271 return 0;
272
273 if( io[ num ] == -1 ) {
274 /* Auto-scan will be stopped when first ISA card were found */
275 scandone = 1;
276 if( num > 0 )
277 return -ENODEV;
278 }
279
280 for( i = 0; netcard_portlist[ i ]; ++i ) {
281 int ioaddr = netcard_portlist[ i ];
282 if( request_region( ioaddr, SBNI_IO_EXTENT, dev->name )
283 && sbni_probe1( dev, ioaddr, 0 ))
284 return 0;
285 }
286
287 return -ENODEV;
288 }
289
290
291 static int __init
292 sbni_pci_probe( struct net_device *dev )
293 {
294 struct pci_dev *pdev = NULL;
295
296 while( (pdev = pci_get_class( PCI_CLASS_NETWORK_OTHER << 8, pdev ))
297 != NULL ) {
298 int pci_irq_line;
299 unsigned long pci_ioaddr;
300 u16 subsys;
301
302 if( pdev->vendor != SBNI_PCI_VENDOR
303 && pdev->device != SBNI_PCI_DEVICE )
304 continue;
305
306 pci_ioaddr = pci_resource_start( pdev, 0 );
307 pci_irq_line = pdev->irq;
308
309 /* Avoid already found cards from previous calls */
310 if( !request_region( pci_ioaddr, SBNI_IO_EXTENT, dev->name ) ) {
311 pci_read_config_word( pdev, PCI_SUBSYSTEM_ID, &subsys );
312
313 if (subsys != 2)
314 continue;
315
316 /* Dual adapter is present */
317 if (!request_region(pci_ioaddr += 4, SBNI_IO_EXTENT,
318 dev->name ) )
319 continue;
320 }
321
322 if (pci_irq_line <= 0 || pci_irq_line >= nr_irqs)
323 printk( KERN_WARNING " WARNING: The PCI BIOS assigned "
324 "this PCI card to IRQ %d, which is unlikely "
325 "to work!.\n"
326 KERN_WARNING " You should use the PCI BIOS "
327 "setup to assign a valid IRQ line.\n",
328 pci_irq_line );
329
330 /* avoiding re-enable dual adapters */
331 if( (pci_ioaddr & 7) == 0 && pci_enable_device( pdev ) ) {
332 release_region( pci_ioaddr, SBNI_IO_EXTENT );
333 pci_dev_put( pdev );
334 return -EIO;
335 }
336 if( sbni_probe1( dev, pci_ioaddr, pci_irq_line ) ) {
337 SET_NETDEV_DEV(dev, &pdev->dev);
338 /* not the best thing to do, but this is all messed up
339 for hotplug systems anyway... */
340 pci_dev_put( pdev );
341 return 0;
342 }
343 }
344 return -ENODEV;
345 }
346
347
348 static struct net_device * __init
349 sbni_probe1( struct net_device *dev, unsigned long ioaddr, int irq )
350 {
351 struct net_local *nl;
352
353 if( sbni_card_probe( ioaddr ) ) {
354 release_region( ioaddr, SBNI_IO_EXTENT );
355 return NULL;
356 }
357
358 outb( 0, ioaddr + CSR0 );
359
360 if( irq < 2 ) {
361 unsigned long irq_mask;
362
363 irq_mask = probe_irq_on();
364 outb( EN_INT | TR_REQ, ioaddr + CSR0 );
365 outb( PR_RES, ioaddr + CSR1 );
366 mdelay(50);
367 irq = probe_irq_off(irq_mask);
368 outb( 0, ioaddr + CSR0 );
369
370 if( !irq ) {
371 printk( KERN_ERR "%s: can't detect device irq!\n",
372 dev->name );
373 release_region( ioaddr, SBNI_IO_EXTENT );
374 return NULL;
375 }
376 } else if( irq == 2 )
377 irq = 9;
378
379 dev->irq = irq;
380 dev->base_addr = ioaddr;
381
382 /* Fill in sbni-specific dev fields. */
383 nl = netdev_priv(dev);
384 if( !nl ) {
385 printk( KERN_ERR "%s: unable to get memory!\n", dev->name );
386 release_region( ioaddr, SBNI_IO_EXTENT );
387 return NULL;
388 }
389
390 memset( nl, 0, sizeof(struct net_local) );
391 spin_lock_init( &nl->lock );
392
393 /* store MAC address (generate if that isn't known) */
394 *(__be16 *)dev->dev_addr = htons( 0x00ff );
395 *(__be32 *)(dev->dev_addr + 2) = htonl( 0x01000000 |
396 ((mac[num] ?
397 mac[num] :
398 (u32)((long)netdev_priv(dev))) & 0x00ffffff));
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
443 static int
444 sbni_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; ) {
452 struct net_local *nl = netdev_priv(p);
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
471 static int
472 sbni_start_xmit( struct sk_buff *skb, struct net_device *dev )
473 {
474 struct net_local *nl = netdev_priv(dev);
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
504 static irqreturn_t
505 sbni_interrupt( int irq, void *dev_id )
506 {
507 struct net_device *dev = dev_id;
508 struct net_local *nl = netdev_priv(dev);
509 int repeat;
510
511 spin_lock( &nl->lock );
512 if( nl->second )
513 spin_lock(&NET_LOCAL_LOCK(nl->second));
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 )
527 spin_unlock(&NET_LOCAL_LOCK(nl->second));
528 spin_unlock( &nl->lock );
529 return IRQ_HANDLED;
530 }
531
532
533 static void
534 handle_channel( struct net_device *dev )
535 {
536 struct net_local *nl = netdev_priv(dev);
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 )
545 spin_lock(&NET_LOCAL_LOCK(nl->master));
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 )
581 spin_unlock(&NET_LOCAL_LOCK(nl->master));
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
591 static int
592 recv_frame( struct net_device *dev )
593 {
594 struct net_local *nl = netdev_priv(dev);
595 unsigned long ioaddr = dev->base_addr;
596
597 u32 crc = CRC32_INITIAL;
598
599 unsigned framelen = 0, frameno, ack;
600 unsigned is_first, frame_ok = 0;
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 );
608 }
609
610 outb( inb( ioaddr + CSR0 ) ^ CT_ZER, ioaddr + CSR0 );
611 if( frame_ok ) {
612 nl->state |= FL_PREV_OK;
613 if( framelen > 4 )
614 nl->in_stats.all_rx_number++;
615 } else
616 nl->state &= ~FL_PREV_OK,
617 change_level( dev ),
618 nl->in_stats.all_rx_number++,
619 nl->in_stats.bad_rx_number++;
620
621 return !frame_ok || framelen > 4;
622 }
623
624
625 static void
626 send_frame( struct net_device *dev )
627 {
628 struct net_local *nl = netdev_priv(dev);
629
630 u32 crc = CRC32_INITIAL;
631
632 if( nl->state & FL_NEED_RESEND ) {
633
634 /* if frame was sended but not ACK'ed - resend it */
635 if( nl->trans_errors ) {
636 --nl->trans_errors;
637 if( nl->framelen != 0 )
638 nl->in_stats.resend_tx_number++;
639 } else {
640 /* cannot xmit with many attempts */
641 #ifdef CONFIG_SBNI_MULTILINE
642 if( (nl->state & FL_SLAVE) || nl->link )
643 #endif
644 nl->state |= FL_LINE_DOWN;
645 drop_xmit_queue( dev );
646 goto do_send;
647 }
648 } else
649 nl->trans_errors = TR_ERROR_COUNT;
650
651 send_frame_header( dev, &crc );
652 nl->state |= FL_NEED_RESEND;
653 /*
654 * FL_NEED_RESEND will be cleared after ACK, but if empty
655 * frame sended then in prepare_to_send next frame
656 */
657
658
659 if( nl->framelen ) {
660 download_data( dev, &crc );
661 nl->in_stats.all_tx_number++;
662 nl->state |= FL_WAIT_ACK;
663 }
664
665 outsb( dev->base_addr + DAT, (u8 *)&crc, sizeof crc );
666
667 do_send:
668 outb( inb( dev->base_addr + CSR0 ) & ~TR_REQ, dev->base_addr + CSR0 );
669
670 if( nl->tx_frameno )
671 /* next frame exists - we request card to send it */
672 outb( inb( dev->base_addr + CSR0 ) | TR_REQ,
673 dev->base_addr + CSR0 );
674 }
675
676
677 /*
678 * Write the frame data into adapter's buffer memory, and calculate CRC.
679 * Do padding if necessary.
680 */
681
682 static void
683 download_data( struct net_device *dev, u32 *crc_p )
684 {
685 struct net_local *nl = netdev_priv(dev);
686 struct sk_buff *skb = nl->tx_buf_p;
687
688 unsigned len = min_t(unsigned int, skb->len - nl->outpos, nl->framelen);
689
690 outsb( dev->base_addr + DAT, skb->data + nl->outpos, len );
691 *crc_p = calc_crc32( *crc_p, skb->data + nl->outpos, len );
692
693 /* if packet too short we should write some more bytes to pad */
694 for( len = nl->framelen - len; len--; )
695 outb( 0, dev->base_addr + DAT ),
696 *crc_p = CRC32( 0, *crc_p );
697 }
698
699
700 static int
701 upload_data( struct net_device *dev, unsigned framelen, unsigned frameno,
702 unsigned is_first, u32 crc )
703 {
704 struct net_local *nl = netdev_priv(dev);
705
706 int frame_ok;
707
708 if( is_first )
709 nl->wait_frameno = frameno,
710 nl->inppos = 0;
711
712 if( nl->wait_frameno == frameno ) {
713
714 if( nl->inppos + framelen <= ETHER_MAX_LEN )
715 frame_ok = append_frame_to_pkt( dev, framelen, crc );
716
717 /*
718 * if CRC is right but framelen incorrect then transmitter
719 * error was occurred... drop entire packet
720 */
721 else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc ))
722 != 0 )
723 nl->wait_frameno = 0,
724 nl->inppos = 0,
725 #ifdef CONFIG_SBNI_MULTILINE
726 ((struct net_local *)netdev_priv(nl->master))
727 ->stats.rx_errors++,
728 ((struct net_local *)netdev_priv(nl->master))
729 ->stats.rx_missed_errors++;
730 #else
731 nl->stats.rx_errors++,
732 nl->stats.rx_missed_errors++;
733 #endif
734 /* now skip all frames until is_first != 0 */
735 } else
736 frame_ok = skip_tail( dev->base_addr, framelen, crc );
737
738 if( is_first && !frame_ok )
739 /*
740 * Frame has been broken, but we had already stored
741 * is_first... Drop entire packet.
742 */
743 nl->wait_frameno = 0,
744 #ifdef CONFIG_SBNI_MULTILINE
745 ((struct net_local *)netdev_priv(nl->master))
746 ->stats.rx_errors++,
747 ((struct net_local *)netdev_priv(nl->master))
748 ->stats.rx_crc_errors++;
749 #else
750 nl->stats.rx_errors++,
751 nl->stats.rx_crc_errors++;
752 #endif
753
754 return frame_ok;
755 }
756
757
758 static inline void
759 send_complete( struct net_local *nl )
760 {
761 #ifdef CONFIG_SBNI_MULTILINE
762 ((struct net_local *)netdev_priv(nl->master))->stats.tx_packets++;
763 ((struct net_local *)netdev_priv(nl->master))->stats.tx_bytes
764 += nl->tx_buf_p->len;
765 #else
766 nl->stats.tx_packets++;
767 nl->stats.tx_bytes += nl->tx_buf_p->len;
768 #endif
769 dev_kfree_skb_irq( nl->tx_buf_p );
770
771 nl->tx_buf_p = NULL;
772
773 nl->outpos = 0;
774 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
775 nl->framelen = 0;
776 }
777
778
779 static void
780 interpret_ack( struct net_device *dev, unsigned ack )
781 {
782 struct net_local *nl = netdev_priv(dev);
783
784 if( ack == FRAME_SENT_OK ) {
785 nl->state &= ~FL_NEED_RESEND;
786
787 if( nl->state & FL_WAIT_ACK ) {
788 nl->outpos += nl->framelen;
789
790 if( --nl->tx_frameno )
791 nl->framelen = min_t(unsigned int,
792 nl->maxframe,
793 nl->tx_buf_p->len - nl->outpos);
794 else
795 send_complete( nl ),
796 #ifdef CONFIG_SBNI_MULTILINE
797 netif_wake_queue( nl->master );
798 #else
799 netif_wake_queue( dev );
800 #endif
801 }
802 }
803
804 nl->state &= ~FL_WAIT_ACK;
805 }
806
807
808 /*
809 * Glue received frame with previous fragments of packet.
810 * Indicate packet when last frame would be accepted.
811 */
812
813 static int
814 append_frame_to_pkt( struct net_device *dev, unsigned framelen, u32 crc )
815 {
816 struct net_local *nl = netdev_priv(dev);
817
818 u8 *p;
819
820 if( nl->inppos + framelen > ETHER_MAX_LEN )
821 return 0;
822
823 if( !nl->rx_buf_p && !(nl->rx_buf_p = get_rx_buf( dev )) )
824 return 0;
825
826 p = nl->rx_buf_p->data + nl->inppos;
827 insb( dev->base_addr + DAT, p, framelen );
828 if( calc_crc32( crc, p, framelen ) != CRC32_REMAINDER )
829 return 0;
830
831 nl->inppos += framelen - 4;
832 if( --nl->wait_frameno == 0 ) /* last frame received */
833 indicate_pkt( dev );
834
835 return 1;
836 }
837
838
839 /*
840 * Prepare to start output on adapter.
841 * Transmitter will be actually activated when marker is accepted.
842 */
843
844 static void
845 prepare_to_send( struct sk_buff *skb, struct net_device *dev )
846 {
847 struct net_local *nl = netdev_priv(dev);
848
849 unsigned int len;
850
851 /* nl->tx_buf_p == NULL here! */
852 if( nl->tx_buf_p )
853 printk( KERN_ERR "%s: memory leak!\n", dev->name );
854
855 nl->outpos = 0;
856 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
857
858 len = skb->len;
859 if( len < SBNI_MIN_LEN )
860 len = SBNI_MIN_LEN;
861
862 nl->tx_buf_p = skb;
863 nl->tx_frameno = DIV_ROUND_UP(len, nl->maxframe);
864 nl->framelen = len < nl->maxframe ? len : nl->maxframe;
865
866 outb( inb( dev->base_addr + CSR0 ) | TR_REQ, dev->base_addr + CSR0 );
867 #ifdef CONFIG_SBNI_MULTILINE
868 nl->master->trans_start = jiffies;
869 #else
870 dev->trans_start = jiffies;
871 #endif
872 }
873
874
875 static void
876 drop_xmit_queue( struct net_device *dev )
877 {
878 struct net_local *nl = netdev_priv(dev);
879
880 if( nl->tx_buf_p )
881 dev_kfree_skb_any( nl->tx_buf_p ),
882 nl->tx_buf_p = NULL,
883 #ifdef CONFIG_SBNI_MULTILINE
884 ((struct net_local *)netdev_priv(nl->master))
885 ->stats.tx_errors++,
886 ((struct net_local *)netdev_priv(nl->master))
887 ->stats.tx_carrier_errors++;
888 #else
889 nl->stats.tx_errors++,
890 nl->stats.tx_carrier_errors++;
891 #endif
892
893 nl->tx_frameno = 0;
894 nl->framelen = 0;
895 nl->outpos = 0;
896 nl->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
897 #ifdef CONFIG_SBNI_MULTILINE
898 netif_start_queue( nl->master );
899 nl->master->trans_start = jiffies;
900 #else
901 netif_start_queue( dev );
902 dev->trans_start = jiffies;
903 #endif
904 }
905
906
907 static void
908 send_frame_header( struct net_device *dev, u32 *crc_p )
909 {
910 struct net_local *nl = netdev_priv(dev);
911
912 u32 crc = *crc_p;
913 u32 len_field = nl->framelen + 6; /* CRC + frameno + reserved */
914 u8 value;
915
916 if( nl->state & FL_NEED_RESEND )
917 len_field |= FRAME_RETRY; /* non-first attempt... */
918
919 if( nl->outpos == 0 )
920 len_field |= FRAME_FIRST;
921
922 len_field |= (nl->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
923 outb( SBNI_SIG, dev->base_addr + DAT );
924
925 value = (u8) len_field;
926 outb( value, dev->base_addr + DAT );
927 crc = CRC32( value, crc );
928 value = (u8) (len_field >> 8);
929 outb( value, dev->base_addr + DAT );
930 crc = CRC32( value, crc );
931
932 outb( nl->tx_frameno, dev->base_addr + DAT );
933 crc = CRC32( nl->tx_frameno, crc );
934 outb( 0, dev->base_addr + DAT );
935 crc = CRC32( 0, crc );
936 *crc_p = crc;
937 }
938
939
940 /*
941 * if frame tail not needed (incorrect number or received twice),
942 * it won't store, but CRC will be calculated
943 */
944
945 static int
946 skip_tail( unsigned int ioaddr, unsigned int tail_len, u32 crc )
947 {
948 while( tail_len-- )
949 crc = CRC32( inb( ioaddr + DAT ), crc );
950
951 return crc == CRC32_REMAINDER;
952 }
953
954
955 /*
956 * Preliminary checks if frame header is correct, calculates its CRC
957 * and split it to simple fields
958 */
959
960 static int
961 check_fhdr( u32 ioaddr, u32 *framelen, u32 *frameno, u32 *ack,
962 u32 *is_first, u32 *crc_p )
963 {
964 u32 crc = *crc_p;
965 u8 value;
966
967 if( inb( ioaddr + DAT ) != SBNI_SIG )
968 return 0;
969
970 value = inb( ioaddr + DAT );
971 *framelen = (u32)value;
972 crc = CRC32( value, crc );
973 value = inb( ioaddr + DAT );
974 *framelen |= ((u32)value) << 8;
975 crc = CRC32( value, crc );
976
977 *ack = *framelen & FRAME_ACK_MASK;
978 *is_first = (*framelen & FRAME_FIRST) != 0;
979
980 if( (*framelen &= FRAME_LEN_MASK) < 6
981 || *framelen > SBNI_MAX_FRAME - 3 )
982 return 0;
983
984 value = inb( ioaddr + DAT );
985 *frameno = (u32)value;
986 crc = CRC32( value, crc );
987
988 crc = CRC32( inb( ioaddr + DAT ), crc ); /* reserved byte */
989 *framelen -= 2;
990
991 *crc_p = crc;
992 return 1;
993 }
994
995
996 static struct sk_buff *
997 get_rx_buf( struct net_device *dev )
998 {
999 /* +2 is to compensate for the alignment fixup below */
1000 struct sk_buff *skb = dev_alloc_skb( ETHER_MAX_LEN + 2 );
1001 if( !skb )
1002 return NULL;
1003
1004 skb_reserve( skb, 2 ); /* Align IP on longword boundaries */
1005 return skb;
1006 }
1007
1008
1009 static void
1010 indicate_pkt( struct net_device *dev )
1011 {
1012 struct net_local *nl = netdev_priv(dev);
1013 struct sk_buff *skb = nl->rx_buf_p;
1014
1015 skb_put( skb, nl->inppos );
1016
1017 #ifdef CONFIG_SBNI_MULTILINE
1018 skb->protocol = eth_type_trans( skb, nl->master );
1019 netif_rx( skb );
1020 ++((struct net_local *)netdev_priv(nl->master))->stats.rx_packets;
1021 ((struct net_local *)netdev_priv(nl->master))->stats.rx_bytes +=
1022 nl->inppos;
1023 #else
1024 skb->protocol = eth_type_trans( skb, dev );
1025 netif_rx( skb );
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
1040 static void
1041 sbni_watchdog( unsigned long arg )
1042 {
1043 struct net_device *dev = (struct net_device *) arg;
1044 struct net_local *nl = netdev_priv(dev);
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
1082 static 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
1088 static unsigned char timeout_rxl_tab[] = {
1089 0x03, 0x05, 0x08, 0x0b
1090 };
1091
1092 /* -------------------------------------------------------------------------- */
1093
1094 static void
1095 card_start( struct net_device *dev )
1096 {
1097 struct net_local *nl = netdev_priv(dev);
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
1116 static void
1117 change_level( struct net_device *dev )
1118 {
1119 struct net_local *nl = netdev_priv(dev);
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
1140 static void
1141 timeout_change_level( struct net_device *dev )
1142 {
1143 struct net_local *nl = netdev_priv(dev);
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
1163 static int
1164 sbni_open( struct net_device *dev )
1165 {
1166 struct net_local *nl = netdev_priv(dev);
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
1182 ((struct net_local *) (netdev_priv(*p)))
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
1191 if( request_irq(dev->irq, sbni_interrupt, IRQF_SHARED, dev->name, dev) ) {
1192 printk( KERN_ERR "%s: unable to get IRQ %d.\n",
1193 dev->name, dev->irq );
1194 return -EAGAIN;
1195 }
1196
1197 handler_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
1219 static int
1220 sbni_close( struct net_device *dev )
1221 {
1222 struct net_local *nl = netdev_priv(dev);
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
1283 static int
1284 sbni_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
1303 static int
1304 sbni_ioctl( struct net_device *dev, struct ifreq *ifr, int cmd )
1305 {
1306 struct net_local *nl = netdev_priv(dev);
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 :
1323 if (!capable(CAP_NET_ADMIN))
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 :
1340 if (!capable(CAP_NET_ADMIN))
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 :
1361 if (!capable(CAP_NET_ADMIN))
1362 return -EPERM;
1363
1364 if (copy_from_user( slave_name, ifr->ifr_data, sizeof slave_name ))
1365 return -EFAULT;
1366 slave_dev = dev_get_by_name(&init_net, slave_name );
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 :
1376 if (!capable(CAP_NET_ADMIN))
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
1393 static int
1394 enslave( struct net_device *dev, struct net_device *slave_dev )
1395 {
1396 struct net_local *nl = netdev_priv(dev);
1397 struct net_local *snl = netdev_priv(slave_dev);
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
1428 static int
1429 emancipate( struct net_device *dev )
1430 {
1431 struct net_local *snl = netdev_priv(dev);
1432 struct net_device *p = snl->master;
1433 struct net_local *nl = netdev_priv(p);
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 */
1444 struct net_local *t = netdev_priv(p);
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
1468 static struct net_device_stats *
1469 sbni_get_stats( struct net_device *dev )
1470 {
1471 return &((struct net_local *)netdev_priv(dev))->stats;
1472 }
1473
1474
1475 static void
1476 set_multicast_list( struct net_device *dev )
1477 {
1478 return; /* sbni always operate in promiscuos mode */
1479 }
1480
1481
1482 #ifdef MODULE
1483 module_param_array(io, int, NULL, 0);
1484 module_param_array(irq, int, NULL, 0);
1485 module_param_array(baud, int, NULL, 0);
1486 module_param_array(rxl, int, NULL, 0);
1487 module_param_array(mac, int, NULL, 0);
1488 module_param(skip_pci_probe, bool, 0);
1489
1490 MODULE_LICENSE("GPL");
1491
1492
1493 int __init init_module( void )
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
1522 void
1523 cleanup_module( void )
1524 {
1525 struct net_device *dev;
1526 int num;
1527
1528 for( num = 0; num < SBNI_MAX_NUM_CARDS; ++num )
1529 if( (dev = sbni_cards[ num ]) != NULL ) {
1530 unregister_netdev( dev );
1531 release_region( dev->base_addr, SBNI_IO_EXTENT );
1532 free_netdev( dev );
1533 }
1534 }
1535
1536 #else /* MODULE */
1537
1538 static int __init
1539 sbni_setup( char *p )
1540 {
1541 int n, parm;
1542
1543 if( *p++ != '(' )
1544 goto bad_param;
1545
1546 for( n = 0, parm = 0; *p && n < 8; ) {
1547 (*dest[ parm ])[ n ] = simple_strtol( p, &p, 0 );
1548 if( !*p || *p == ')' )
1549 return 1;
1550 if( *p == ';' )
1551 ++p, ++n, parm = 0;
1552 else if( *p++ != ',' )
1553 break;
1554 else
1555 if( ++parm >= 5 )
1556 break;
1557 }
1558 bad_param:
1559 printk( KERN_ERR "Error in sbni kernel parameter!\n" );
1560 return 0;
1561 }
1562
1563 __setup( "sbni=", sbni_setup );
1564
1565 #endif /* MODULE */
1566
1567 /* -------------------------------------------------------------------------- */
1568
1569 #ifdef ASM_CRC
1570
1571 static u32
1572 calc_crc32( u32 crc, u8 *p, u32 len )
1573 {
1574 register u32 _crc;
1575 _crc = crc;
1576
1577 __asm__ __volatile__ (
1578 "xorl %%ebx, %%ebx\n"
1579 "movl %2, %%esi\n"
1580 "movl %3, %%ecx\n"
1581 "movl $crc32tab, %%edi\n"
1582 "shrl $2, %%ecx\n"
1583 "jz 1f\n"
1584
1585 ".align 4\n"
1586 "0:\n"
1587 "movb %%al, %%bl\n"
1588 "movl (%%esi), %%edx\n"
1589 "shrl $8, %%eax\n"
1590 "xorb %%dl, %%bl\n"
1591 "shrl $8, %%edx\n"
1592 "xorl (%%edi,%%ebx,4), %%eax\n"
1593
1594 "movb %%al, %%bl\n"
1595 "shrl $8, %%eax\n"
1596 "xorb %%dl, %%bl\n"
1597 "shrl $8, %%edx\n"
1598 "xorl (%%edi,%%ebx,4), %%eax\n"
1599
1600 "movb %%al, %%bl\n"
1601 "shrl $8, %%eax\n"
1602 "xorb %%dl, %%bl\n"
1603 "movb %%dh, %%dl\n"
1604 "xorl (%%edi,%%ebx,4), %%eax\n"
1605
1606 "movb %%al, %%bl\n"
1607 "shrl $8, %%eax\n"
1608 "xorb %%dl, %%bl\n"
1609 "addl $4, %%esi\n"
1610 "xorl (%%edi,%%ebx,4), %%eax\n"
1611
1612 "decl %%ecx\n"
1613 "jnz 0b\n"
1614
1615 "1:\n"
1616 "movl %3, %%ecx\n"
1617 "andl $3, %%ecx\n"
1618 "jz 2f\n"
1619
1620 "movb %%al, %%bl\n"
1621 "shrl $8, %%eax\n"
1622 "xorb (%%esi), %%bl\n"
1623 "xorl (%%edi,%%ebx,4), %%eax\n"
1624
1625 "decl %%ecx\n"
1626 "jz 2f\n"
1627
1628 "movb %%al, %%bl\n"
1629 "shrl $8, %%eax\n"
1630 "xorb 1(%%esi), %%bl\n"
1631 "xorl (%%edi,%%ebx,4), %%eax\n"
1632
1633 "decl %%ecx\n"
1634 "jz 2f\n"
1635
1636 "movb %%al, %%bl\n"
1637 "shrl $8, %%eax\n"
1638 "xorb 2(%%esi), %%bl\n"
1639 "xorl (%%edi,%%ebx,4), %%eax\n"
1640 "2:\n"
1641 : "=a" (_crc)
1642 : "0" (_crc), "g" (p), "g" (len)
1643 : "bx", "cx", "dx", "si", "di"
1644 );
1645
1646 return _crc;
1647 }
1648
1649 #else /* ASM_CRC */
1650
1651 static u32
1652 calc_crc32( u32 crc, u8 *p, u32 len )
1653 {
1654 while( len-- )
1655 crc = CRC32( *p++, crc );
1656
1657 return crc;
1658 }
1659
1660 #endif /* ASM_CRC */
1661
1662
1663 static u32 crc32tab[] __attribute__ ((aligned(8))) = {
1664 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1665 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1666 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1667 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1668 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1669 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1670 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1671 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1672 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1673 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1674 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1675 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1676 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1677 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1678 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1679 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1680 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1681 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1682 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1683 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1684 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1685 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1686 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1687 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1688 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1689 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1690 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1691 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1692 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1693 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1694 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1695 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1696 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1697 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1698 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1699 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1700 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1701 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1702 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1703 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1704 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1705 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1706 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1707 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1708 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1709 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1710 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1711 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1712 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1713 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1714 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1715 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1716 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1717 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1718 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1719 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1720 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1721 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1722 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1723 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1724 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1725 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1726 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1727 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
1728 };
1729
Support for the Chinese Samsung S3C2440 based development boards