projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
r8169: Fix warning in rtl8169_start_xmit().
[GitHub/mt8127/android_kernel_alcatel_ttab.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
ed8cf436
SH		 268static const struct net_device_ops plip_netdev_ops = {
269 .ndo_open = plip_open,
270 .ndo_stop = plip_close,
271 .ndo_start_xmit = plip_tx_packet,
272 .ndo_do_ioctl = plip_ioctl,
635ecaa7 273 .ndo_change_mtu = eth_change_mtu,
240c102d
BH		 274 .ndo_set_mac_address = eth_mac_addr,
275 .ndo_validate_addr = eth_validate_addr,
ed8cf436
SH		 276};
277
1da177e4
LT		 278/* Entry point of PLIP driver.
279 Probe the hardware, and register/initialize the driver.
280
281 PLIP is rather weird, because of the way it interacts with the parport
282 system. It is _not_ initialised from Space.c. Instead, plip_init()
283 is called, and that function makes up a "struct net_device" for each port, and
284 then calls us here.
285
286 */
287static void
288plip_init_netdev(struct net_device *dev)
289{
290 struct net_local *nl = netdev_priv(dev);
291
292 /* Then, override parts of it */
1da177e4
LT		 293 dev->tx_queue_len = 10;
294 dev->flags = IFF_POINTOPOINT|IFF_NOARP;
295 memset(dev->dev_addr, 0xfc, ETH_ALEN);
296
ed8cf436 297 dev->netdev_ops = &plip_netdev_ops;
3b04ddde 298 dev->header_ops = &plip_header_ops;
1da177e4
LT		 299
300
301 nl->port_owner = 0;
302
303 /* Initialize constants */
304 nl->trigger = PLIP_TRIGGER_WAIT;
305 nl->nibble = PLIP_NIBBLE_WAIT;
306
307 /* Initialize task queue structures */
c4028958
DH		 308 INIT_WORK(&nl->immediate, plip_bh);
309 INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);
1da177e4
LT		 310
311 if (dev->irq == -1)
c4028958 312 INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);
1da177e4
LT		 313
314 spin_lock_init(&nl->lock);
315}
77933d72 316
1da177e4
LT		 317/* Bottom half handler for the delayed request.
318 This routine is kicked by do_timer().
319 Request `plip_bh' to be invoked. */
320static void
c4028958 321plip_kick_bh(struct work_struct *work)
1da177e4 322{
c4028958
DH		 323 struct net_local *nl =
324 container_of(work, struct net_local, deferred.work);
1da177e4
LT		 325
326 if (nl->is_deferred)
327 schedule_work(&nl->immediate);
328}
329
330/* Forward declarations of internal routines */
331static int plip_none(struct net_device *, struct net_local *,
332 struct plip_local *, struct plip_local *);
333static int plip_receive_packet(struct net_device *, struct net_local *,
334 struct plip_local *, struct plip_local *);
335static int plip_send_packet(struct net_device *, struct net_local *,
336 struct plip_local *, struct plip_local *);
337static int plip_connection_close(struct net_device *, struct net_local *,
338 struct plip_local *, struct plip_local *);
339static int plip_error(struct net_device *, struct net_local *,
340 struct plip_local *, struct plip_local *);
341static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
342 struct plip_local *snd,
343 struct plip_local *rcv,
344 int error);
345
346#define OK 0
347#define TIMEOUT 1
348#define ERROR 2
349#define HS_TIMEOUT 3
350
351typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
352 struct plip_local *snd, struct plip_local *rcv);
353
f71e1309 354static const plip_func connection_state_table[] =
1da177e4
LT		 355{
356 plip_none,
357 plip_receive_packet,
358 plip_send_packet,
359 plip_connection_close,
360 plip_error
361};
362
363/* Bottom half handler of PLIP. */
364static void
c4028958 365plip_bh(struct work_struct *work)
1da177e4 366{
c4028958 367 struct net_local *nl = container_of(work, struct net_local, immediate);
1da177e4
LT		 368 struct plip_local *snd = &nl->snd_data;
369 struct plip_local *rcv = &nl->rcv_data;
370 plip_func f;
371 int r;
372
373 nl->is_deferred = 0;
374 f = connection_state_table[nl->connection];
c4028958
DH		 375 if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK
376 && (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) {
1da177e4
LT		 377 nl->is_deferred = 1;
378 schedule_delayed_work(&nl->deferred, 1);
379 }
380}
381
382static void
c4028958 383plip_timer_bh(struct work_struct *work)
1da177e4 384{
c4028958
DH		 385 struct net_local *nl =
386 container_of(work, struct net_local, timer.work);
6aa20a22 387
1da177e4 388 if (!(atomic_read (&nl->kill_timer))) {
5712cb3d 389 plip_interrupt (nl->dev);
1da177e4
LT		 390
391 schedule_delayed_work(&nl->timer, 1);
392 }
393 else {
01f31ac8 394 complete(&nl->killed_timer_cmp);
1da177e4
LT		 395 }
396}
397
398static int
399plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
400 struct plip_local *snd, struct plip_local *rcv,
401 int error)
402{
403 unsigned char c0;
404 /*
405 * This is tricky. If we got here from the beginning of send (either
406 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
407 * already disabled. With the old variant of {enable,disable}_irq()
408 * extra disable_irq() was a no-op. Now it became mortal - it's
409 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
410 * that is). So we have to treat HS_TIMEOUT and ERROR from send
411 * in a special way.
412 */
413
414 spin_lock_irq(&nl->lock);
415 if (nl->connection == PLIP_CN_SEND) {
416
417 if (error != ERROR) { /* Timeout */
418 nl->timeout_count++;
419 if ((error == HS_TIMEOUT
420 && nl->timeout_count <= 10)
421 || nl->timeout_count <= 3) {
422 spin_unlock_irq(&nl->lock);
423 /* Try again later */
424 return TIMEOUT;
425 }
426 c0 = read_status(dev);
427 printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
428 dev->name, snd->state, c0);
429 } else
430 error = HS_TIMEOUT;
09f75cd7
JG		 431 dev->stats.tx_errors++;
432 dev->stats.tx_aborted_errors++;
1da177e4
LT		 433 } else if (nl->connection == PLIP_CN_RECEIVE) {
434 if (rcv->state == PLIP_PK_TRIGGER) {
435 /* Transmission was interrupted. */
436 spin_unlock_irq(&nl->lock);
437 return OK;
438 }
439 if (error != ERROR) { /* Timeout */
440 if (++nl->timeout_count <= 3) {
441 spin_unlock_irq(&nl->lock);
442 /* Try again later */
443 return TIMEOUT;
444 }
445 c0 = read_status(dev);
446 printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
447 dev->name, rcv->state, c0);
448 }
09f75cd7 449 dev->stats.rx_dropped++;
1da177e4
LT		 450 }
451 rcv->state = PLIP_PK_DONE;
452 if (rcv->skb) {
453 kfree_skb(rcv->skb);
454 rcv->skb = NULL;
455 }
456 snd->state = PLIP_PK_DONE;
457 if (snd->skb) {
458 dev_kfree_skb(snd->skb);
459 snd->skb = NULL;
460 }
461 spin_unlock_irq(&nl->lock);
462 if (error == HS_TIMEOUT) {
463 DISABLE(dev->irq);
464 synchronize_irq(dev->irq);
465 }
466 disable_parport_interrupts (dev);
467 netif_stop_queue (dev);
468 nl->connection = PLIP_CN_ERROR;
469 write_data (dev, 0x00);
470
471 return TIMEOUT;
472}
77933d72 473
1da177e4
LT		 474static int
475plip_none(struct net_device *dev, struct net_local *nl,
476 struct plip_local *snd, struct plip_local *rcv)
477{
478 return OK;
479}
480
481/* PLIP_RECEIVE --- receive a byte(two nibbles)
482 Returns OK on success, TIMEOUT on timeout */
77933d72 483static inline int
1da177e4
LT		 484plip_receive(unsigned short nibble_timeout, struct net_device *dev,
485 enum plip_nibble_state *ns_p, unsigned char *data_p)
486{
487 unsigned char c0, c1;
488 unsigned int cx;
489
490 switch (*ns_p) {
491 case PLIP_NB_BEGIN:
492 cx = nibble_timeout;
493 while (1) {
494 c0 = read_status(dev);
495 udelay(PLIP_DELAY_UNIT);
496 if ((c0 & 0x80) == 0) {
497 c1 = read_status(dev);
498 if (c0 == c1)
499 break;
500 }
501 if (--cx == 0)
502 return TIMEOUT;
503 }
504 *data_p = (c0 >> 3) & 0x0f;
505 write_data (dev, 0x10); /* send ACK */
506 *ns_p = PLIP_NB_1;
507
508 case PLIP_NB_1:
509 cx = nibble_timeout;
510 while (1) {
511 c0 = read_status(dev);
512 udelay(PLIP_DELAY_UNIT);
513 if (c0 & 0x80) {
514 c1 = read_status(dev);
515 if (c0 == c1)
516 break;
517 }
518 if (--cx == 0)
519 return TIMEOUT;
520 }
521 *data_p |= (c0 << 1) & 0xf0;
522 write_data (dev, 0x00); /* send ACK */
523 *ns_p = PLIP_NB_BEGIN;
524 case PLIP_NB_2:
525 break;
526 }
527 return OK;
528}
529
530/*
6aa20a22 531 * Determine the packet's protocol ID. The rule here is that we
1da177e4
LT		 532 * assume 802.3 if the type field is short enough to be a length.
533 * This is normal practice and works for any 'now in use' protocol.
534 *
535 * PLIP is ethernet ish but the daddr might not be valid if unicast.
536 * PLIP fortunately has no bus architecture (its Point-to-point).
537 *
538 * We can't fix the daddr thing as that quirk (more bug) is embedded
539 * in far too many old systems not all even running Linux.
540 */
6aa20a22 541
ab611487 542static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
1da177e4
LT		 543{
544 struct ethhdr *eth;
545 unsigned char *rawp;
6aa20a22 546
98e399f8 547 skb_reset_mac_header(skb);
1da177e4
LT		 548 skb_pull(skb,dev->hard_header_len);
549 eth = eth_hdr(skb);
6aa20a22 550
1da177e4
LT		 551 if(*eth->h_dest&1)
552 {
553 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
554 skb->pkt_type=PACKET_BROADCAST;
555 else
556 skb->pkt_type=PACKET_MULTICAST;
557 }
6aa20a22 558
1da177e4
LT		 559 /*
560 * This ALLMULTI check should be redundant by 1.4
561 * so don't forget to remove it.
562 */
6aa20a22 563
1da177e4
LT		 564 if (ntohs(eth->h_proto) >= 1536)
565 return eth->h_proto;
6aa20a22 566
1da177e4 567 rawp = skb->data;
6aa20a22 568
1da177e4
LT		 569 /*
570 * This is a magic hack to spot IPX packets. Older Novell breaks
571 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
572 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
573 * won't work for fault tolerant netware but does for the rest.
574 */
575 if (*(unsigned short *)rawp == 0xFFFF)
576 return htons(ETH_P_802_3);
6aa20a22 577
1da177e4
LT		 578 /*
579 * Real 802.2 LLC
580 */
581 return htons(ETH_P_802_2);
582}
583
1da177e4
LT		 584/* PLIP_RECEIVE_PACKET --- receive a packet */
585static int
586plip_receive_packet(struct net_device *dev, struct net_local *nl,
587 struct plip_local *snd, struct plip_local *rcv)
588{
589 unsigned short nibble_timeout = nl->nibble;
590 unsigned char *lbuf;
591
592 switch (rcv->state) {
593 case PLIP_PK_TRIGGER:
594 DISABLE(dev->irq);
595 /* Don't need to synchronize irq, as we can safely ignore it */
596 disable_parport_interrupts (dev);
597 write_data (dev, 0x01); /* send ACK */
598 if (net_debug > 2)
599 printk(KERN_DEBUG "%s: receive start\n", dev->name);
600 rcv->state = PLIP_PK_LENGTH_LSB;
601 rcv->nibble = PLIP_NB_BEGIN;
602
603 case PLIP_PK_LENGTH_LSB:
604 if (snd->state != PLIP_PK_DONE) {
605 if (plip_receive(nl->trigger, dev,
606 &rcv->nibble, &rcv->length.b.lsb)) {
607 /* collision, here dev->tbusy == 1 */
608 rcv->state = PLIP_PK_DONE;
609 nl->is_deferred = 1;
610 nl->connection = PLIP_CN_SEND;
611 schedule_delayed_work(&nl->deferred, 1);
612 enable_parport_interrupts (dev);
613 ENABLE(dev->irq);
614 return OK;
615 }
616 } else {
617 if (plip_receive(nibble_timeout, dev,
618 &rcv->nibble, &rcv->length.b.lsb))
619 return TIMEOUT;
620 }
621 rcv->state = PLIP_PK_LENGTH_MSB;
622
623 case PLIP_PK_LENGTH_MSB:
624 if (plip_receive(nibble_timeout, dev,
625 &rcv->nibble, &rcv->length.b.msb))
626 return TIMEOUT;
627 if (rcv->length.h > dev->mtu + dev->hard_header_len
628 || rcv->length.h < 8) {
629 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
630 return ERROR;
631 }
632 /* Malloc up new buffer. */
633 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
634 if (rcv->skb == NULL) {
635 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
636 return ERROR;
637 }
638 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */
639 skb_put(rcv->skb,rcv->length.h);
640 rcv->skb->dev = dev;
641 rcv->state = PLIP_PK_DATA;
642 rcv->byte = 0;
643 rcv->checksum = 0;
644
645 case PLIP_PK_DATA:
646 lbuf = rcv->skb->data;
e4c3c13c 647 do {
1da177e4
LT		 648 if (plip_receive(nibble_timeout, dev,
649 &rcv->nibble, &lbuf[rcv->byte]))
650 return TIMEOUT;
e4c3c13c
HE		 651 } while (++rcv->byte < rcv->length.h);
652 do {
1da177e4 653 rcv->checksum += lbuf[--rcv->byte];
e4c3c13c 654 } while (rcv->byte);
1da177e4
LT		 655 rcv->state = PLIP_PK_CHECKSUM;
656
657 case PLIP_PK_CHECKSUM:
658 if (plip_receive(nibble_timeout, dev,
659 &rcv->nibble, &rcv->data))
660 return TIMEOUT;
661 if (rcv->data != rcv->checksum) {
09f75cd7 662 dev->stats.rx_crc_errors++;
1da177e4
LT		 663 if (net_debug)
664 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
665 return ERROR;
666 }
667 rcv->state = PLIP_PK_DONE;
668
669 case PLIP_PK_DONE:
670 /* Inform the upper layer for the arrival of a packet. */
671 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
f6ce5cca 672 netif_rx_ni(rcv->skb);
09f75cd7
JG		 673 dev->stats.rx_bytes += rcv->length.h;
674 dev->stats.rx_packets++;
1da177e4
LT		 675 rcv->skb = NULL;
676 if (net_debug > 2)
677 printk(KERN_DEBUG "%s: receive end\n", dev->name);
678
679 /* Close the connection. */
680 write_data (dev, 0x00);
681 spin_lock_irq(&nl->lock);
682 if (snd->state != PLIP_PK_DONE) {
683 nl->connection = PLIP_CN_SEND;
684 spin_unlock_irq(&nl->lock);
685 schedule_work(&nl->immediate);
686 enable_parport_interrupts (dev);
687 ENABLE(dev->irq);
688 return OK;
689 } else {
690 nl->connection = PLIP_CN_NONE;
691 spin_unlock_irq(&nl->lock);
692 enable_parport_interrupts (dev);
693 ENABLE(dev->irq);
694 return OK;
695 }
696 }
697 return OK;
698}
699
700/* PLIP_SEND --- send a byte (two nibbles)
701 Returns OK on success, TIMEOUT when timeout */
77933d72 702static inline int
1da177e4
LT		 703plip_send(unsigned short nibble_timeout, struct net_device *dev,
704 enum plip_nibble_state *ns_p, unsigned char data)
705{
706 unsigned char c0;
707 unsigned int cx;
708
709 switch (*ns_p) {
710 case PLIP_NB_BEGIN:
711 write_data (dev, data & 0x0f);
712 *ns_p = PLIP_NB_1;
713
714 case PLIP_NB_1:
715 write_data (dev, 0x10 | (data & 0x0f));
716 cx = nibble_timeout;
717 while (1) {
718 c0 = read_status(dev);
719 if ((c0 & 0x80) == 0)
720 break;
721 if (--cx == 0)
722 return TIMEOUT;
723 udelay(PLIP_DELAY_UNIT);
724 }
725 write_data (dev, 0x10 | (data >> 4));
726 *ns_p = PLIP_NB_2;
727
728 case PLIP_NB_2:
729 write_data (dev, (data >> 4));
730 cx = nibble_timeout;
731 while (1) {
732 c0 = read_status(dev);
733 if (c0 & 0x80)
734 break;
735 if (--cx == 0)
736 return TIMEOUT;
737 udelay(PLIP_DELAY_UNIT);
738 }
739 *ns_p = PLIP_NB_BEGIN;
740 return OK;
741 }
742 return OK;
743}
744
745/* PLIP_SEND_PACKET --- send a packet */
746static int
747plip_send_packet(struct net_device *dev, struct net_local *nl,
748 struct plip_local *snd, struct plip_local *rcv)
749{
750 unsigned short nibble_timeout = nl->nibble;
751 unsigned char *lbuf;
752 unsigned char c0;
753 unsigned int cx;
754
755 if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
756 printk(KERN_DEBUG "%s: send skb lost\n", dev->name);
757 snd->state = PLIP_PK_DONE;
758 snd->skb = NULL;
759 return ERROR;
760 }
761
762 switch (snd->state) {
763 case PLIP_PK_TRIGGER:
764 if ((read_status(dev) & 0xf8) != 0x80)
765 return HS_TIMEOUT;
766
767 /* Trigger remote rx interrupt. */
768 write_data (dev, 0x08);
769 cx = nl->trigger;
770 while (1) {
771 udelay(PLIP_DELAY_UNIT);
772 spin_lock_irq(&nl->lock);
773 if (nl->connection == PLIP_CN_RECEIVE) {
774 spin_unlock_irq(&nl->lock);
775 /* Interrupted. */
09f75cd7 776 dev->stats.collisions++;
1da177e4
LT		 777 return OK;
778 }
779 c0 = read_status(dev);
780 if (c0 & 0x08) {
781 spin_unlock_irq(&nl->lock);
782 DISABLE(dev->irq);
783 synchronize_irq(dev->irq);
784 if (nl->connection == PLIP_CN_RECEIVE) {
785 /* Interrupted.
786 We don't need to enable irq,
787 as it is soon disabled. */
788 /* Yes, we do. New variant of
789 {enable,disable}_irq *counts*
790 them. -- AV */
791 ENABLE(dev->irq);
09f75cd7 792 dev->stats.collisions++;
1da177e4
LT		 793 return OK;
794 }
795 disable_parport_interrupts (dev);
796 if (net_debug > 2)
797 printk(KERN_DEBUG "%s: send start\n", dev->name);
798 snd->state = PLIP_PK_LENGTH_LSB;
799 snd->nibble = PLIP_NB_BEGIN;
800 nl->timeout_count = 0;
801 break;
802 }
803 spin_unlock_irq(&nl->lock);
804 if (--cx == 0) {
805 write_data (dev, 0x00);
806 return HS_TIMEOUT;
807 }
808 }
809
810 case PLIP_PK_LENGTH_LSB:
811 if (plip_send(nibble_timeout, dev,
812 &snd->nibble, snd->length.b.lsb))
813 return TIMEOUT;
814 snd->state = PLIP_PK_LENGTH_MSB;
815
816 case PLIP_PK_LENGTH_MSB:
817 if (plip_send(nibble_timeout, dev,
818 &snd->nibble, snd->length.b.msb))
819 return TIMEOUT;
820 snd->state = PLIP_PK_DATA;
821 snd->byte = 0;
822 snd->checksum = 0;
823
824 case PLIP_PK_DATA:
e4c3c13c 825 do {
1da177e4
LT		 826 if (plip_send(nibble_timeout, dev,
827 &snd->nibble, lbuf[snd->byte]))
828 return TIMEOUT;
e4c3c13c
HE		 829 } while (++snd->byte < snd->length.h);
830 do {
1da177e4 831 snd->checksum += lbuf[--snd->byte];
e4c3c13c 832 } while (snd->byte);
1da177e4
LT		 833 snd->state = PLIP_PK_CHECKSUM;
834
835 case PLIP_PK_CHECKSUM:
836 if (plip_send(nibble_timeout, dev,
837 &snd->nibble, snd->checksum))
838 return TIMEOUT;
839
09f75cd7 840 dev->stats.tx_bytes += snd->skb->len;
1da177e4 841 dev_kfree_skb(snd->skb);
09f75cd7 842 dev->stats.tx_packets++;
1da177e4
LT		 843 snd->state = PLIP_PK_DONE;
844
845 case PLIP_PK_DONE:
846 /* Close the connection */
847 write_data (dev, 0x00);
848 snd->skb = NULL;
849 if (net_debug > 2)
850 printk(KERN_DEBUG "%s: send end\n", dev->name);
851 nl->connection = PLIP_CN_CLOSING;
852 nl->is_deferred = 1;
853 schedule_delayed_work(&nl->deferred, 1);
854 enable_parport_interrupts (dev);
855 ENABLE(dev->irq);
856 return OK;
857 }
858 return OK;
859}
860
861static int
862plip_connection_close(struct net_device *dev, struct net_local *nl,
863 struct plip_local *snd, struct plip_local *rcv)
864{
865 spin_lock_irq(&nl->lock);
866 if (nl->connection == PLIP_CN_CLOSING) {
867 nl->connection = PLIP_CN_NONE;
868 netif_wake_queue (dev);
869 }
870 spin_unlock_irq(&nl->lock);
871 if (nl->should_relinquish) {
872 nl->should_relinquish = nl->port_owner = 0;
873 parport_release(nl->pardev);
874 }
875 return OK;
876}
877
878/* PLIP_ERROR --- wait till other end settled */
879static int
880plip_error(struct net_device *dev, struct net_local *nl,
881 struct plip_local *snd, struct plip_local *rcv)
882{
883 unsigned char status;
884
885 status = read_status(dev);
886 if ((status & 0xf8) == 0x80) {
887 if (net_debug > 2)
888 printk(KERN_DEBUG "%s: reset interface.\n", dev->name);
889 nl->connection = PLIP_CN_NONE;
890 nl->should_relinquish = 0;
891 netif_start_queue (dev);
892 enable_parport_interrupts (dev);
893 ENABLE(dev->irq);
894 netif_wake_queue (dev);
895 } else {
896 nl->is_deferred = 1;
897 schedule_delayed_work(&nl->deferred, 1);
898 }
899
900 return OK;
901}
77933d72 902
1da177e4
LT		 903/* Handle the parallel port interrupts. */
904static void
5712cb3d 905plip_interrupt(void *dev_id)
1da177e4
LT		 906{
907 struct net_device *dev = dev_id;
908 struct net_local *nl;
909 struct plip_local *rcv;
910 unsigned char c0;
cabce28e 911 unsigned long flags;
1da177e4 912
1da177e4
LT		 913 nl = netdev_priv(dev);
914 rcv = &nl->rcv_data;
915
cabce28e 916 spin_lock_irqsave (&nl->lock, flags);
1da177e4
LT		 917
918 c0 = read_status(dev);
919 if ((c0 & 0xf8) != 0xc0) {
920 if ((dev->irq != -1) && (net_debug > 1))
921 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
cabce28e 922 spin_unlock_irqrestore (&nl->lock, flags);
1da177e4
LT		 923 return;
924 }
925
926 if (net_debug > 3)
927 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
928
929 switch (nl->connection) {
930 case PLIP_CN_CLOSING:
931 netif_wake_queue (dev);
932 case PLIP_CN_NONE:
933 case PLIP_CN_SEND:
934 rcv->state = PLIP_PK_TRIGGER;
935 nl->connection = PLIP_CN_RECEIVE;
936 nl->timeout_count = 0;
937 schedule_work(&nl->immediate);
938 break;
939
940 case PLIP_CN_RECEIVE:
941 /* May occur because there is race condition
942 around test and set of dev->interrupt.
943 Ignore this interrupt. */
944 break;
945
946 case PLIP_CN_ERROR:
947 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
948 break;
949 }
950
cabce28e 951 spin_unlock_irqrestore(&nl->lock, flags);
1da177e4 952}
77933d72 953
1da177e4
LT		 954static int
955plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
956{
957 struct net_local *nl = netdev_priv(dev);
958 struct plip_local *snd = &nl->snd_data;
959
960 if (netif_queue_stopped(dev))
5b548140 961 return NETDEV_TX_BUSY;
1da177e4
LT		 962
963 /* We may need to grab the bus */
964 if (!nl->port_owner) {
965 if (parport_claim(nl->pardev))
5b548140 966 return NETDEV_TX_BUSY;
1da177e4
LT		 967 nl->port_owner = 1;
968 }
969
970 netif_stop_queue (dev);
6aa20a22 971
1da177e4
LT		 972 if (skb->len > dev->mtu + dev->hard_header_len) {
973 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
974 netif_start_queue (dev);
5b548140 975 return NETDEV_TX_BUSY;
1da177e4
LT		 976 }
977
978 if (net_debug > 2)
979 printk(KERN_DEBUG "%s: send request\n", dev->name);
980
981 spin_lock_irq(&nl->lock);
982 dev->trans_start = jiffies;
983 snd->skb = skb;
984 snd->length.h = skb->len;
985 snd->state = PLIP_PK_TRIGGER;
986 if (nl->connection == PLIP_CN_NONE) {
987 nl->connection = PLIP_CN_SEND;
988 nl->timeout_count = 0;
989 }
990 schedule_work(&nl->immediate);
991 spin_unlock_irq(&nl->lock);
6aa20a22 992
6ed10654 993 return NETDEV_TX_OK;
1da177e4
LT		 994}
995
996static void
3b04ddde 997plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth)
1da177e4 998{
3b04ddde 999 const struct in_device *in_dev = dev->ip_ptr;
1da177e4 1000
3b04ddde 1001 if (in_dev) {
1da177e4 1002 /* Any address will do - we take the first */
3b04ddde
SH		 1003 const struct in_ifaddr *ifa = in_dev->ifa_list;
1004 if (ifa) {
1da177e4
LT		 1005 memcpy(eth->h_source, dev->dev_addr, 6);
1006 memset(eth->h_dest, 0xfc, 2);
1007 memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1008 }
1009 }
1010}
1011
1012static int
1013plip_hard_header(struct sk_buff *skb, struct net_device *dev,
3b04ddde
SH		 1014 unsigned short type, const void *daddr,
1015 const void *saddr, unsigned len)
1da177e4 1016{
1da177e4
LT		 1017 int ret;
1018
3b04ddde
SH		 1019 ret = eth_header(skb, dev, type, daddr, saddr, len);
1020 if (ret >= 0)
1da177e4
LT		 1021 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1022
1023 return ret;
1024}
1025
dac499f9
HE		 1026static int plip_hard_header_cache(const struct neighbour *neigh,
1027 struct hh_cache *hh)
1da177e4 1028{
1da177e4 1029 int ret;
6aa20a22 1030
3b04ddde
SH		 1031 ret = eth_header_cache(neigh, hh);
1032 if (ret == 0) {
1da177e4
LT		 1033 struct ethhdr *eth;
1034
1035 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1036 HH_DATA_OFF(sizeof(*eth)));
1037 plip_rewrite_address (neigh->dev, eth);
1038 }
6aa20a22 1039
1da177e4 1040 return ret;
6aa20a22 1041}
1da177e4
LT		 1042
1043/* Open/initialize the board. This is called (in the current kernel)
1044 sometime after booting when the 'ifconfig' program is run.
1045
1046 This routine gets exclusive access to the parallel port by allocating
1047 its IRQ line.
1048 */
1049static int
1050plip_open(struct net_device *dev)
1051{
1052 struct net_local *nl = netdev_priv(dev);
1053 struct in_device *in_dev;
1054
1055 /* Grab the port */
1056 if (!nl->port_owner) {
1057 if (parport_claim(nl->pardev)) return -EAGAIN;
1058 nl->port_owner = 1;
1059 }
1060
1061 nl->should_relinquish = 0;
1062
1063 /* Clear the data port. */
1064 write_data (dev, 0x00);
1065
1066 /* Enable rx interrupt. */
1067 enable_parport_interrupts (dev);
1068 if (dev->irq == -1)
1069 {
1070 atomic_set (&nl->kill_timer, 0);
1071 schedule_delayed_work(&nl->timer, 1);
1072 }
1073
1074 /* Initialize the state machine. */
1075 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1076 nl->rcv_data.skb = nl->snd_data.skb = NULL;
1077 nl->connection = PLIP_CN_NONE;
1078 nl->is_deferred = 0;
1079
1080 /* Fill in the MAC-level header.
1081 We used to abuse dev->broadcast to store the point-to-point
1082 MAC address, but we no longer do it. Instead, we fetch the
1083 interface address whenever it is needed, which is cheap enough
1084 because we use the hh_cache. Actually, abusing dev->broadcast
1085 didn't work, because when using plip_open the point-to-point
1086 address isn't yet known.
1087 PLIP doesn't have a real MAC address, but we need it to be
1088 DOS compatible, and to properly support taps (otherwise,
1089 when the device address isn't identical to the address of a
1090 received frame, the kernel incorrectly drops it). */
1091
1092 if ((in_dev=dev->ip_ptr) != NULL) {
1093 /* Any address will do - we take the first. We already
1094 have the first two bytes filled with 0xfc, from
1095 plip_init_dev(). */
1096 struct in_ifaddr *ifa=in_dev->ifa_list;
1097 if (ifa != NULL) {
1098 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1099 }
1100 }
1101
1102 netif_start_queue (dev);
1103
1104 return 0;
1105}
1106
1107/* The inverse routine to plip_open (). */
1108static int
1109plip_close(struct net_device *dev)
1110{
1111 struct net_local *nl = netdev_priv(dev);
1112 struct plip_local *snd = &nl->snd_data;
1113 struct plip_local *rcv = &nl->rcv_data;
1114
1115 netif_stop_queue (dev);
1116 DISABLE(dev->irq);
1117 synchronize_irq(dev->irq);
1118
1119 if (dev->irq == -1)
1120 {
01f31ac8 1121 init_completion(&nl->killed_timer_cmp);
1da177e4 1122 atomic_set (&nl->kill_timer, 1);
01f31ac8 1123 wait_for_completion(&nl->killed_timer_cmp);
1da177e4
LT		 1124 }
1125
1126#ifdef NOTDEF
1127 outb(0x00, PAR_DATA(dev));
1128#endif
1129 nl->is_deferred = 0;
1130 nl->connection = PLIP_CN_NONE;
1131 if (nl->port_owner) {
1132 parport_release(nl->pardev);
1133 nl->port_owner = 0;
1134 }
1135
1136 snd->state = PLIP_PK_DONE;
1137 if (snd->skb) {
1138 dev_kfree_skb(snd->skb);
1139 snd->skb = NULL;
1140 }
1141 rcv->state = PLIP_PK_DONE;
1142 if (rcv->skb) {
1143 kfree_skb(rcv->skb);
1144 rcv->skb = NULL;
1145 }
1146
1147#ifdef NOTDEF
1148 /* Reset. */
1149 outb(0x00, PAR_CONTROL(dev));
1150#endif
1151 return 0;
1152}
1153
1154static int
1155plip_preempt(void *handle)
1156{
1157 struct net_device *dev = (struct net_device *)handle;
1158 struct net_local *nl = netdev_priv(dev);
1159
1160 /* Stand our ground if a datagram is on the wire */
1161 if (nl->connection != PLIP_CN_NONE) {
1162 nl->should_relinquish = 1;
1163 return 1;
1164 }
1165
1166 nl->port_owner = 0; /* Remember that we released the bus */
1167 return 0;
1168}
1169
1170static void
1171plip_wakeup(void *handle)
1172{
1173 struct net_device *dev = (struct net_device *)handle;
1174 struct net_local *nl = netdev_priv(dev);
1175
1176 if (nl->port_owner) {
1177 /* Why are we being woken up? */
1178 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1179 if (!parport_claim(nl->pardev))
1180 /* bus_owner is already set (but why?) */
1181 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1182 else
1183 return;
1184 }
6aa20a22 1185
1da177e4
LT		 1186 if (!(dev->flags & IFF_UP))
1187 /* Don't need the port when the interface is down */
1188 return;
1189
1190 if (!parport_claim(nl->pardev)) {
1191 nl->port_owner = 1;
1192 /* Clear the data port. */
1193 write_data (dev, 0x00);
1194 }
1195
1196 return;
1197}
1198
1da177e4
LT		 1199static int
1200plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1201{
1202 struct net_local *nl = netdev_priv(dev);
1203 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1204
1205 if (cmd != SIOCDEVPLIP)
1206 return -EOPNOTSUPP;
1207
1208 switch(pc->pcmd) {
1209 case PLIP_GET_TIMEOUT:
1210 pc->trigger = nl->trigger;
1211 pc->nibble = nl->nibble;
1212 break;
1213 case PLIP_SET_TIMEOUT:
1214 if(!capable(CAP_NET_ADMIN))
1215 return -EPERM;
1216 nl->trigger = pc->trigger;
1217 nl->nibble = pc->nibble;
1218 break;
1219 default:
1220 return -EOPNOTSUPP;
1221 }
1222 return 0;
1223}
77933d72 1224
1da177e4
LT		 1225static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1226static int timid;
1227
1228module_param_array(parport, int, NULL, 0);
1229module_param(timid, int, 0);
1230MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1231
1232static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1233
1234static inline int
1235plip_searchfor(int list[], int a)
1236{
1237 int i;
1238 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1239 if (list[i] == a) return 1;
1240 }
1241 return 0;
1242}
1243
1244/* plip_attach() is called (by the parport code) when a port is
1245 * available to use. */
1246static void plip_attach (struct parport *port)
1247{
1248 static int unit;
1249 struct net_device *dev;
1250 struct net_local *nl;
1251 char name[IFNAMSIZ];
1252
6aa20a22 1253 if ((parport[0] == -1 && (!timid || !port->devices)) ||
1da177e4
LT		 1254 plip_searchfor(parport, port->number)) {
1255 if (unit == PLIP_MAX) {
1256 printk(KERN_ERR "plip: too many devices\n");
1257 return;
1258 }
1259
1260 sprintf(name, "plip%d", unit);
1261 dev = alloc_etherdev(sizeof(struct net_local));
1262 if (!dev) {
1263 printk(KERN_ERR "plip: memory squeeze\n");
1264 return;
1265 }
6aa20a22 1266
1da177e4
LT		 1267 strcpy(dev->name, name);
1268
1da177e4
LT		 1269 dev->irq = port->irq;
1270 dev->base_addr = port->base;
1271 if (port->irq == -1) {
1272 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1273 "which is fairly inefficient!\n", port->name);
1274 }
1275
1276 nl = netdev_priv(dev);
c4028958 1277 nl->dev = dev;
cdb32706 1278 nl->pardev = parport_register_device(port, dev->name, plip_preempt,
6aa20a22 1279 plip_wakeup, plip_interrupt,
1da177e4
LT		 1280 0, dev);
1281
1282 if (!nl->pardev) {
1283 printk(KERN_ERR "%s: parport_register failed\n", name);
1284 goto err_free_dev;
1285 return;
1286 }
1287
1288 plip_init_netdev(dev);
1289
1290 if (register_netdev(dev)) {
1291 printk(KERN_ERR "%s: network register failed\n", name);
1292 goto err_parport_unregister;
1293 }
1294
1295 printk(KERN_INFO "%s", version);
1296 if (dev->irq != -1)
1297 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1298 "using IRQ %d.\n",
1299 dev->name, dev->base_addr, dev->irq);
1300 else
1301 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1302 "not using IRQ.\n",
1303 dev->name, dev->base_addr);
1304 dev_plip[unit++] = dev;
1305 }
1306 return;
1307
1308err_parport_unregister:
1309 parport_unregister_device(nl->pardev);
1310err_free_dev:
1311 free_netdev(dev);
1312 return;
1313}
1314
1315/* plip_detach() is called (by the parport code) when a port is
1316 * no longer available to use. */
1317static void plip_detach (struct parport *port)
1318{
1319 /* Nothing to do */
1320}
1321
1322static struct parport_driver plip_driver = {
1323 .name = "plip",
1324 .attach = plip_attach,
1325 .detach = plip_detach
1326};
1327
1328static void __exit plip_cleanup_module (void)
1329{
1330 struct net_device *dev;
1331 int i;
1332
1333 parport_unregister_driver (&plip_driver);
1334
1335 for (i=0; i < PLIP_MAX; i++) {
1336 if ((dev = dev_plip[i])) {
1337 struct net_local *nl = netdev_priv(dev);
1338 unregister_netdev(dev);
1339 if (nl->port_owner)
1340 parport_release(nl->pardev);
1341 parport_unregister_device(nl->pardev);
1342 free_netdev(dev);
1343 dev_plip[i] = NULL;
1344 }
1345 }
1346}
1347
1348#ifndef MODULE
1349
1350static int parport_ptr;
1351
1352static int __init plip_setup(char *str)
1353{
1354 int ints[4];
1355
1356 str = get_options(str, ARRAY_SIZE(ints), ints);
1357
1358 /* Ugh. */
1359 if (!strncmp(str, "parport", 7)) {
1360 int n = simple_strtoul(str+7, NULL, 10);
1361 if (parport_ptr < PLIP_MAX)
1362 parport[parport_ptr++] = n;
1363 else
1364 printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1365 str);
1366 } else if (!strcmp(str, "timid")) {
1367 timid = 1;
1368 } else {
1369 if (ints[0] == 0 || ints[1] == 0) {
1370 /* disable driver on "plip=" or "plip=0" */
1371 parport[0] = -2;
1372 } else {
6aa20a22 1373 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1da177e4
LT		 1374 ints[1]);
1375 }
1376 }
1377 return 1;
1378}
1379
1380__setup("plip=", plip_setup);
1381
1382#endif /* !MODULE */
1383
1384static int __init plip_init (void)
1385{
1386 if (parport[0] == -2)
1387 return 0;
1388
1389 if (parport[0] != -1 && timid) {
1390 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1391 timid = 0;
1392 }
1393
1394 if (parport_register_driver (&plip_driver)) {
1395 printk (KERN_WARNING "plip: couldn't register driver\n");
1396 return 1;
1397 }
1398
1399 return 0;
1400}
1401
1402module_init(plip_init);
1403module_exit(plip_cleanup_module);
1404MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)