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