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). */
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>
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
25 * - Module initialization.
27 * - Make sure other end is OK, before sending a packet.
28 * - Fix immediate timer problem.
31 * - Changed {enable,disable}_irq handling to make it work
32 * with new ("stack") semantics.
36 * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com>
37 * inspired by Russ Nelson's parallel port packet driver.
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.
45 * This version follows original PLIP protocol.
46 * So, this PLIP can't communicate the PLIP of Linux v1.0.
50 * To use with DOS box, please do (Turn on ARP switch):
51 * # ifconfig plip[0-2] arp
53 static const char version
[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n";
57 Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
58 "parallel.asm" parallel port packet driver.
60 The "Crynwr" parallel port standard specifies the following protocol:
61 Trigger by sending nibble '0x8' (this causes interrupt on other end)
66 Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
67 <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
69 The packet is encapsulated as if it were ethernet.
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:
76 D0->ERROR 2 - 15 15 - 2
77 D1->SLCT 3 - 13 13 - 3
78 D2->PAPOUT 4 - 12 12 - 4
80 D4->BUSY 6 - 11 11 - 6
81 Do not connect the other pins. They are
83 STROBE is 1, FEED is 14, INIT is 16
84 extra grounds are 18,19,20,21,22,23,24
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>
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>
110 #include <net/neighbour.h>
113 #include <asm/byteorder.h>
115 /* Maximum number of devices to support. */
118 /* Use 0 for production, 1 for verification, >2 for debug */
122 static const unsigned int net_debug
= NET_DEBUG
;
124 #define ENABLE(irq) if (irq != -1) enable_irq(irq)
125 #define DISABLE(irq) if (irq != -1) disable_irq(irq)
127 /* In micro second */
128 #define PLIP_DELAY_UNIT 1
130 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
131 #define PLIP_TRIGGER_WAIT 500
133 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
134 #define PLIP_NIBBLE_WAIT 3000
137 static void plip_kick_bh(struct work_struct
*work
);
138 static void plip_bh(struct work_struct
*work
);
139 static void plip_timer_bh(struct work_struct
*work
);
141 /* Interrupt handler */
142 static void plip_interrupt(void *dev_id
);
144 /* Functions for DEV methods */
145 static netdev_tx_t
plip_tx_packet(struct sk_buff
*skb
, struct net_device
*dev
);
146 static 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
);
149 static int plip_hard_header_cache(const struct neighbour
*neigh
,
150 struct hh_cache
*hh
, __be16 type
);
151 static int plip_open(struct net_device
*dev
);
152 static int plip_close(struct net_device
*dev
);
153 static int plip_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
);
154 static int plip_preempt(void *handle
);
155 static void plip_wakeup(void *handle
);
157 enum plip_connection_state
{
165 enum plip_packet_state
{
174 enum plip_nibble_state
{
181 enum plip_packet_state state
;
182 enum plip_nibble_state nibble
;
185 #if defined(__LITTLE_ENDIAN)
188 #elif defined(__BIG_ENDIAN)
192 #error "Please fix the endianness defines in <asm/byteorder.h>"
198 unsigned char checksum
;
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
;
217 int should_relinquish
;
220 struct completion killed_timer_cmp
;
223 static inline void enable_parport_interrupts (struct net_device
*dev
)
227 struct parport
*port
=
228 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
229 port
->ops
->enable_irq (port
);
233 static inline void disable_parport_interrupts (struct net_device
*dev
)
237 struct parport
*port
=
238 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
239 port
->ops
->disable_irq (port
);
243 static inline void write_data (struct net_device
*dev
, unsigned char data
)
245 struct parport
*port
=
246 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
248 port
->ops
->write_data (port
, data
);
251 static inline unsigned char read_status (struct net_device
*dev
)
253 struct parport
*port
=
254 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
256 return port
->ops
->read_status (port
);
259 static const struct header_ops plip_header_ops
= {
260 .create
= plip_hard_header
,
261 .cache
= plip_hard_header_cache
,
264 static 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
,
273 /* Entry point of PLIP driver.
274 Probe the hardware, and register/initialize the driver.
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
283 plip_init_netdev(struct net_device
*dev
)
285 struct net_local
*nl
= netdev_priv(dev
);
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
);
292 dev
->netdev_ops
= &plip_netdev_ops
;
293 dev
->header_ops
= &plip_header_ops
;
298 /* Initialize constants */
299 nl
->trigger
= PLIP_TRIGGER_WAIT
;
300 nl
->nibble
= PLIP_NIBBLE_WAIT
;
302 /* Initialize task queue structures */
303 INIT_WORK(&nl
->immediate
, plip_bh
);
304 INIT_DELAYED_WORK(&nl
->deferred
, plip_kick_bh
);
307 INIT_DELAYED_WORK(&nl
->timer
, plip_timer_bh
);
309 spin_lock_init(&nl
->lock
);
312 /* Bottom half handler for the delayed request.
313 This routine is kicked by do_timer().
314 Request `plip_bh' to be invoked. */
316 plip_kick_bh(struct work_struct
*work
)
318 struct net_local
*nl
=
319 container_of(work
, struct net_local
, deferred
.work
);
322 schedule_work(&nl
->immediate
);
325 /* Forward declarations of internal routines */
326 static int plip_none(struct net_device
*, struct net_local
*,
327 struct plip_local
*, struct plip_local
*);
328 static int plip_receive_packet(struct net_device
*, struct net_local
*,
329 struct plip_local
*, struct plip_local
*);
330 static int plip_send_packet(struct net_device
*, struct net_local
*,
331 struct plip_local
*, struct plip_local
*);
332 static int plip_connection_close(struct net_device
*, struct net_local
*,
333 struct plip_local
*, struct plip_local
*);
334 static int plip_error(struct net_device
*, struct net_local
*,
335 struct plip_local
*, struct plip_local
*);
336 static int plip_bh_timeout_error(struct net_device
*dev
, struct net_local
*nl
,
337 struct plip_local
*snd
,
338 struct plip_local
*rcv
,
346 typedef int (*plip_func
)(struct net_device
*dev
, struct net_local
*nl
,
347 struct plip_local
*snd
, struct plip_local
*rcv
);
349 static const plip_func connection_state_table
[] =
354 plip_connection_close
,
358 /* Bottom half handler of PLIP. */
360 plip_bh(struct work_struct
*work
)
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
;
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
) {
373 schedule_delayed_work(&nl
->deferred
, 1);
378 plip_timer_bh(struct work_struct
*work
)
380 struct net_local
*nl
=
381 container_of(work
, struct net_local
, timer
.work
);
383 if (!(atomic_read (&nl
->kill_timer
))) {
384 plip_interrupt (nl
->dev
);
386 schedule_delayed_work(&nl
->timer
, 1);
389 complete(&nl
->killed_timer_cmp
);
394 plip_bh_timeout_error(struct net_device
*dev
, struct net_local
*nl
,
395 struct plip_local
*snd
, struct plip_local
*rcv
,
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
409 spin_lock_irq(&nl
->lock
);
410 if (nl
->connection
== PLIP_CN_SEND
) {
412 if (error
!= ERROR
) { /* Timeout */
414 if ((error
== HS_TIMEOUT
&& nl
->timeout_count
<= 10) ||
415 nl
->timeout_count
<= 3) {
416 spin_unlock_irq(&nl
->lock
);
417 /* Try again later */
420 c0
= read_status(dev
);
421 printk(KERN_WARNING
"%s: transmit timeout(%d,%02x)\n",
422 dev
->name
, snd
->state
, c0
);
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
);
433 if (error
!= ERROR
) { /* Timeout */
434 if (++nl
->timeout_count
<= 3) {
435 spin_unlock_irq(&nl
->lock
);
436 /* Try again later */
439 c0
= read_status(dev
);
440 printk(KERN_WARNING
"%s: receive timeout(%d,%02x)\n",
441 dev
->name
, rcv
->state
, c0
);
443 dev
->stats
.rx_dropped
++;
445 rcv
->state
= PLIP_PK_DONE
;
450 snd
->state
= PLIP_PK_DONE
;
452 dev_kfree_skb(snd
->skb
);
455 spin_unlock_irq(&nl
->lock
);
456 if (error
== HS_TIMEOUT
) {
458 synchronize_irq(dev
->irq
);
460 disable_parport_interrupts (dev
);
461 netif_stop_queue (dev
);
462 nl
->connection
= PLIP_CN_ERROR
;
463 write_data (dev
, 0x00);
469 plip_none(struct net_device
*dev
, struct net_local
*nl
,
470 struct plip_local
*snd
, struct plip_local
*rcv
)
475 /* PLIP_RECEIVE --- receive a byte(two nibbles)
476 Returns OK on success, TIMEOUT on timeout */
478 plip_receive(unsigned short nibble_timeout
, struct net_device
*dev
,
479 enum plip_nibble_state
*ns_p
, unsigned char *data_p
)
481 unsigned char c0
, c1
;
488 c0
= read_status(dev
);
489 udelay(PLIP_DELAY_UNIT
);
490 if ((c0
& 0x80) == 0) {
491 c1
= read_status(dev
);
498 *data_p
= (c0
>> 3) & 0x0f;
499 write_data (dev
, 0x10); /* send ACK */
506 c0
= read_status(dev
);
507 udelay(PLIP_DELAY_UNIT
);
509 c1
= read_status(dev
);
516 *data_p
|= (c0
<< 1) & 0xf0;
517 write_data (dev
, 0x00); /* send ACK */
518 *ns_p
= PLIP_NB_BEGIN
;
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.
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).
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.
537 static __be16
plip_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
542 skb_reset_mac_header(skb
);
543 skb_pull(skb
,dev
->hard_header_len
);
546 if(is_multicast_ether_addr(eth
->h_dest
))
548 if(ether_addr_equal_64bits(eth
->h_dest
, dev
->broadcast
))
549 skb
->pkt_type
=PACKET_BROADCAST
;
551 skb
->pkt_type
=PACKET_MULTICAST
;
555 * This ALLMULTI check should be redundant by 1.4
556 * so don't forget to remove it.
559 if (ntohs(eth
->h_proto
) >= ETH_P_802_3_MIN
)
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.
570 if (*(unsigned short *)rawp
== 0xFFFF)
571 return htons(ETH_P_802_3
);
576 return htons(ETH_P_802_2
);
579 /* PLIP_RECEIVE_PACKET --- receive a packet */
581 plip_receive_packet(struct net_device
*dev
, struct net_local
*nl
,
582 struct plip_local
*snd
, struct plip_local
*rcv
)
584 unsigned short nibble_timeout
= nl
->nibble
;
587 switch (rcv
->state
) {
588 case PLIP_PK_TRIGGER
:
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 */
594 printk(KERN_DEBUG
"%s: receive start\n", dev
->name
);
595 rcv
->state
= PLIP_PK_LENGTH_LSB
;
596 rcv
->nibble
= PLIP_NB_BEGIN
;
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
;
606 nl
->connection
= PLIP_CN_SEND
;
607 schedule_delayed_work(&nl
->deferred
, 1);
608 enable_parport_interrupts (dev
);
613 if (plip_receive(nibble_timeout
, dev
,
614 &rcv
->nibble
, &rcv
->length
.b
.lsb
))
617 rcv
->state
= PLIP_PK_LENGTH_MSB
;
620 case PLIP_PK_LENGTH_MSB
:
621 if (plip_receive(nibble_timeout
, dev
,
622 &rcv
->nibble
, &rcv
->length
.b
.msb
))
624 if (rcv
->length
.h
> dev
->mtu
+ dev
->hard_header_len
||
626 printk(KERN_WARNING
"%s: bogus packet size %d.\n", dev
->name
, rcv
->length
.h
);
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
);
635 skb_reserve(rcv
->skb
, 2); /* Align IP on 16 byte boundaries */
636 skb_put(rcv
->skb
,rcv
->length
.h
);
638 rcv
->state
= PLIP_PK_DATA
;
644 lbuf
= rcv
->skb
->data
;
646 if (plip_receive(nibble_timeout
, dev
,
647 &rcv
->nibble
, &lbuf
[rcv
->byte
]))
649 } while (++rcv
->byte
< rcv
->length
.h
);
651 rcv
->checksum
+= lbuf
[--rcv
->byte
];
653 rcv
->state
= PLIP_PK_CHECKSUM
;
656 case PLIP_PK_CHECKSUM
:
657 if (plip_receive(nibble_timeout
, dev
,
658 &rcv
->nibble
, &rcv
->data
))
660 if (rcv
->data
!= rcv
->checksum
) {
661 dev
->stats
.rx_crc_errors
++;
663 printk(KERN_DEBUG
"%s: checksum error\n", dev
->name
);
666 rcv
->state
= 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
++;
677 printk(KERN_DEBUG
"%s: receive end\n", dev
->name
);
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
);
690 nl
->connection
= PLIP_CN_NONE
;
691 spin_unlock_irq(&nl
->lock
);
692 enable_parport_interrupts (dev
);
700 /* PLIP_SEND --- send a byte (two nibbles)
701 Returns OK on success, TIMEOUT when timeout */
703 plip_send(unsigned short nibble_timeout
, struct net_device
*dev
,
704 enum plip_nibble_state
*ns_p
, unsigned char data
)
711 write_data (dev
, data
& 0x0f);
716 write_data (dev
, 0x10 | (data
& 0x0f));
719 c0
= read_status(dev
);
720 if ((c0
& 0x80) == 0)
724 udelay(PLIP_DELAY_UNIT
);
726 write_data (dev
, 0x10 | (data
>> 4));
731 write_data (dev
, (data
>> 4));
734 c0
= read_status(dev
);
739 udelay(PLIP_DELAY_UNIT
);
741 *ns_p
= PLIP_NB_BEGIN
;
747 /* PLIP_SEND_PACKET --- send a packet */
749 plip_send_packet(struct net_device
*dev
, struct net_local
*nl
,
750 struct plip_local
*snd
, struct plip_local
*rcv
)
752 unsigned short nibble_timeout
= nl
->nibble
;
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
;
764 switch (snd
->state
) {
765 case PLIP_PK_TRIGGER
:
766 if ((read_status(dev
) & 0xf8) != 0x80)
769 /* Trigger remote rx interrupt. */
770 write_data (dev
, 0x08);
773 udelay(PLIP_DELAY_UNIT
);
774 spin_lock_irq(&nl
->lock
);
775 if (nl
->connection
== PLIP_CN_RECEIVE
) {
776 spin_unlock_irq(&nl
->lock
);
778 dev
->stats
.collisions
++;
781 c0
= read_status(dev
);
783 spin_unlock_irq(&nl
->lock
);
785 synchronize_irq(dev
->irq
);
786 if (nl
->connection
== PLIP_CN_RECEIVE
) {
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*
794 dev
->stats
.collisions
++;
797 disable_parport_interrupts (dev
);
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;
805 spin_unlock_irq(&nl
->lock
);
807 write_data (dev
, 0x00);
812 case PLIP_PK_LENGTH_LSB
:
813 if (plip_send(nibble_timeout
, dev
,
814 &snd
->nibble
, snd
->length
.b
.lsb
))
816 snd
->state
= PLIP_PK_LENGTH_MSB
;
819 case PLIP_PK_LENGTH_MSB
:
820 if (plip_send(nibble_timeout
, dev
,
821 &snd
->nibble
, snd
->length
.b
.msb
))
823 snd
->state
= PLIP_PK_DATA
;
830 if (plip_send(nibble_timeout
, dev
,
831 &snd
->nibble
, lbuf
[snd
->byte
]))
833 } while (++snd
->byte
< snd
->length
.h
);
835 snd
->checksum
+= lbuf
[--snd
->byte
];
837 snd
->state
= PLIP_PK_CHECKSUM
;
840 case PLIP_PK_CHECKSUM
:
841 if (plip_send(nibble_timeout
, dev
,
842 &snd
->nibble
, snd
->checksum
))
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
;
852 /* Close the connection */
853 write_data (dev
, 0x00);
856 printk(KERN_DEBUG
"%s: send end\n", dev
->name
);
857 nl
->connection
= PLIP_CN_CLOSING
;
859 schedule_delayed_work(&nl
->deferred
, 1);
860 enable_parport_interrupts (dev
);
868 plip_connection_close(struct net_device
*dev
, struct net_local
*nl
,
869 struct plip_local
*snd
, struct plip_local
*rcv
)
871 spin_lock_irq(&nl
->lock
);
872 if (nl
->connection
== PLIP_CN_CLOSING
) {
873 nl
->connection
= PLIP_CN_NONE
;
874 netif_wake_queue (dev
);
876 spin_unlock_irq(&nl
->lock
);
877 if (nl
->should_relinquish
) {
878 nl
->should_relinquish
= nl
->port_owner
= 0;
879 parport_release(nl
->pardev
);
884 /* PLIP_ERROR --- wait till other end settled */
886 plip_error(struct net_device
*dev
, struct net_local
*nl
,
887 struct plip_local
*snd
, struct plip_local
*rcv
)
889 unsigned char status
;
891 status
= read_status(dev
);
892 if ((status
& 0xf8) == 0x80) {
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
);
900 netif_wake_queue (dev
);
903 schedule_delayed_work(&nl
->deferred
, 1);
909 /* Handle the parallel port interrupts. */
911 plip_interrupt(void *dev_id
)
913 struct net_device
*dev
= dev_id
;
914 struct net_local
*nl
;
915 struct plip_local
*rcv
;
919 nl
= netdev_priv(dev
);
922 spin_lock_irqsave (&nl
->lock
, flags
);
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
);
933 printk(KERN_DEBUG
"%s: interrupt.\n", dev
->name
);
935 switch (nl
->connection
) {
936 case PLIP_CN_CLOSING
:
937 netif_wake_queue (dev
);
941 rcv
->state
= PLIP_PK_TRIGGER
;
942 nl
->connection
= PLIP_CN_RECEIVE
;
943 nl
->timeout_count
= 0;
944 schedule_work(&nl
->immediate
);
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. */
954 printk(KERN_ERR
"%s: receive interrupt in error state\n", dev
->name
);
958 spin_unlock_irqrestore(&nl
->lock
, flags
);
962 plip_tx_packet(struct sk_buff
*skb
, struct net_device
*dev
)
964 struct net_local
*nl
= netdev_priv(dev
);
965 struct plip_local
*snd
= &nl
->snd_data
;
967 if (netif_queue_stopped(dev
))
968 return NETDEV_TX_BUSY
;
970 /* We may need to grab the bus */
971 if (!nl
->port_owner
) {
972 if (parport_claim(nl
->pardev
))
973 return NETDEV_TX_BUSY
;
977 netif_stop_queue (dev
);
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
;
986 printk(KERN_DEBUG
"%s: send request\n", dev
->name
);
988 spin_lock_irq(&nl
->lock
);
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;
996 schedule_work(&nl
->immediate
);
997 spin_unlock_irq(&nl
->lock
);
1003 plip_rewrite_address(const struct net_device
*dev
, struct ethhdr
*eth
)
1005 const struct in_device
*in_dev
;
1008 in_dev
= __in_dev_get_rcu(dev
);
1010 /* Any address will do - we take the first */
1011 const struct in_ifaddr
*ifa
= rcu_dereference(in_dev
->ifa_list
);
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);
1022 plip_hard_header(struct sk_buff
*skb
, struct net_device
*dev
,
1023 unsigned short type
, const void *daddr
,
1024 const void *saddr
, unsigned len
)
1028 ret
= eth_header(skb
, dev
, type
, daddr
, saddr
, len
);
1030 plip_rewrite_address (dev
, (struct ethhdr
*)skb
->data
);
1035 static int plip_hard_header_cache(const struct neighbour
*neigh
,
1036 struct hh_cache
*hh
, __be16 type
)
1040 ret
= eth_header_cache(neigh
, hh
, type
);
1044 eth
= (struct ethhdr
*)(((u8
*)hh
->hh_data
) +
1045 HH_DATA_OFF(sizeof(*eth
)));
1046 plip_rewrite_address (neigh
->dev
, eth
);
1052 /* Open/initialize the board. This is called (in the current kernel)
1053 sometime after booting when the 'ifconfig' program is run.
1055 This routine gets exclusive access to the parallel port by allocating
1059 plip_open(struct net_device
*dev
)
1061 struct net_local
*nl
= netdev_priv(dev
);
1062 struct in_device
*in_dev
;
1065 if (!nl
->port_owner
) {
1066 if (parport_claim(nl
->pardev
)) return -EAGAIN
;
1070 nl
->should_relinquish
= 0;
1072 /* Clear the data port. */
1073 write_data (dev
, 0x00);
1075 /* Enable rx interrupt. */
1076 enable_parport_interrupts (dev
);
1079 atomic_set (&nl
->kill_timer
, 0);
1080 schedule_delayed_work(&nl
->timer
, 1);
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;
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). */
1101 in_dev
=__in_dev_get_rtnl(dev
);
1103 /* Any address will do - we take the first. We already
1104 have the first two bytes filled with 0xfc, from
1106 const struct in_ifaddr
*ifa
= rcu_dereference(in_dev
->ifa_list
);
1108 memcpy(dev
->dev_addr
+2, &ifa
->ifa_local
, 4);
1112 netif_start_queue (dev
);
1117 /* The inverse routine to plip_open (). */
1119 plip_close(struct net_device
*dev
)
1121 struct net_local
*nl
= netdev_priv(dev
);
1122 struct plip_local
*snd
= &nl
->snd_data
;
1123 struct plip_local
*rcv
= &nl
->rcv_data
;
1125 netif_stop_queue (dev
);
1127 synchronize_irq(dev
->irq
);
1131 init_completion(&nl
->killed_timer_cmp
);
1132 atomic_set (&nl
->kill_timer
, 1);
1133 wait_for_completion(&nl
->killed_timer_cmp
);
1137 outb(0x00, PAR_DATA(dev
));
1139 nl
->is_deferred
= 0;
1140 nl
->connection
= PLIP_CN_NONE
;
1141 if (nl
->port_owner
) {
1142 parport_release(nl
->pardev
);
1146 snd
->state
= PLIP_PK_DONE
;
1148 dev_kfree_skb(snd
->skb
);
1151 rcv
->state
= PLIP_PK_DONE
;
1153 kfree_skb(rcv
->skb
);
1159 outb(0x00, PAR_CONTROL(dev
));
1165 plip_preempt(void *handle
)
1167 struct net_device
*dev
= (struct net_device
*)handle
;
1168 struct net_local
*nl
= netdev_priv(dev
);
1170 /* Stand our ground if a datagram is on the wire */
1171 if (nl
->connection
!= PLIP_CN_NONE
) {
1172 nl
->should_relinquish
= 1;
1176 nl
->port_owner
= 0; /* Remember that we released the bus */
1181 plip_wakeup(void *handle
)
1183 struct net_device
*dev
= (struct net_device
*)handle
;
1184 struct net_local
*nl
= netdev_priv(dev
);
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
);
1196 if (!(dev
->flags
& IFF_UP
))
1197 /* Don't need the port when the interface is down */
1200 if (!parport_claim(nl
->pardev
)) {
1202 /* Clear the data port. */
1203 write_data (dev
, 0x00);
1208 plip_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1210 struct net_local
*nl
= netdev_priv(dev
);
1211 struct plipconf
*pc
= (struct plipconf
*) &rq
->ifr_ifru
;
1213 if (cmd
!= SIOCDEVPLIP
)
1217 case PLIP_GET_TIMEOUT
:
1218 pc
->trigger
= nl
->trigger
;
1219 pc
->nibble
= nl
->nibble
;
1221 case PLIP_SET_TIMEOUT
:
1222 if(!capable(CAP_NET_ADMIN
))
1224 nl
->trigger
= pc
->trigger
;
1225 nl
->nibble
= pc
->nibble
;
1233 static int parport
[PLIP_MAX
] = { [0 ... PLIP_MAX
-1] = -1 };
1236 module_param_array(parport
, int, NULL
, 0);
1237 module_param(timid
, int, 0);
1238 MODULE_PARM_DESC(parport
, "List of parport device numbers to use by plip");
1240 static struct net_device
*dev_plip
[PLIP_MAX
] = { NULL
, };
1243 plip_searchfor(int list
[], int a
)
1246 for (i
= 0; i
< PLIP_MAX
&& list
[i
] != -1; i
++) {
1247 if (list
[i
] == a
) return 1;
1252 /* plip_attach() is called (by the parport code) when a port is
1253 * available to use. */
1254 static void plip_attach (struct parport
*port
)
1257 struct net_device
*dev
;
1258 struct net_local
*nl
;
1259 char name
[IFNAMSIZ
];
1260 struct pardev_cb plip_cb
;
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");
1269 sprintf(name
, "plip%d", unit
);
1270 dev
= alloc_etherdev(sizeof(struct net_local
));
1274 strcpy(dev
->name
, name
);
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
);
1283 nl
= netdev_priv(dev
);
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
;
1292 nl
->pardev
= parport_register_dev_model(port
, dev
->name
,
1296 printk(KERN_ERR
"%s: parport_register failed\n", name
);
1300 plip_init_netdev(dev
);
1302 if (register_netdev(dev
)) {
1303 printk(KERN_ERR
"%s: network register failed\n", name
);
1304 goto err_parport_unregister
;
1307 printk(KERN_INFO
"%s", version
);
1309 printk(KERN_INFO
"%s: Parallel port at %#3lx, "
1311 dev
->name
, dev
->base_addr
, dev
->irq
);
1313 printk(KERN_INFO
"%s: Parallel port at %#3lx, "
1315 dev
->name
, dev
->base_addr
);
1316 dev_plip
[unit
++] = dev
;
1320 err_parport_unregister
:
1321 parport_unregister_device(nl
->pardev
);
1326 /* plip_detach() is called (by the parport code) when a port is
1327 * no longer available to use. */
1328 static void plip_detach (struct parport
*port
)
1333 static int plip_probe(struct pardevice
*par_dev
)
1335 struct device_driver
*drv
= par_dev
->dev
.driver
;
1336 int len
= strlen(drv
->name
);
1338 if (strncmp(par_dev
->name
, drv
->name
, len
))
1344 static struct parport_driver plip_driver
= {
1346 .probe
= plip_probe
,
1347 .match_port
= plip_attach
,
1348 .detach
= plip_detach
,
1352 static void __exit
plip_cleanup_module (void)
1354 struct net_device
*dev
;
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
);
1362 parport_release(nl
->pardev
);
1363 parport_unregister_device(nl
->pardev
);
1369 parport_unregister_driver(&plip_driver
);
1374 static int parport_ptr
;
1376 static int __init
plip_setup(char *str
)
1380 str
= get_options(str
, ARRAY_SIZE(ints
), ints
);
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
;
1388 printk(KERN_INFO
"plip: too many ports, %s ignored.\n",
1390 } else if (!strcmp(str
, "timid")) {
1393 if (ints
[0] == 0 || ints
[1] == 0) {
1394 /* disable driver on "plip=" or "plip=0" */
1397 printk(KERN_WARNING
"warning: 'plip=0x%x' ignored\n",
1404 __setup("plip=", plip_setup
);
1406 #endif /* !MODULE */
1408 static int __init
plip_init (void)
1410 if (parport
[0] == -2)
1413 if (parport
[0] != -1 && timid
) {
1414 printk(KERN_WARNING
"plip: warning, ignoring `timid' since specific ports given.\n");
1418 if (parport_register_driver (&plip_driver
)) {
1419 printk (KERN_WARNING
"plip: couldn't register driver\n");
1426 module_init(plip_init
);
1427 module_exit(plip_cleanup_module
);
1428 MODULE_LICENSE("GPL");