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