]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/net/plip.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[mirror_ubuntu-zesty-kernel.git] / drivers / net / plip.c
CommitLineData
1da177e4
LT		 1/* $Id: plip.c,v 1.3.6.2 1997/04/16 15:07:56 phil Exp $ */
2/* PLIP: A parallel port "network" driver for Linux. */
3/* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */
4/*
5 * Authors: Donald Becker <becker@scyld.com>
6 * Tommy Thorn <thorn@daimi.aau.dk>
7 * Tanabe Hiroyasu <hiro@sanpo.t.u-tokyo.ac.jp>
8 * Alan Cox <gw4pts@gw4pts.ampr.org>
9 * Peter Bauer <100136.3530@compuserve.com>
10 * Niibe Yutaka <gniibe@mri.co.jp>
11 * Nimrod Zimerman <zimerman@mailandnews.com>
12 *
13 * Enhancements:
14 * Modularization and ifreq/ifmap support by Alan Cox.
15 * Rewritten by Niibe Yutaka.
16 * parport-sharing awareness code by Philip Blundell.
17 * SMP locking by Niibe Yutaka.
18 * Support for parallel ports with no IRQ (poll mode),
6aa20a22 19 * Modifications to use the parallel port API
1da177e4
LT		 20 * by Nimrod Zimerman.
21 *
22 * Fixes:
23 * Niibe Yutaka
24 * - Module initialization.
25 * - MTU fix.
26 * - Make sure other end is OK, before sending a packet.
27 * - Fix immediate timer problem.
28 *
29 * Al Viro
30 * - Changed {enable,disable}_irq handling to make it work
31 * with new ("stack") semantics.
32 *
33 * This program is free software; you can redistribute it and/or
34 * modify it under the terms of the GNU General Public License
35 * as published by the Free Software Foundation; either version
36 * 2 of the License, or (at your option) any later version.
37 */
38
39/*
40 * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com>
41 * inspired by Russ Nelson's parallel port packet driver.
42 *
43 * NOTE:
44 * Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0.
45 * Because of the necessity to communicate to DOS machines with the
46 * Crynwr packet driver, Peter Bauer changed the protocol again
47 * back to original protocol.
48 *
49 * This version follows original PLIP protocol.
50 * So, this PLIP can't communicate the PLIP of Linux v1.0.
51 */
52
53/*
54 * To use with DOS box, please do (Turn on ARP switch):
55 * # ifconfig plip[0-2] arp
56 */
57static const char version[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n";
58
59/*
60 Sources:
61 Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
62 "parallel.asm" parallel port packet driver.
63
64 The "Crynwr" parallel port standard specifies the following protocol:
65 Trigger by sending nibble '0x8' (this causes interrupt on other end)
66 count-low octet
67 count-high octet
68 ... data octets
69 checksum octet
70 Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
71 <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
72
73 The packet is encapsulated as if it were ethernet.
74
75 The cable used is a de facto standard parallel null cable -- sold as
76 a "LapLink" cable by various places. You'll need a 12-conductor cable to
77 make one yourself. The wiring is:
78 SLCTIN 17 - 17
79 GROUND 25 - 25
80 D0->ERROR 2 - 15 15 - 2
81 D1->SLCT 3 - 13 13 - 3
82 D2->PAPOUT 4 - 12 12 - 4
83 D3->ACK 5 - 10 10 - 5
84 D4->BUSY 6 - 11 11 - 6
85 Do not connect the other pins. They are
86 D5,D6,D7 are 7,8,9
87 STROBE is 1, FEED is 14, INIT is 16
88 extra grounds are 18,19,20,21,22,23,24
89*/
90
91#include <linux/module.h>
92#include <linux/kernel.h>
93#include <linux/types.h>
94#include <linux/fcntl.h>
95#include <linux/interrupt.h>
96#include <linux/string.h>
97#include <linux/if_ether.h>
98#include <linux/in.h>
99#include <linux/errno.h>
100#include <linux/delay.h>
1da177e4
LT		 101#include <linux/init.h>
102#include <linux/netdevice.h>
103#include <linux/etherdevice.h>
104#include <linux/inetdevice.h>
105#include <linux/skbuff.h>
106#include <linux/if_plip.h>
107#include <linux/workqueue.h>
1da177e4 108#include <linux/spinlock.h>
01f31ac8 109#include <linux/completion.h>
1da177e4
LT		 110#include <linux/parport.h>
111#include <linux/bitops.h>
112
113#include <net/neighbour.h>
114
115#include <asm/system.h>
116#include <asm/irq.h>
117#include <asm/byteorder.h>
1da177e4
LT		 118
119/* Maximum number of devices to support. */
120#define PLIP_MAX 8
121
122/* Use 0 for production, 1 for verification, >2 for debug */
123#ifndef NET_DEBUG
124#define NET_DEBUG 1
125#endif
f71e1309 126static const unsigned int net_debug = NET_DEBUG;
1da177e4
LT		 127
128#define ENABLE(irq) if (irq != -1) enable_irq(irq)
129#define DISABLE(irq) if (irq != -1) disable_irq(irq)
130
131/* In micro second */
132#define PLIP_DELAY_UNIT 1
133
134/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
135#define PLIP_TRIGGER_WAIT 500
136
137/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
138#define PLIP_NIBBLE_WAIT 3000
139
140/* Bottom halves */
c4028958
DH		 141static void plip_kick_bh(struct work_struct *work);
142static void plip_bh(struct work_struct *work);
143static void plip_timer_bh(struct work_struct *work);
1da177e4
LT		 144
145/* Interrupt handler */
5712cb3d 146static void plip_interrupt(void *dev_id);
1da177e4
LT		 147
148/* Functions for DEV methods */
149static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);
150static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,
3b04ddde
SH		 151 unsigned short type, const void *daddr,
152 const void *saddr, unsigned len);
153static int plip_hard_header_cache(const struct neighbour *neigh,
1da177e4
LT		 154 struct hh_cache *hh);
155static int plip_open(struct net_device *dev);
156static int plip_close(struct net_device *dev);
1da177e4
LT		 157static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
158static int plip_preempt(void *handle);
159static void plip_wakeup(void *handle);
77933d72 160
1da177e4
LT		 161enum plip_connection_state {
162 PLIP_CN_NONE=0,
163 PLIP_CN_RECEIVE,
164 PLIP_CN_SEND,
165 PLIP_CN_CLOSING,
166 PLIP_CN_ERROR
167};
168
169enum plip_packet_state {
170 PLIP_PK_DONE=0,
171 PLIP_PK_TRIGGER,
172 PLIP_PK_LENGTH_LSB,
173 PLIP_PK_LENGTH_MSB,
174 PLIP_PK_DATA,
175 PLIP_PK_CHECKSUM
176};
177
178enum plip_nibble_state {
179 PLIP_NB_BEGIN,
180 PLIP_NB_1,
181 PLIP_NB_2,
182};
183
184struct plip_local {
185 enum plip_packet_state state;
186 enum plip_nibble_state nibble;
187 union {
188 struct {
189#if defined(__LITTLE_ENDIAN)
190 unsigned char lsb;
191 unsigned char msb;
192#elif defined(__BIG_ENDIAN)
193 unsigned char msb;
194 unsigned char lsb;
195#else
196#error "Please fix the endianness defines in <asm/byteorder.h>"
197#endif
198 } b;
199 unsigned short h;
200 } length;
201 unsigned short byte;
202 unsigned char checksum;
203 unsigned char data;
204 struct sk_buff *skb;
205};
206
207struct net_local {
c4028958 208 struct net_device *dev;
1da177e4 209 struct work_struct immediate;
c4028958
DH		 210 struct delayed_work deferred;
211 struct delayed_work timer;
1da177e4
LT		 212 struct plip_local snd_data;
213 struct plip_local rcv_data;
214 struct pardevice *pardev;
215 unsigned long trigger;
216 unsigned long nibble;
217 enum plip_connection_state connection;
218 unsigned short timeout_count;
219 int is_deferred;
220 int port_owner;
221 int should_relinquish;
1da177e4
LT		 222 spinlock_t lock;
223 atomic_t kill_timer;
01f31ac8 224 struct completion killed_timer_cmp;
1da177e4 225};
77933d72
JJ		 226
227static inline void enable_parport_interrupts (struct net_device *dev)
1da177e4
LT		 228{
229 if (dev->irq != -1)
230 {
231 struct parport *port =
4cf1653a 232 ((struct net_local *)netdev_priv(dev))->pardev->port;
1da177e4
LT		 233 port->ops->enable_irq (port);
234 }
235}
236
77933d72 237static inline void disable_parport_interrupts (struct net_device *dev)
1da177e4
LT		 238{
239 if (dev->irq != -1)
240 {
241 struct parport *port =
4cf1653a 242 ((struct net_local *)netdev_priv(dev))->pardev->port;
1da177e4
LT		 243 port->ops->disable_irq (port);
244 }
245}
246
77933d72 247static inline void write_data (struct net_device *dev, unsigned char data)
1da177e4
LT		 248{
249 struct parport *port =
4cf1653a 250 ((struct net_local *)netdev_priv(dev))->pardev->port;
1da177e4
LT		 251
252 port->ops->write_data (port, data);
253}
254
77933d72 255static inline unsigned char read_status (struct net_device *dev)
1da177e4
LT		 256{
257 struct parport *port =
4cf1653a 258 ((struct net_local *)netdev_priv(dev))->pardev->port;
1da177e4
LT		 259
260 return port->ops->read_status (port);
261}
77933d72 262
3b04ddde
SH		 263static const struct header_ops plip_header_ops = {
264 .create = plip_hard_header,
265 .cache = plip_hard_header_cache,
266};
267
1da177e4
LT		 268/* Entry point of PLIP driver.
269 Probe the hardware, and register/initialize the driver.
270
271 PLIP is rather weird, because of the way it interacts with the parport
272 system. It is _not_ initialised from Space.c. Instead, plip_init()
273 is called, and that function makes up a "struct net_device" for each port, and
274 then calls us here.
275
276 */
277static void
278plip_init_netdev(struct net_device *dev)
279{
280 struct net_local *nl = netdev_priv(dev);
281
282 /* Then, override parts of it */
283 dev->hard_start_xmit = plip_tx_packet;
284 dev->open = plip_open;
285 dev->stop = plip_close;
1da177e4 286 dev->do_ioctl = plip_ioctl;
3b04ddde 287
1da177e4
LT		 288 dev->tx_queue_len = 10;
289 dev->flags = IFF_POINTOPOINT|IFF_NOARP;
290 memset(dev->dev_addr, 0xfc, ETH_ALEN);
291
3b04ddde 292 dev->header_ops = &plip_header_ops;
1da177e4
LT		 293
294
295 nl->port_owner = 0;
296
297 /* Initialize constants */
298 nl->trigger = PLIP_TRIGGER_WAIT;
299 nl->nibble = PLIP_NIBBLE_WAIT;
300
301 /* Initialize task queue structures */
c4028958
DH		 302 INIT_WORK(&nl->immediate, plip_bh);
303 INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);
1da177e4
LT		 304
305 if (dev->irq == -1)
c4028958 306 INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);
1da177e4
LT		 307
308 spin_lock_init(&nl->lock);
309}
77933d72 310
1da177e4
LT		 311/* Bottom half handler for the delayed request.
312 This routine is kicked by do_timer().
313 Request `plip_bh' to be invoked. */
314static void
c4028958 315plip_kick_bh(struct work_struct *work)
1da177e4 316{
c4028958
DH		 317 struct net_local *nl =
318 container_of(work, struct net_local, deferred.work);
1da177e4
LT		 319
320 if (nl->is_deferred)
321 schedule_work(&nl->immediate);
322}
323
324/* Forward declarations of internal routines */
325static int plip_none(struct net_device *, struct net_local *,
326 struct plip_local *, struct plip_local *);
327static int plip_receive_packet(struct net_device *, struct net_local *,
328 struct plip_local *, struct plip_local *);
329static int plip_send_packet(struct net_device *, struct net_local *,
330 struct plip_local *, struct plip_local *);
331static int plip_connection_close(struct net_device *, struct net_local *,
332 struct plip_local *, struct plip_local *);
333static int plip_error(struct net_device *, struct net_local *,
334 struct plip_local *, struct plip_local *);
335static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
336 struct plip_local *snd,
337 struct plip_local *rcv,
338 int error);
339
340#define OK 0
341#define TIMEOUT 1
342#define ERROR 2
343#define HS_TIMEOUT 3
344
345typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
346 struct plip_local *snd, struct plip_local *rcv);
347
f71e1309 348static const plip_func connection_state_table[] =
1da177e4
LT		 349{
350 plip_none,
351 plip_receive_packet,
352 plip_send_packet,
353 plip_connection_close,
354 plip_error
355};
356
357/* Bottom half handler of PLIP. */
358static void
c4028958 359plip_bh(struct work_struct *work)
1da177e4 360{
c4028958 361 struct net_local *nl = container_of(work, struct net_local, immediate);
1da177e4
LT		 362 struct plip_local *snd = &nl->snd_data;
363 struct plip_local *rcv = &nl->rcv_data;
364 plip_func f;
365 int r;
366
367 nl->is_deferred = 0;
368 f = connection_state_table[nl->connection];
c4028958
DH		 369 if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK
370 && (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) {
1da177e4
LT		 371 nl->is_deferred = 1;
372 schedule_delayed_work(&nl->deferred, 1);
373 }
374}
375
376static void
c4028958 377plip_timer_bh(struct work_struct *work)
1da177e4 378{
c4028958
DH		 379 struct net_local *nl =
380 container_of(work, struct net_local, timer.work);
6aa20a22 381
1da177e4 382 if (!(atomic_read (&nl->kill_timer))) {
5712cb3d 383 plip_interrupt (nl->dev);
1da177e4
LT		 384
385 schedule_delayed_work(&nl->timer, 1);
386 }
387 else {
01f31ac8 388 complete(&nl->killed_timer_cmp);
1da177e4
LT		 389 }
390}
391
392static int
393plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
394 struct plip_local *snd, struct plip_local *rcv,
395 int error)
396{
397 unsigned char c0;
398 /*
399 * This is tricky. If we got here from the beginning of send (either
400 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
401 * already disabled. With the old variant of {enable,disable}_irq()
402 * extra disable_irq() was a no-op. Now it became mortal - it's
403 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
404 * that is). So we have to treat HS_TIMEOUT and ERROR from send
405 * in a special way.
406 */
407
408 spin_lock_irq(&nl->lock);
409 if (nl->connection == PLIP_CN_SEND) {
410
411 if (error != ERROR) { /* Timeout */
412 nl->timeout_count++;
413 if ((error == HS_TIMEOUT
414 && nl->timeout_count <= 10)
415 || nl->timeout_count <= 3) {
416 spin_unlock_irq(&nl->lock);
417 /* Try again later */
418 return TIMEOUT;
419 }
420 c0 = read_status(dev);
421 printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
422 dev->name, snd->state, c0);
423 } else
424 error = HS_TIMEOUT;
09f75cd7
JG		 425 dev->stats.tx_errors++;
426 dev->stats.tx_aborted_errors++;
1da177e4
LT		 427 } else if (nl->connection == PLIP_CN_RECEIVE) {
428 if (rcv->state == PLIP_PK_TRIGGER) {
429 /* Transmission was interrupted. */
430 spin_unlock_irq(&nl->lock);
431 return OK;
432 }
433 if (error != ERROR) { /* Timeout */
434 if (++nl->timeout_count <= 3) {
435 spin_unlock_irq(&nl->lock);
436 /* Try again later */
437 return TIMEOUT;
438 }
439 c0 = read_status(dev);
440 printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
441 dev->name, rcv->state, c0);
442 }
09f75cd7 443 dev->stats.rx_dropped++;
1da177e4
LT		 444 }
445 rcv->state = PLIP_PK_DONE;
446 if (rcv->skb) {
447 kfree_skb(rcv->skb);
448 rcv->skb = NULL;
449 }
450 snd->state = PLIP_PK_DONE;
451 if (snd->skb) {
452 dev_kfree_skb(snd->skb);
453 snd->skb = NULL;
454 }
455 spin_unlock_irq(&nl->lock);
456 if (error == HS_TIMEOUT) {
457 DISABLE(dev->irq);
458 synchronize_irq(dev->irq);
459 }
460 disable_parport_interrupts (dev);
461 netif_stop_queue (dev);
462 nl->connection = PLIP_CN_ERROR;
463 write_data (dev, 0x00);
464
465 return TIMEOUT;
466}
77933d72 467
1da177e4
LT		 468static int
469plip_none(struct net_device *dev, struct net_local *nl,
470 struct plip_local *snd, struct plip_local *rcv)
471{
472 return OK;
473}
474
475/* PLIP_RECEIVE --- receive a byte(two nibbles)
476 Returns OK on success, TIMEOUT on timeout */
77933d72 477static inline int
1da177e4
LT		 478plip_receive(unsigned short nibble_timeout, struct net_device *dev,
479 enum plip_nibble_state *ns_p, unsigned char *data_p)
480{
481 unsigned char c0, c1;
482 unsigned int cx;
483
484 switch (*ns_p) {
485 case PLIP_NB_BEGIN:
486 cx = nibble_timeout;
487 while (1) {
488 c0 = read_status(dev);
489 udelay(PLIP_DELAY_UNIT);
490 if ((c0 & 0x80) == 0) {
491 c1 = read_status(dev);
492 if (c0 == c1)
493 break;
494 }
495 if (--cx == 0)
496 return TIMEOUT;
497 }
498 *data_p = (c0 >> 3) & 0x0f;
499 write_data (dev, 0x10); /* send ACK */
500 *ns_p = PLIP_NB_1;
501
502 case PLIP_NB_1:
503 cx = nibble_timeout;
504 while (1) {
505 c0 = read_status(dev);
506 udelay(PLIP_DELAY_UNIT);
507 if (c0 & 0x80) {
508 c1 = read_status(dev);
509 if (c0 == c1)
510 break;
511 }
512 if (--cx == 0)
513 return TIMEOUT;
514 }
515 *data_p |= (c0 << 1) & 0xf0;
516 write_data (dev, 0x00); /* send ACK */
517 *ns_p = PLIP_NB_BEGIN;
518 case PLIP_NB_2:
519 break;
520 }
521 return OK;
522}
523
524/*
6aa20a22 525 * Determine the packet's protocol ID. The rule here is that we
1da177e4
LT		 526 * assume 802.3 if the type field is short enough to be a length.
527 * This is normal practice and works for any 'now in use' protocol.
528 *
529 * PLIP is ethernet ish but the daddr might not be valid if unicast.
530 * PLIP fortunately has no bus architecture (its Point-to-point).
531 *
532 * We can't fix the daddr thing as that quirk (more bug) is embedded
533 * in far too many old systems not all even running Linux.
534 */
6aa20a22 535
ab611487 536static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
1da177e4
LT		 537{
538 struct ethhdr *eth;
539 unsigned char *rawp;
6aa20a22 540
98e399f8 541 skb_reset_mac_header(skb);
1da177e4
LT		 542 skb_pull(skb,dev->hard_header_len);
543 eth = eth_hdr(skb);
6aa20a22 544
1da177e4
LT		 545 if(*eth->h_dest&1)
546 {
547 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
548 skb->pkt_type=PACKET_BROADCAST;
549 else
550 skb->pkt_type=PACKET_MULTICAST;
551 }
6aa20a22 552
1da177e4
LT		 553 /*
554 * This ALLMULTI check should be redundant by 1.4
555 * so don't forget to remove it.
556 */
6aa20a22 557
1da177e4
LT		 558 if (ntohs(eth->h_proto) >= 1536)
559 return eth->h_proto;
6aa20a22 560
1da177e4 561 rawp = skb->data;
6aa20a22 562
1da177e4
LT		 563 /*
564 * This is a magic hack to spot IPX packets. Older Novell breaks
565 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
566 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
567 * won't work for fault tolerant netware but does for the rest.
568 */
569 if (*(unsigned short *)rawp == 0xFFFF)
570 return htons(ETH_P_802_3);
6aa20a22 571
1da177e4
LT		 572 /*
573 * Real 802.2 LLC
574 */
575 return htons(ETH_P_802_2);
576}
577
1da177e4
LT		 578/* PLIP_RECEIVE_PACKET --- receive a packet */
579static int
580plip_receive_packet(struct net_device *dev, struct net_local *nl,
581 struct plip_local *snd, struct plip_local *rcv)
582{
583 unsigned short nibble_timeout = nl->nibble;
584 unsigned char *lbuf;
585
586 switch (rcv->state) {
587 case PLIP_PK_TRIGGER:
588 DISABLE(dev->irq);
589 /* Don't need to synchronize irq, as we can safely ignore it */
590 disable_parport_interrupts (dev);
591 write_data (dev, 0x01); /* send ACK */
592 if (net_debug > 2)
593 printk(KERN_DEBUG "%s: receive start\n", dev->name);
594 rcv->state = PLIP_PK_LENGTH_LSB;
595 rcv->nibble = PLIP_NB_BEGIN;
596
597 case PLIP_PK_LENGTH_LSB:
598 if (snd->state != PLIP_PK_DONE) {
599 if (plip_receive(nl->trigger, dev,
600 &rcv->nibble, &rcv->length.b.lsb)) {
601 /* collision, here dev->tbusy == 1 */
602 rcv->state = PLIP_PK_DONE;
603 nl->is_deferred = 1;
604 nl->connection = PLIP_CN_SEND;
605 schedule_delayed_work(&nl->deferred, 1);
606 enable_parport_interrupts (dev);
607 ENABLE(dev->irq);
608 return OK;
609 }
610 } else {
611 if (plip_receive(nibble_timeout, dev,
612 &rcv->nibble, &rcv->length.b.lsb))
613 return TIMEOUT;
614 }
615 rcv->state = PLIP_PK_LENGTH_MSB;
616
617 case PLIP_PK_LENGTH_MSB:
618 if (plip_receive(nibble_timeout, dev,
619 &rcv->nibble, &rcv->length.b.msb))
620 return TIMEOUT;
621 if (rcv->length.h > dev->mtu + dev->hard_header_len
622 || rcv->length.h < 8) {
623 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
624 return ERROR;
625 }
626 /* Malloc up new buffer. */
627 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
628 if (rcv->skb == NULL) {
629 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
630 return ERROR;
631 }
632 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */
633 skb_put(rcv->skb,rcv->length.h);
634 rcv->skb->dev = dev;
635 rcv->state = PLIP_PK_DATA;
636 rcv->byte = 0;
637 rcv->checksum = 0;
638
639 case PLIP_PK_DATA:
640 lbuf = rcv->skb->data;
641 do
642 if (plip_receive(nibble_timeout, dev,
643 &rcv->nibble, &lbuf[rcv->byte]))
644 return TIMEOUT;
645 while (++rcv->byte < rcv->length.h);
646 do
647 rcv->checksum += lbuf[--rcv->byte];
648 while (rcv->byte);
649 rcv->state = PLIP_PK_CHECKSUM;
650
651 case PLIP_PK_CHECKSUM:
652 if (plip_receive(nibble_timeout, dev,
653 &rcv->nibble, &rcv->data))
654 return TIMEOUT;
655 if (rcv->data != rcv->checksum) {
09f75cd7 656 dev->stats.rx_crc_errors++;
1da177e4
LT		 657 if (net_debug)
658 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
659 return ERROR;
660 }
661 rcv->state = PLIP_PK_DONE;
662
663 case PLIP_PK_DONE:
664 /* Inform the upper layer for the arrival of a packet. */
665 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
f6ce5cca 666 netif_rx_ni(rcv->skb);
09f75cd7
JG		 667 dev->stats.rx_bytes += rcv->length.h;
668 dev->stats.rx_packets++;
1da177e4
LT		 669 rcv->skb = NULL;
670 if (net_debug > 2)
671 printk(KERN_DEBUG "%s: receive end\n", dev->name);
672
673 /* Close the connection. */
674 write_data (dev, 0x00);
675 spin_lock_irq(&nl->lock);
676 if (snd->state != PLIP_PK_DONE) {
677 nl->connection = PLIP_CN_SEND;
678 spin_unlock_irq(&nl->lock);
679 schedule_work(&nl->immediate);
680 enable_parport_interrupts (dev);
681 ENABLE(dev->irq);
682 return OK;
683 } else {
684 nl->connection = PLIP_CN_NONE;
685 spin_unlock_irq(&nl->lock);
686 enable_parport_interrupts (dev);
687 ENABLE(dev->irq);
688 return OK;
689 }
690 }
691 return OK;
692}
693
694/* PLIP_SEND --- send a byte (two nibbles)
695 Returns OK on success, TIMEOUT when timeout */
77933d72 696static inline int
1da177e4
LT		 697plip_send(unsigned short nibble_timeout, struct net_device *dev,
698 enum plip_nibble_state *ns_p, unsigned char data)
699{
700 unsigned char c0;
701 unsigned int cx;
702
703 switch (*ns_p) {
704 case PLIP_NB_BEGIN:
705 write_data (dev, data & 0x0f);
706 *ns_p = PLIP_NB_1;
707
708 case PLIP_NB_1:
709 write_data (dev, 0x10 | (data & 0x0f));
710 cx = nibble_timeout;
711 while (1) {
712 c0 = read_status(dev);
713 if ((c0 & 0x80) == 0)
714 break;
715 if (--cx == 0)
716 return TIMEOUT;
717 udelay(PLIP_DELAY_UNIT);
718 }
719 write_data (dev, 0x10 | (data >> 4));
720 *ns_p = PLIP_NB_2;
721
722 case PLIP_NB_2:
723 write_data (dev, (data >> 4));
724 cx = nibble_timeout;
725 while (1) {
726 c0 = read_status(dev);
727 if (c0 & 0x80)
728 break;
729 if (--cx == 0)
730 return TIMEOUT;
731 udelay(PLIP_DELAY_UNIT);
732 }
733 *ns_p = PLIP_NB_BEGIN;
734 return OK;
735 }
736 return OK;
737}
738
739/* PLIP_SEND_PACKET --- send a packet */
740static int
741plip_send_packet(struct net_device *dev, struct net_local *nl,
742 struct plip_local *snd, struct plip_local *rcv)
743{
744 unsigned short nibble_timeout = nl->nibble;
745 unsigned char *lbuf;
746 unsigned char c0;
747 unsigned int cx;
748
749 if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
750 printk(KERN_DEBUG "%s: send skb lost\n", dev->name);
751 snd->state = PLIP_PK_DONE;
752 snd->skb = NULL;
753 return ERROR;
754 }
755
756 switch (snd->state) {
757 case PLIP_PK_TRIGGER:
758 if ((read_status(dev) & 0xf8) != 0x80)
759 return HS_TIMEOUT;
760
761 /* Trigger remote rx interrupt. */
762 write_data (dev, 0x08);
763 cx = nl->trigger;
764 while (1) {
765 udelay(PLIP_DELAY_UNIT);
766 spin_lock_irq(&nl->lock);
767 if (nl->connection == PLIP_CN_RECEIVE) {
768 spin_unlock_irq(&nl->lock);
769 /* Interrupted. */
09f75cd7 770 dev->stats.collisions++;
1da177e4
LT		 771 return OK;
772 }
773 c0 = read_status(dev);
774 if (c0 & 0x08) {
775 spin_unlock_irq(&nl->lock);
776 DISABLE(dev->irq);
777 synchronize_irq(dev->irq);
778 if (nl->connection == PLIP_CN_RECEIVE) {
779 /* Interrupted.
780 We don't need to enable irq,
781 as it is soon disabled. */
782 /* Yes, we do. New variant of
783 {enable,disable}_irq *counts*
784 them. -- AV */
785 ENABLE(dev->irq);
09f75cd7 786 dev->stats.collisions++;
1da177e4
LT		 787 return OK;
788 }
789 disable_parport_interrupts (dev);
790 if (net_debug > 2)
791 printk(KERN_DEBUG "%s: send start\n", dev->name);
792 snd->state = PLIP_PK_LENGTH_LSB;
793 snd->nibble = PLIP_NB_BEGIN;
794 nl->timeout_count = 0;
795 break;
796 }
797 spin_unlock_irq(&nl->lock);
798 if (--cx == 0) {
799 write_data (dev, 0x00);
800 return HS_TIMEOUT;
801 }
802 }
803
804 case PLIP_PK_LENGTH_LSB:
805 if (plip_send(nibble_timeout, dev,
806 &snd->nibble, snd->length.b.lsb))
807 return TIMEOUT;
808 snd->state = PLIP_PK_LENGTH_MSB;
809
810 case PLIP_PK_LENGTH_MSB:
811 if (plip_send(nibble_timeout, dev,
812 &snd->nibble, snd->length.b.msb))
813 return TIMEOUT;
814 snd->state = PLIP_PK_DATA;
815 snd->byte = 0;
816 snd->checksum = 0;
817
818 case PLIP_PK_DATA:
819 do
820 if (plip_send(nibble_timeout, dev,
821 &snd->nibble, lbuf[snd->byte]))
822 return TIMEOUT;
823 while (++snd->byte < snd->length.h);
824 do
825 snd->checksum += lbuf[--snd->byte];
826 while (snd->byte);
827 snd->state = PLIP_PK_CHECKSUM;
828
829 case PLIP_PK_CHECKSUM:
830 if (plip_send(nibble_timeout, dev,
831 &snd->nibble, snd->checksum))
832 return TIMEOUT;
833
09f75cd7 834 dev->stats.tx_bytes += snd->skb->len;
1da177e4 835 dev_kfree_skb(snd->skb);
09f75cd7 836 dev->stats.tx_packets++;
1da177e4
LT		 837 snd->state = PLIP_PK_DONE;
838
839 case PLIP_PK_DONE:
840 /* Close the connection */
841 write_data (dev, 0x00);
842 snd->skb = NULL;
843 if (net_debug > 2)
844 printk(KERN_DEBUG "%s: send end\n", dev->name);
845 nl->connection = PLIP_CN_CLOSING;
846 nl->is_deferred = 1;
847 schedule_delayed_work(&nl->deferred, 1);
848 enable_parport_interrupts (dev);
849 ENABLE(dev->irq);
850 return OK;
851 }
852 return OK;
853}
854
855static int
856plip_connection_close(struct net_device *dev, struct net_local *nl,
857 struct plip_local *snd, struct plip_local *rcv)
858{
859 spin_lock_irq(&nl->lock);
860 if (nl->connection == PLIP_CN_CLOSING) {
861 nl->connection = PLIP_CN_NONE;
862 netif_wake_queue (dev);
863 }
864 spin_unlock_irq(&nl->lock);
865 if (nl->should_relinquish) {
866 nl->should_relinquish = nl->port_owner = 0;
867 parport_release(nl->pardev);
868 }
869 return OK;
870}
871
872/* PLIP_ERROR --- wait till other end settled */
873static int
874plip_error(struct net_device *dev, struct net_local *nl,
875 struct plip_local *snd, struct plip_local *rcv)
876{
877 unsigned char status;
878
879 status = read_status(dev);
880 if ((status & 0xf8) == 0x80) {
881 if (net_debug > 2)
882 printk(KERN_DEBUG "%s: reset interface.\n", dev->name);
883 nl->connection = PLIP_CN_NONE;
884 nl->should_relinquish = 0;
885 netif_start_queue (dev);
886 enable_parport_interrupts (dev);
887 ENABLE(dev->irq);
888 netif_wake_queue (dev);
889 } else {
890 nl->is_deferred = 1;
891 schedule_delayed_work(&nl->deferred, 1);
892 }
893
894 return OK;
895}
77933d72 896
1da177e4
LT		 897/* Handle the parallel port interrupts. */
898static void
5712cb3d 899plip_interrupt(void *dev_id)
1da177e4
LT		 900{
901 struct net_device *dev = dev_id;
902 struct net_local *nl;
903 struct plip_local *rcv;
904 unsigned char c0;
cabce28e 905 unsigned long flags;
1da177e4 906
1da177e4
LT		 907 nl = netdev_priv(dev);
908 rcv = &nl->rcv_data;
909
cabce28e 910 spin_lock_irqsave (&nl->lock, flags);
1da177e4
LT		 911
912 c0 = read_status(dev);
913 if ((c0 & 0xf8) != 0xc0) {
914 if ((dev->irq != -1) && (net_debug > 1))
915 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
cabce28e 916 spin_unlock_irqrestore (&nl->lock, flags);
1da177e4
LT		 917 return;
918 }
919
920 if (net_debug > 3)
921 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
922
923 switch (nl->connection) {
924 case PLIP_CN_CLOSING:
925 netif_wake_queue (dev);
926 case PLIP_CN_NONE:
927 case PLIP_CN_SEND:
928 rcv->state = PLIP_PK_TRIGGER;
929 nl->connection = PLIP_CN_RECEIVE;
930 nl->timeout_count = 0;
931 schedule_work(&nl->immediate);
932 break;
933
934 case PLIP_CN_RECEIVE:
935 /* May occur because there is race condition
936 around test and set of dev->interrupt.
937 Ignore this interrupt. */
938 break;
939
940 case PLIP_CN_ERROR:
941 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
942 break;
943 }
944
cabce28e 945 spin_unlock_irqrestore(&nl->lock, flags);
1da177e4 946}
77933d72 947
1da177e4
LT		 948static int
949plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
950{
951 struct net_local *nl = netdev_priv(dev);
952 struct plip_local *snd = &nl->snd_data;
953
954 if (netif_queue_stopped(dev))
955 return 1;
956
957 /* We may need to grab the bus */
958 if (!nl->port_owner) {
959 if (parport_claim(nl->pardev))
960 return 1;
961 nl->port_owner = 1;
962 }
963
964 netif_stop_queue (dev);
6aa20a22 965
1da177e4
LT		 966 if (skb->len > dev->mtu + dev->hard_header_len) {
967 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
968 netif_start_queue (dev);
969 return 1;
970 }
971
972 if (net_debug > 2)
973 printk(KERN_DEBUG "%s: send request\n", dev->name);
974
975 spin_lock_irq(&nl->lock);
976 dev->trans_start = jiffies;
977 snd->skb = skb;
978 snd->length.h = skb->len;
979 snd->state = PLIP_PK_TRIGGER;
980 if (nl->connection == PLIP_CN_NONE) {
981 nl->connection = PLIP_CN_SEND;
982 nl->timeout_count = 0;
983 }
984 schedule_work(&nl->immediate);
985 spin_unlock_irq(&nl->lock);
6aa20a22 986
1da177e4
LT		 987 return 0;
988}
989
990static void
3b04ddde 991plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth)
1da177e4 992{
3b04ddde 993 const struct in_device *in_dev = dev->ip_ptr;
1da177e4 994
3b04ddde 995 if (in_dev) {
1da177e4 996 /* Any address will do - we take the first */
3b04ddde
SH		 997 const struct in_ifaddr *ifa = in_dev->ifa_list;
998 if (ifa) {
1da177e4
LT		 999 memcpy(eth->h_source, dev->dev_addr, 6);
1000 memset(eth->h_dest, 0xfc, 2);
1001 memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1002 }
1003 }
1004}
1005
1006static int
1007plip_hard_header(struct sk_buff *skb, struct net_device *dev,
3b04ddde
SH		 1008 unsigned short type, const void *daddr,
1009 const void *saddr, unsigned len)
1da177e4 1010{
1da177e4
LT		 1011 int ret;
1012
3b04ddde
SH		 1013 ret = eth_header(skb, dev, type, daddr, saddr, len);
1014 if (ret >= 0)
1da177e4
LT		 1015 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1016
1017 return ret;
1018}
1019
3b04ddde 1020int plip_hard_header_cache(const struct neighbour *neigh,
1da177e4
LT		 1021 struct hh_cache *hh)
1022{
1da177e4 1023 int ret;
6aa20a22 1024
3b04ddde
SH		 1025 ret = eth_header_cache(neigh, hh);
1026 if (ret == 0) {
1da177e4
LT		 1027 struct ethhdr *eth;
1028
1029 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1030 HH_DATA_OFF(sizeof(*eth)));
1031 plip_rewrite_address (neigh->dev, eth);
1032 }
6aa20a22 1033
1da177e4 1034 return ret;
6aa20a22 1035}
1da177e4
LT		 1036
1037/* Open/initialize the board. This is called (in the current kernel)
1038 sometime after booting when the 'ifconfig' program is run.
1039
1040 This routine gets exclusive access to the parallel port by allocating
1041 its IRQ line.
1042 */
1043static int
1044plip_open(struct net_device *dev)
1045{
1046 struct net_local *nl = netdev_priv(dev);
1047 struct in_device *in_dev;
1048
1049 /* Grab the port */
1050 if (!nl->port_owner) {
1051 if (parport_claim(nl->pardev)) return -EAGAIN;
1052 nl->port_owner = 1;
1053 }
1054
1055 nl->should_relinquish = 0;
1056
1057 /* Clear the data port. */
1058 write_data (dev, 0x00);
1059
1060 /* Enable rx interrupt. */
1061 enable_parport_interrupts (dev);
1062 if (dev->irq == -1)
1063 {
1064 atomic_set (&nl->kill_timer, 0);
1065 schedule_delayed_work(&nl->timer, 1);
1066 }
1067
1068 /* Initialize the state machine. */
1069 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1070 nl->rcv_data.skb = nl->snd_data.skb = NULL;
1071 nl->connection = PLIP_CN_NONE;
1072 nl->is_deferred = 0;
1073
1074 /* Fill in the MAC-level header.
1075 We used to abuse dev->broadcast to store the point-to-point
1076 MAC address, but we no longer do it. Instead, we fetch the
1077 interface address whenever it is needed, which is cheap enough
1078 because we use the hh_cache. Actually, abusing dev->broadcast
1079 didn't work, because when using plip_open the point-to-point
1080 address isn't yet known.
1081 PLIP doesn't have a real MAC address, but we need it to be
1082 DOS compatible, and to properly support taps (otherwise,
1083 when the device address isn't identical to the address of a
1084 received frame, the kernel incorrectly drops it). */
1085
1086 if ((in_dev=dev->ip_ptr) != NULL) {
1087 /* Any address will do - we take the first. We already
1088 have the first two bytes filled with 0xfc, from
1089 plip_init_dev(). */
1090 struct in_ifaddr *ifa=in_dev->ifa_list;
1091 if (ifa != NULL) {
1092 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1093 }
1094 }
1095
1096 netif_start_queue (dev);
1097
1098 return 0;
1099}
1100
1101/* The inverse routine to plip_open (). */
1102static int
1103plip_close(struct net_device *dev)
1104{
1105 struct net_local *nl = netdev_priv(dev);
1106 struct plip_local *snd = &nl->snd_data;
1107 struct plip_local *rcv = &nl->rcv_data;
1108
1109 netif_stop_queue (dev);
1110 DISABLE(dev->irq);
1111 synchronize_irq(dev->irq);
1112
1113 if (dev->irq == -1)
1114 {
01f31ac8 1115 init_completion(&nl->killed_timer_cmp);
1da177e4 1116 atomic_set (&nl->kill_timer, 1);
01f31ac8 1117 wait_for_completion(&nl->killed_timer_cmp);
1da177e4
LT		 1118 }
1119
1120#ifdef NOTDEF
1121 outb(0x00, PAR_DATA(dev));
1122#endif
1123 nl->is_deferred = 0;
1124 nl->connection = PLIP_CN_NONE;
1125 if (nl->port_owner) {
1126 parport_release(nl->pardev);
1127 nl->port_owner = 0;
1128 }
1129
1130 snd->state = PLIP_PK_DONE;
1131 if (snd->skb) {
1132 dev_kfree_skb(snd->skb);
1133 snd->skb = NULL;
1134 }
1135 rcv->state = PLIP_PK_DONE;
1136 if (rcv->skb) {
1137 kfree_skb(rcv->skb);
1138 rcv->skb = NULL;
1139 }
1140
1141#ifdef NOTDEF
1142 /* Reset. */
1143 outb(0x00, PAR_CONTROL(dev));
1144#endif
1145 return 0;
1146}
1147
1148static int
1149plip_preempt(void *handle)
1150{
1151 struct net_device *dev = (struct net_device *)handle;
1152 struct net_local *nl = netdev_priv(dev);
1153
1154 /* Stand our ground if a datagram is on the wire */
1155 if (nl->connection != PLIP_CN_NONE) {
1156 nl->should_relinquish = 1;
1157 return 1;
1158 }
1159
1160 nl->port_owner = 0; /* Remember that we released the bus */
1161 return 0;
1162}
1163
1164static void
1165plip_wakeup(void *handle)
1166{
1167 struct net_device *dev = (struct net_device *)handle;
1168 struct net_local *nl = netdev_priv(dev);
1169
1170 if (nl->port_owner) {
1171 /* Why are we being woken up? */
1172 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1173 if (!parport_claim(nl->pardev))
1174 /* bus_owner is already set (but why?) */
1175 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1176 else
1177 return;
1178 }
6aa20a22 1179
1da177e4
LT		 1180 if (!(dev->flags & IFF_UP))
1181 /* Don't need the port when the interface is down */
1182 return;
1183
1184 if (!parport_claim(nl->pardev)) {
1185 nl->port_owner = 1;
1186 /* Clear the data port. */
1187 write_data (dev, 0x00);
1188 }
1189
1190 return;
1191}
1192
1da177e4
LT		 1193static int
1194plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1195{
1196 struct net_local *nl = netdev_priv(dev);
1197 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1198
1199 if (cmd != SIOCDEVPLIP)
1200 return -EOPNOTSUPP;
1201
1202 switch(pc->pcmd) {
1203 case PLIP_GET_TIMEOUT:
1204 pc->trigger = nl->trigger;
1205 pc->nibble = nl->nibble;
1206 break;
1207 case PLIP_SET_TIMEOUT:
1208 if(!capable(CAP_NET_ADMIN))
1209 return -EPERM;
1210 nl->trigger = pc->trigger;
1211 nl->nibble = pc->nibble;
1212 break;
1213 default:
1214 return -EOPNOTSUPP;
1215 }
1216 return 0;
1217}
77933d72 1218
1da177e4
LT		 1219static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1220static int timid;
1221
1222module_param_array(parport, int, NULL, 0);
1223module_param(timid, int, 0);
1224MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1225
1226static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1227
1228static inline int
1229plip_searchfor(int list[], int a)
1230{
1231 int i;
1232 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1233 if (list[i] == a) return 1;
1234 }
1235 return 0;
1236}
1237
1238/* plip_attach() is called (by the parport code) when a port is
1239 * available to use. */
1240static void plip_attach (struct parport *port)
1241{
1242 static int unit;
1243 struct net_device *dev;
1244 struct net_local *nl;
1245 char name[IFNAMSIZ];
1246
6aa20a22 1247 if ((parport[0] == -1 && (!timid || !port->devices)) ||
1da177e4
LT		 1248 plip_searchfor(parport, port->number)) {
1249 if (unit == PLIP_MAX) {
1250 printk(KERN_ERR "plip: too many devices\n");
1251 return;
1252 }
1253
1254 sprintf(name, "plip%d", unit);
1255 dev = alloc_etherdev(sizeof(struct net_local));
1256 if (!dev) {
1257 printk(KERN_ERR "plip: memory squeeze\n");
1258 return;
1259 }
6aa20a22 1260
1da177e4
LT		 1261 strcpy(dev->name, name);
1262
1da177e4
LT		 1263 dev->irq = port->irq;
1264 dev->base_addr = port->base;
1265 if (port->irq == -1) {
1266 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1267 "which is fairly inefficient!\n", port->name);
1268 }
1269
1270 nl = netdev_priv(dev);
c4028958 1271 nl->dev = dev;
cdb32706 1272 nl->pardev = parport_register_device(port, dev->name, plip_preempt,
6aa20a22 1273 plip_wakeup, plip_interrupt,
1da177e4
LT		 1274 0, dev);
1275
1276 if (!nl->pardev) {
1277 printk(KERN_ERR "%s: parport_register failed\n", name);
1278 goto err_free_dev;
1279 return;
1280 }
1281
1282 plip_init_netdev(dev);
1283
1284 if (register_netdev(dev)) {
1285 printk(KERN_ERR "%s: network register failed\n", name);
1286 goto err_parport_unregister;
1287 }
1288
1289 printk(KERN_INFO "%s", version);
1290 if (dev->irq != -1)
1291 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1292 "using IRQ %d.\n",
1293 dev->name, dev->base_addr, dev->irq);
1294 else
1295 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1296 "not using IRQ.\n",
1297 dev->name, dev->base_addr);
1298 dev_plip[unit++] = dev;
1299 }
1300 return;
1301
1302err_parport_unregister:
1303 parport_unregister_device(nl->pardev);
1304err_free_dev:
1305 free_netdev(dev);
1306 return;
1307}
1308
1309/* plip_detach() is called (by the parport code) when a port is
1310 * no longer available to use. */
1311static void plip_detach (struct parport *port)
1312{
1313 /* Nothing to do */
1314}
1315
1316static struct parport_driver plip_driver = {
1317 .name = "plip",
1318 .attach = plip_attach,
1319 .detach = plip_detach
1320};
1321
1322static void __exit plip_cleanup_module (void)
1323{
1324 struct net_device *dev;
1325 int i;
1326
1327 parport_unregister_driver (&plip_driver);
1328
1329 for (i=0; i < PLIP_MAX; i++) {
1330 if ((dev = dev_plip[i])) {
1331 struct net_local *nl = netdev_priv(dev);
1332 unregister_netdev(dev);
1333 if (nl->port_owner)
1334 parport_release(nl->pardev);
1335 parport_unregister_device(nl->pardev);
1336 free_netdev(dev);
1337 dev_plip[i] = NULL;
1338 }
1339 }
1340}
1341
1342#ifndef MODULE
1343
1344static int parport_ptr;
1345
1346static int __init plip_setup(char *str)
1347{
1348 int ints[4];
1349
1350 str = get_options(str, ARRAY_SIZE(ints), ints);
1351
1352 /* Ugh. */
1353 if (!strncmp(str, "parport", 7)) {
1354 int n = simple_strtoul(str+7, NULL, 10);
1355 if (parport_ptr < PLIP_MAX)
1356 parport[parport_ptr++] = n;
1357 else
1358 printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1359 str);
1360 } else if (!strcmp(str, "timid")) {
1361 timid = 1;
1362 } else {
1363 if (ints[0] == 0 || ints[1] == 0) {
1364 /* disable driver on "plip=" or "plip=0" */
1365 parport[0] = -2;
1366 } else {
6aa20a22 1367 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1da177e4
LT		 1368 ints[1]);
1369 }
1370 }
1371 return 1;
1372}
1373
1374__setup("plip=", plip_setup);
1375
1376#endif /* !MODULE */
1377
1378static int __init plip_init (void)
1379{
1380 if (parport[0] == -2)
1381 return 0;
1382
1383 if (parport[0] != -1 && timid) {
1384 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1385 timid = 0;
1386 }
1387
1388 if (parport_register_driver (&plip_driver)) {
1389 printk (KERN_WARNING "plip: couldn't register driver\n");
1390 return 1;
1391 }
1392
1393 return 0;
1394}
1395
1396module_init(plip_init);
1397module_exit(plip_cleanup_module);
1398MODULE_LICENSE("GPL");
ubuntu-zesty-kernel mirror