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