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