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