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). */
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>
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
24 * - Module initialization.
26 * - Make sure other end is OK, before sending a packet.
27 * - Fix immediate timer problem.
30 * - Changed {enable,disable}_irq handling to make it work
31 * with new ("stack") semantics.
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.
40 * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com>
41 * inspired by Russ Nelson's parallel port packet driver.
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.
49 * This version follows original PLIP protocol.
50 * So, this PLIP can't communicate the PLIP of Linux v1.0.
54 * To use with DOS box, please do (Turn on ARP switch):
55 * # ifconfig plip[0-2] arp
57 static const char version
[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n";
61 Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
62 "parallel.asm" parallel port packet driver.
64 The "Crynwr" parallel port standard specifies the following protocol:
65 Trigger by sending nibble '0x8' (this causes interrupt on other end)
70 Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
71 <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
73 The packet is encapsulated as if it were ethernet.
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:
80 D0->ERROR 2 - 15 15 - 2
81 D1->SLCT 3 - 13 13 - 3
82 D2->PAPOUT 4 - 12 12 - 4
84 D4->BUSY 6 - 11 11 - 6
85 Do not connect the other pins. They are
87 STROBE is 1, FEED is 14, INIT is 16
88 extra grounds are 18,19,20,21,22,23,24
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/if_ether.h>
99 #include <linux/errno.h>
100 #include <linux/delay.h>
101 #include <linux/init.h>
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/inetdevice.h>
105 #include <linux/skbuff.h>
106 #include <linux/if_plip.h>
107 #include <linux/workqueue.h>
108 #include <linux/spinlock.h>
109 #include <linux/completion.h>
110 #include <linux/parport.h>
111 #include <linux/bitops.h>
113 #include <net/neighbour.h>
115 #include <asm/system.h>
117 #include <asm/byteorder.h>
119 /* Maximum number of devices to support. */
122 /* Use 0 for production, 1 for verification, >2 for debug */
126 static const unsigned int net_debug
= NET_DEBUG
;
128 #define ENABLE(irq) if (irq != -1) enable_irq(irq)
129 #define DISABLE(irq) if (irq != -1) disable_irq(irq)
131 /* In micro second */
132 #define PLIP_DELAY_UNIT 1
134 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
135 #define PLIP_TRIGGER_WAIT 500
137 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
138 #define PLIP_NIBBLE_WAIT 3000
141 static void plip_kick_bh(struct work_struct
*work
);
142 static void plip_bh(struct work_struct
*work
);
143 static void plip_timer_bh(struct work_struct
*work
);
145 /* Interrupt handler */
146 static void plip_interrupt(void *dev_id
);
148 /* Functions for DEV methods */
149 static int plip_tx_packet(struct sk_buff
*skb
, struct net_device
*dev
);
150 static 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
);
153 static int plip_hard_header_cache(const struct neighbour
*neigh
,
154 struct hh_cache
*hh
);
155 static int plip_open(struct net_device
*dev
);
156 static int plip_close(struct net_device
*dev
);
157 static int plip_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
);
158 static int plip_preempt(void *handle
);
159 static void plip_wakeup(void *handle
);
161 enum plip_connection_state
{
169 enum plip_packet_state
{
178 enum plip_nibble_state
{
185 enum plip_packet_state state
;
186 enum plip_nibble_state nibble
;
189 #if defined(__LITTLE_ENDIAN)
192 #elif defined(__BIG_ENDIAN)
196 #error "Please fix the endianness defines in <asm/byteorder.h>"
202 unsigned char checksum
;
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
;
221 int should_relinquish
;
224 struct completion killed_timer_cmp
;
227 static inline void enable_parport_interrupts (struct net_device
*dev
)
231 struct parport
*port
=
232 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
233 port
->ops
->enable_irq (port
);
237 static inline void disable_parport_interrupts (struct net_device
*dev
)
241 struct parport
*port
=
242 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
243 port
->ops
->disable_irq (port
);
247 static inline void write_data (struct net_device
*dev
, unsigned char data
)
249 struct parport
*port
=
250 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
252 port
->ops
->write_data (port
, data
);
255 static inline unsigned char read_status (struct net_device
*dev
)
257 struct parport
*port
=
258 ((struct net_local
*)netdev_priv(dev
))->pardev
->port
;
260 return port
->ops
->read_status (port
);
263 static const struct header_ops plip_header_ops
= {
264 .create
= plip_hard_header
,
265 .cache
= plip_hard_header_cache
,
268 /* Entry point of PLIP driver.
269 Probe the hardware, and register/initialize the driver.
271 PLIP is rather weird, because of the way it interacts with the parport
272 system. It is _not_ initialised from Space.c. Instead, plip_init()
273 is called, and that function makes up a "struct net_device" for each port, and
278 plip_init_netdev(struct net_device
*dev
)
280 struct net_local
*nl
= netdev_priv(dev
);
282 /* Then, override parts of it */
283 dev
->hard_start_xmit
= plip_tx_packet
;
284 dev
->open
= plip_open
;
285 dev
->stop
= plip_close
;
286 dev
->do_ioctl
= plip_ioctl
;
288 dev
->tx_queue_len
= 10;
289 dev
->flags
= IFF_POINTOPOINT
|IFF_NOARP
;
290 memset(dev
->dev_addr
, 0xfc, ETH_ALEN
);
292 dev
->header_ops
= &plip_header_ops
;
297 /* Initialize constants */
298 nl
->trigger
= PLIP_TRIGGER_WAIT
;
299 nl
->nibble
= PLIP_NIBBLE_WAIT
;
301 /* Initialize task queue structures */
302 INIT_WORK(&nl
->immediate
, plip_bh
);
303 INIT_DELAYED_WORK(&nl
->deferred
, plip_kick_bh
);
306 INIT_DELAYED_WORK(&nl
->timer
, plip_timer_bh
);
308 spin_lock_init(&nl
->lock
);
311 /* Bottom half handler for the delayed request.
312 This routine is kicked by do_timer().
313 Request `plip_bh' to be invoked. */
315 plip_kick_bh(struct work_struct
*work
)
317 struct net_local
*nl
=
318 container_of(work
, struct net_local
, deferred
.work
);
321 schedule_work(&nl
->immediate
);
324 /* Forward declarations of internal routines */
325 static int plip_none(struct net_device
*, struct net_local
*,
326 struct plip_local
*, struct plip_local
*);
327 static int plip_receive_packet(struct net_device
*, struct net_local
*,
328 struct plip_local
*, struct plip_local
*);
329 static int plip_send_packet(struct net_device
*, struct net_local
*,
330 struct plip_local
*, struct plip_local
*);
331 static int plip_connection_close(struct net_device
*, struct net_local
*,
332 struct plip_local
*, struct plip_local
*);
333 static int plip_error(struct net_device
*, struct net_local
*,
334 struct plip_local
*, struct plip_local
*);
335 static int plip_bh_timeout_error(struct net_device
*dev
, struct net_local
*nl
,
336 struct plip_local
*snd
,
337 struct plip_local
*rcv
,
345 typedef int (*plip_func
)(struct net_device
*dev
, struct net_local
*nl
,
346 struct plip_local
*snd
, struct plip_local
*rcv
);
348 static const plip_func connection_state_table
[] =
353 plip_connection_close
,
357 /* Bottom half handler of PLIP. */
359 plip_bh(struct work_struct
*work
)
361 struct net_local
*nl
= container_of(work
, struct net_local
, immediate
);
362 struct plip_local
*snd
= &nl
->snd_data
;
363 struct plip_local
*rcv
= &nl
->rcv_data
;
368 f
= connection_state_table
[nl
->connection
];
369 if ((r
= (*f
)(nl
->dev
, nl
, snd
, rcv
)) != OK
370 && (r
= plip_bh_timeout_error(nl
->dev
, nl
, snd
, rcv
, r
)) != OK
) {
372 schedule_delayed_work(&nl
->deferred
, 1);
377 plip_timer_bh(struct work_struct
*work
)
379 struct net_local
*nl
=
380 container_of(work
, struct net_local
, timer
.work
);
382 if (!(atomic_read (&nl
->kill_timer
))) {
383 plip_interrupt (nl
->dev
);
385 schedule_delayed_work(&nl
->timer
, 1);
388 complete(&nl
->killed_timer_cmp
);
393 plip_bh_timeout_error(struct net_device
*dev
, struct net_local
*nl
,
394 struct plip_local
*snd
, struct plip_local
*rcv
,
399 * This is tricky. If we got here from the beginning of send (either
400 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
401 * already disabled. With the old variant of {enable,disable}_irq()
402 * extra disable_irq() was a no-op. Now it became mortal - it's
403 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
404 * that is). So we have to treat HS_TIMEOUT and ERROR from send
408 spin_lock_irq(&nl
->lock
);
409 if (nl
->connection
== PLIP_CN_SEND
) {
411 if (error
!= ERROR
) { /* Timeout */
413 if ((error
== HS_TIMEOUT
414 && 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 */
505 c0
= read_status(dev
);
506 udelay(PLIP_DELAY_UNIT
);
508 c1
= read_status(dev
);
515 *data_p
|= (c0
<< 1) & 0xf0;
516 write_data (dev
, 0x00); /* send ACK */
517 *ns_p
= PLIP_NB_BEGIN
;
525 * Determine the packet's protocol ID. The rule here is that we
526 * assume 802.3 if the type field is short enough to be a length.
527 * This is normal practice and works for any 'now in use' protocol.
529 * PLIP is ethernet ish but the daddr might not be valid if unicast.
530 * PLIP fortunately has no bus architecture (its Point-to-point).
532 * We can't fix the daddr thing as that quirk (more bug) is embedded
533 * in far too many old systems not all even running Linux.
536 static __be16
plip_type_trans(struct sk_buff
*skb
, struct net_device
*dev
)
541 skb_reset_mac_header(skb
);
542 skb_pull(skb
,dev
->hard_header_len
);
547 if(memcmp(eth
->h_dest
,dev
->broadcast
, ETH_ALEN
)==0)
548 skb
->pkt_type
=PACKET_BROADCAST
;
550 skb
->pkt_type
=PACKET_MULTICAST
;
554 * This ALLMULTI check should be redundant by 1.4
555 * so don't forget to remove it.
558 if (ntohs(eth
->h_proto
) >= 1536)
564 * This is a magic hack to spot IPX packets. Older Novell breaks
565 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
566 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
567 * won't work for fault tolerant netware but does for the rest.
569 if (*(unsigned short *)rawp
== 0xFFFF)
570 return htons(ETH_P_802_3
);
575 return htons(ETH_P_802_2
);
578 /* PLIP_RECEIVE_PACKET --- receive a packet */
580 plip_receive_packet(struct net_device
*dev
, struct net_local
*nl
,
581 struct plip_local
*snd
, struct plip_local
*rcv
)
583 unsigned short nibble_timeout
= nl
->nibble
;
586 switch (rcv
->state
) {
587 case PLIP_PK_TRIGGER
:
589 /* Don't need to synchronize irq, as we can safely ignore it */
590 disable_parport_interrupts (dev
);
591 write_data (dev
, 0x01); /* send ACK */
593 printk(KERN_DEBUG
"%s: receive start\n", dev
->name
);
594 rcv
->state
= PLIP_PK_LENGTH_LSB
;
595 rcv
->nibble
= PLIP_NB_BEGIN
;
597 case PLIP_PK_LENGTH_LSB
:
598 if (snd
->state
!= PLIP_PK_DONE
) {
599 if (plip_receive(nl
->trigger
, dev
,
600 &rcv
->nibble
, &rcv
->length
.b
.lsb
)) {
601 /* collision, here dev->tbusy == 1 */
602 rcv
->state
= PLIP_PK_DONE
;
604 nl
->connection
= PLIP_CN_SEND
;
605 schedule_delayed_work(&nl
->deferred
, 1);
606 enable_parport_interrupts (dev
);
611 if (plip_receive(nibble_timeout
, dev
,
612 &rcv
->nibble
, &rcv
->length
.b
.lsb
))
615 rcv
->state
= PLIP_PK_LENGTH_MSB
;
617 case PLIP_PK_LENGTH_MSB
:
618 if (plip_receive(nibble_timeout
, dev
,
619 &rcv
->nibble
, &rcv
->length
.b
.msb
))
621 if (rcv
->length
.h
> dev
->mtu
+ dev
->hard_header_len
622 || rcv
->length
.h
< 8) {
623 printk(KERN_WARNING
"%s: bogus packet size %d.\n", dev
->name
, rcv
->length
.h
);
626 /* Malloc up new buffer. */
627 rcv
->skb
= dev_alloc_skb(rcv
->length
.h
+ 2);
628 if (rcv
->skb
== NULL
) {
629 printk(KERN_ERR
"%s: Memory squeeze.\n", dev
->name
);
632 skb_reserve(rcv
->skb
, 2); /* Align IP on 16 byte boundaries */
633 skb_put(rcv
->skb
,rcv
->length
.h
);
635 rcv
->state
= PLIP_PK_DATA
;
640 lbuf
= rcv
->skb
->data
;
642 if (plip_receive(nibble_timeout
, dev
,
643 &rcv
->nibble
, &lbuf
[rcv
->byte
]))
645 while (++rcv
->byte
< rcv
->length
.h
);
647 rcv
->checksum
+= lbuf
[--rcv
->byte
];
649 rcv
->state
= PLIP_PK_CHECKSUM
;
651 case PLIP_PK_CHECKSUM
:
652 if (plip_receive(nibble_timeout
, dev
,
653 &rcv
->nibble
, &rcv
->data
))
655 if (rcv
->data
!= rcv
->checksum
) {
656 dev
->stats
.rx_crc_errors
++;
658 printk(KERN_DEBUG
"%s: checksum error\n", dev
->name
);
661 rcv
->state
= PLIP_PK_DONE
;
664 /* Inform the upper layer for the arrival of a packet. */
665 rcv
->skb
->protocol
=plip_type_trans(rcv
->skb
, dev
);
666 netif_rx_ni(rcv
->skb
);
667 dev
->stats
.rx_bytes
+= rcv
->length
.h
;
668 dev
->stats
.rx_packets
++;
671 printk(KERN_DEBUG
"%s: receive end\n", dev
->name
);
673 /* Close the connection. */
674 write_data (dev
, 0x00);
675 spin_lock_irq(&nl
->lock
);
676 if (snd
->state
!= PLIP_PK_DONE
) {
677 nl
->connection
= PLIP_CN_SEND
;
678 spin_unlock_irq(&nl
->lock
);
679 schedule_work(&nl
->immediate
);
680 enable_parport_interrupts (dev
);
684 nl
->connection
= PLIP_CN_NONE
;
685 spin_unlock_irq(&nl
->lock
);
686 enable_parport_interrupts (dev
);
694 /* PLIP_SEND --- send a byte (two nibbles)
695 Returns OK on success, TIMEOUT when timeout */
697 plip_send(unsigned short nibble_timeout
, struct net_device
*dev
,
698 enum plip_nibble_state
*ns_p
, unsigned char data
)
705 write_data (dev
, data
& 0x0f);
709 write_data (dev
, 0x10 | (data
& 0x0f));
712 c0
= read_status(dev
);
713 if ((c0
& 0x80) == 0)
717 udelay(PLIP_DELAY_UNIT
);
719 write_data (dev
, 0x10 | (data
>> 4));
723 write_data (dev
, (data
>> 4));
726 c0
= read_status(dev
);
731 udelay(PLIP_DELAY_UNIT
);
733 *ns_p
= PLIP_NB_BEGIN
;
739 /* PLIP_SEND_PACKET --- send a packet */
741 plip_send_packet(struct net_device
*dev
, struct net_local
*nl
,
742 struct plip_local
*snd
, struct plip_local
*rcv
)
744 unsigned short nibble_timeout
= nl
->nibble
;
749 if (snd
->skb
== NULL
|| (lbuf
= snd
->skb
->data
) == NULL
) {
750 printk(KERN_DEBUG
"%s: send skb lost\n", dev
->name
);
751 snd
->state
= PLIP_PK_DONE
;
756 switch (snd
->state
) {
757 case PLIP_PK_TRIGGER
:
758 if ((read_status(dev
) & 0xf8) != 0x80)
761 /* Trigger remote rx interrupt. */
762 write_data (dev
, 0x08);
765 udelay(PLIP_DELAY_UNIT
);
766 spin_lock_irq(&nl
->lock
);
767 if (nl
->connection
== PLIP_CN_RECEIVE
) {
768 spin_unlock_irq(&nl
->lock
);
770 dev
->stats
.collisions
++;
773 c0
= read_status(dev
);
775 spin_unlock_irq(&nl
->lock
);
777 synchronize_irq(dev
->irq
);
778 if (nl
->connection
== PLIP_CN_RECEIVE
) {
780 We don't need to enable irq,
781 as it is soon disabled. */
782 /* Yes, we do. New variant of
783 {enable,disable}_irq *counts*
786 dev
->stats
.collisions
++;
789 disable_parport_interrupts (dev
);
791 printk(KERN_DEBUG
"%s: send start\n", dev
->name
);
792 snd
->state
= PLIP_PK_LENGTH_LSB
;
793 snd
->nibble
= PLIP_NB_BEGIN
;
794 nl
->timeout_count
= 0;
797 spin_unlock_irq(&nl
->lock
);
799 write_data (dev
, 0x00);
804 case PLIP_PK_LENGTH_LSB
:
805 if (plip_send(nibble_timeout
, dev
,
806 &snd
->nibble
, snd
->length
.b
.lsb
))
808 snd
->state
= PLIP_PK_LENGTH_MSB
;
810 case PLIP_PK_LENGTH_MSB
:
811 if (plip_send(nibble_timeout
, dev
,
812 &snd
->nibble
, snd
->length
.b
.msb
))
814 snd
->state
= PLIP_PK_DATA
;
820 if (plip_send(nibble_timeout
, dev
,
821 &snd
->nibble
, lbuf
[snd
->byte
]))
823 while (++snd
->byte
< snd
->length
.h
);
825 snd
->checksum
+= lbuf
[--snd
->byte
];
827 snd
->state
= PLIP_PK_CHECKSUM
;
829 case PLIP_PK_CHECKSUM
:
830 if (plip_send(nibble_timeout
, dev
,
831 &snd
->nibble
, snd
->checksum
))
834 dev
->stats
.tx_bytes
+= snd
->skb
->len
;
835 dev_kfree_skb(snd
->skb
);
836 dev
->stats
.tx_packets
++;
837 snd
->state
= PLIP_PK_DONE
;
840 /* Close the connection */
841 write_data (dev
, 0x00);
844 printk(KERN_DEBUG
"%s: send end\n", dev
->name
);
845 nl
->connection
= PLIP_CN_CLOSING
;
847 schedule_delayed_work(&nl
->deferred
, 1);
848 enable_parport_interrupts (dev
);
856 plip_connection_close(struct net_device
*dev
, struct net_local
*nl
,
857 struct plip_local
*snd
, struct plip_local
*rcv
)
859 spin_lock_irq(&nl
->lock
);
860 if (nl
->connection
== PLIP_CN_CLOSING
) {
861 nl
->connection
= PLIP_CN_NONE
;
862 netif_wake_queue (dev
);
864 spin_unlock_irq(&nl
->lock
);
865 if (nl
->should_relinquish
) {
866 nl
->should_relinquish
= nl
->port_owner
= 0;
867 parport_release(nl
->pardev
);
872 /* PLIP_ERROR --- wait till other end settled */
874 plip_error(struct net_device
*dev
, struct net_local
*nl
,
875 struct plip_local
*snd
, struct plip_local
*rcv
)
877 unsigned char status
;
879 status
= read_status(dev
);
880 if ((status
& 0xf8) == 0x80) {
882 printk(KERN_DEBUG
"%s: reset interface.\n", dev
->name
);
883 nl
->connection
= PLIP_CN_NONE
;
884 nl
->should_relinquish
= 0;
885 netif_start_queue (dev
);
886 enable_parport_interrupts (dev
);
888 netif_wake_queue (dev
);
891 schedule_delayed_work(&nl
->deferred
, 1);
897 /* Handle the parallel port interrupts. */
899 plip_interrupt(void *dev_id
)
901 struct net_device
*dev
= dev_id
;
902 struct net_local
*nl
;
903 struct plip_local
*rcv
;
907 nl
= netdev_priv(dev
);
910 spin_lock_irqsave (&nl
->lock
, flags
);
912 c0
= read_status(dev
);
913 if ((c0
& 0xf8) != 0xc0) {
914 if ((dev
->irq
!= -1) && (net_debug
> 1))
915 printk(KERN_DEBUG
"%s: spurious interrupt\n", dev
->name
);
916 spin_unlock_irqrestore (&nl
->lock
, flags
);
921 printk(KERN_DEBUG
"%s: interrupt.\n", dev
->name
);
923 switch (nl
->connection
) {
924 case PLIP_CN_CLOSING
:
925 netif_wake_queue (dev
);
928 rcv
->state
= PLIP_PK_TRIGGER
;
929 nl
->connection
= PLIP_CN_RECEIVE
;
930 nl
->timeout_count
= 0;
931 schedule_work(&nl
->immediate
);
934 case PLIP_CN_RECEIVE
:
935 /* May occur because there is race condition
936 around test and set of dev->interrupt.
937 Ignore this interrupt. */
941 printk(KERN_ERR
"%s: receive interrupt in error state\n", dev
->name
);
945 spin_unlock_irqrestore(&nl
->lock
, flags
);
949 plip_tx_packet(struct sk_buff
*skb
, struct net_device
*dev
)
951 struct net_local
*nl
= netdev_priv(dev
);
952 struct plip_local
*snd
= &nl
->snd_data
;
954 if (netif_queue_stopped(dev
))
957 /* We may need to grab the bus */
958 if (!nl
->port_owner
) {
959 if (parport_claim(nl
->pardev
))
964 netif_stop_queue (dev
);
966 if (skb
->len
> dev
->mtu
+ dev
->hard_header_len
) {
967 printk(KERN_WARNING
"%s: packet too big, %d.\n", dev
->name
, (int)skb
->len
);
968 netif_start_queue (dev
);
973 printk(KERN_DEBUG
"%s: send request\n", dev
->name
);
975 spin_lock_irq(&nl
->lock
);
976 dev
->trans_start
= jiffies
;
978 snd
->length
.h
= skb
->len
;
979 snd
->state
= PLIP_PK_TRIGGER
;
980 if (nl
->connection
== PLIP_CN_NONE
) {
981 nl
->connection
= PLIP_CN_SEND
;
982 nl
->timeout_count
= 0;
984 schedule_work(&nl
->immediate
);
985 spin_unlock_irq(&nl
->lock
);
991 plip_rewrite_address(const struct net_device
*dev
, struct ethhdr
*eth
)
993 const struct in_device
*in_dev
= dev
->ip_ptr
;
996 /* Any address will do - we take the first */
997 const struct in_ifaddr
*ifa
= in_dev
->ifa_list
;
999 memcpy(eth
->h_source
, dev
->dev_addr
, 6);
1000 memset(eth
->h_dest
, 0xfc, 2);
1001 memcpy(eth
->h_dest
+2, &ifa
->ifa_address
, 4);
1007 plip_hard_header(struct sk_buff
*skb
, struct net_device
*dev
,
1008 unsigned short type
, const void *daddr
,
1009 const void *saddr
, unsigned len
)
1013 ret
= eth_header(skb
, dev
, type
, daddr
, saddr
, len
);
1015 plip_rewrite_address (dev
, (struct ethhdr
*)skb
->data
);
1020 int plip_hard_header_cache(const struct neighbour
*neigh
,
1021 struct hh_cache
*hh
)
1025 ret
= eth_header_cache(neigh
, hh
);
1029 eth
= (struct ethhdr
*)(((u8
*)hh
->hh_data
) +
1030 HH_DATA_OFF(sizeof(*eth
)));
1031 plip_rewrite_address (neigh
->dev
, eth
);
1037 /* Open/initialize the board. This is called (in the current kernel)
1038 sometime after booting when the 'ifconfig' program is run.
1040 This routine gets exclusive access to the parallel port by allocating
1044 plip_open(struct net_device
*dev
)
1046 struct net_local
*nl
= netdev_priv(dev
);
1047 struct in_device
*in_dev
;
1050 if (!nl
->port_owner
) {
1051 if (parport_claim(nl
->pardev
)) return -EAGAIN
;
1055 nl
->should_relinquish
= 0;
1057 /* Clear the data port. */
1058 write_data (dev
, 0x00);
1060 /* Enable rx interrupt. */
1061 enable_parport_interrupts (dev
);
1064 atomic_set (&nl
->kill_timer
, 0);
1065 schedule_delayed_work(&nl
->timer
, 1);
1068 /* Initialize the state machine. */
1069 nl
->rcv_data
.state
= nl
->snd_data
.state
= PLIP_PK_DONE
;
1070 nl
->rcv_data
.skb
= nl
->snd_data
.skb
= NULL
;
1071 nl
->connection
= PLIP_CN_NONE
;
1072 nl
->is_deferred
= 0;
1074 /* Fill in the MAC-level header.
1075 We used to abuse dev->broadcast to store the point-to-point
1076 MAC address, but we no longer do it. Instead, we fetch the
1077 interface address whenever it is needed, which is cheap enough
1078 because we use the hh_cache. Actually, abusing dev->broadcast
1079 didn't work, because when using plip_open the point-to-point
1080 address isn't yet known.
1081 PLIP doesn't have a real MAC address, but we need it to be
1082 DOS compatible, and to properly support taps (otherwise,
1083 when the device address isn't identical to the address of a
1084 received frame, the kernel incorrectly drops it). */
1086 if ((in_dev
=dev
->ip_ptr
) != NULL
) {
1087 /* Any address will do - we take the first. We already
1088 have the first two bytes filled with 0xfc, from
1090 struct in_ifaddr
*ifa
=in_dev
->ifa_list
;
1092 memcpy(dev
->dev_addr
+2, &ifa
->ifa_local
, 4);
1096 netif_start_queue (dev
);
1101 /* The inverse routine to plip_open (). */
1103 plip_close(struct net_device
*dev
)
1105 struct net_local
*nl
= netdev_priv(dev
);
1106 struct plip_local
*snd
= &nl
->snd_data
;
1107 struct plip_local
*rcv
= &nl
->rcv_data
;
1109 netif_stop_queue (dev
);
1111 synchronize_irq(dev
->irq
);
1115 init_completion(&nl
->killed_timer_cmp
);
1116 atomic_set (&nl
->kill_timer
, 1);
1117 wait_for_completion(&nl
->killed_timer_cmp
);
1121 outb(0x00, PAR_DATA(dev
));
1123 nl
->is_deferred
= 0;
1124 nl
->connection
= PLIP_CN_NONE
;
1125 if (nl
->port_owner
) {
1126 parport_release(nl
->pardev
);
1130 snd
->state
= PLIP_PK_DONE
;
1132 dev_kfree_skb(snd
->skb
);
1135 rcv
->state
= PLIP_PK_DONE
;
1137 kfree_skb(rcv
->skb
);
1143 outb(0x00, PAR_CONTROL(dev
));
1149 plip_preempt(void *handle
)
1151 struct net_device
*dev
= (struct net_device
*)handle
;
1152 struct net_local
*nl
= netdev_priv(dev
);
1154 /* Stand our ground if a datagram is on the wire */
1155 if (nl
->connection
!= PLIP_CN_NONE
) {
1156 nl
->should_relinquish
= 1;
1160 nl
->port_owner
= 0; /* Remember that we released the bus */
1165 plip_wakeup(void *handle
)
1167 struct net_device
*dev
= (struct net_device
*)handle
;
1168 struct net_local
*nl
= netdev_priv(dev
);
1170 if (nl
->port_owner
) {
1171 /* Why are we being woken up? */
1172 printk(KERN_DEBUG
"%s: why am I being woken up?\n", dev
->name
);
1173 if (!parport_claim(nl
->pardev
))
1174 /* bus_owner is already set (but why?) */
1175 printk(KERN_DEBUG
"%s: I'm broken.\n", dev
->name
);
1180 if (!(dev
->flags
& IFF_UP
))
1181 /* Don't need the port when the interface is down */
1184 if (!parport_claim(nl
->pardev
)) {
1186 /* Clear the data port. */
1187 write_data (dev
, 0x00);
1194 plip_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
1196 struct net_local
*nl
= netdev_priv(dev
);
1197 struct plipconf
*pc
= (struct plipconf
*) &rq
->ifr_ifru
;
1199 if (cmd
!= SIOCDEVPLIP
)
1203 case PLIP_GET_TIMEOUT
:
1204 pc
->trigger
= nl
->trigger
;
1205 pc
->nibble
= nl
->nibble
;
1207 case PLIP_SET_TIMEOUT
:
1208 if(!capable(CAP_NET_ADMIN
))
1210 nl
->trigger
= pc
->trigger
;
1211 nl
->nibble
= pc
->nibble
;
1219 static int parport
[PLIP_MAX
] = { [0 ... PLIP_MAX
-1] = -1 };
1222 module_param_array(parport
, int, NULL
, 0);
1223 module_param(timid
, int, 0);
1224 MODULE_PARM_DESC(parport
, "List of parport device numbers to use by plip");
1226 static struct net_device
*dev_plip
[PLIP_MAX
] = { NULL
, };
1229 plip_searchfor(int list
[], int a
)
1232 for (i
= 0; i
< PLIP_MAX
&& list
[i
] != -1; i
++) {
1233 if (list
[i
] == a
) return 1;
1238 /* plip_attach() is called (by the parport code) when a port is
1239 * available to use. */
1240 static void plip_attach (struct parport
*port
)
1243 struct net_device
*dev
;
1244 struct net_local
*nl
;
1245 char name
[IFNAMSIZ
];
1247 if ((parport
[0] == -1 && (!timid
|| !port
->devices
)) ||
1248 plip_searchfor(parport
, port
->number
)) {
1249 if (unit
== PLIP_MAX
) {
1250 printk(KERN_ERR
"plip: too many devices\n");
1254 sprintf(name
, "plip%d", unit
);
1255 dev
= alloc_etherdev(sizeof(struct net_local
));
1257 printk(KERN_ERR
"plip: memory squeeze\n");
1261 strcpy(dev
->name
, name
);
1263 dev
->irq
= port
->irq
;
1264 dev
->base_addr
= port
->base
;
1265 if (port
->irq
== -1) {
1266 printk(KERN_INFO
"plip: %s has no IRQ. Using IRQ-less mode,"
1267 "which is fairly inefficient!\n", port
->name
);
1270 nl
= netdev_priv(dev
);
1272 nl
->pardev
= parport_register_device(port
, dev
->name
, plip_preempt
,
1273 plip_wakeup
, plip_interrupt
,
1277 printk(KERN_ERR
"%s: parport_register failed\n", name
);
1282 plip_init_netdev(dev
);
1284 if (register_netdev(dev
)) {
1285 printk(KERN_ERR
"%s: network register failed\n", name
);
1286 goto err_parport_unregister
;
1289 printk(KERN_INFO
"%s", version
);
1291 printk(KERN_INFO
"%s: Parallel port at %#3lx, "
1293 dev
->name
, dev
->base_addr
, dev
->irq
);
1295 printk(KERN_INFO
"%s: Parallel port at %#3lx, "
1297 dev
->name
, dev
->base_addr
);
1298 dev_plip
[unit
++] = dev
;
1302 err_parport_unregister
:
1303 parport_unregister_device(nl
->pardev
);
1309 /* plip_detach() is called (by the parport code) when a port is
1310 * no longer available to use. */
1311 static void plip_detach (struct parport
*port
)
1316 static struct parport_driver plip_driver
= {
1318 .attach
= plip_attach
,
1319 .detach
= plip_detach
1322 static void __exit
plip_cleanup_module (void)
1324 struct net_device
*dev
;
1327 parport_unregister_driver (&plip_driver
);
1329 for (i
=0; i
< PLIP_MAX
; i
++) {
1330 if ((dev
= dev_plip
[i
])) {
1331 struct net_local
*nl
= netdev_priv(dev
);
1332 unregister_netdev(dev
);
1334 parport_release(nl
->pardev
);
1335 parport_unregister_device(nl
->pardev
);
1344 static int parport_ptr
;
1346 static int __init
plip_setup(char *str
)
1350 str
= get_options(str
, ARRAY_SIZE(ints
), ints
);
1353 if (!strncmp(str
, "parport", 7)) {
1354 int n
= simple_strtoul(str
+7, NULL
, 10);
1355 if (parport_ptr
< PLIP_MAX
)
1356 parport
[parport_ptr
++] = n
;
1358 printk(KERN_INFO
"plip: too many ports, %s ignored.\n",
1360 } else if (!strcmp(str
, "timid")) {
1363 if (ints
[0] == 0 || ints
[1] == 0) {
1364 /* disable driver on "plip=" or "plip=0" */
1367 printk(KERN_WARNING
"warning: 'plip=0x%x' ignored\n",
1374 __setup("plip=", plip_setup
);
1376 #endif /* !MODULE */
1378 static int __init
plip_init (void)
1380 if (parport
[0] == -2)
1383 if (parport
[0] != -1 && timid
) {
1384 printk(KERN_WARNING
"plip: warning, ignoring `timid' since specific ports given.\n");
1388 if (parport_register_driver (&plip_driver
)) {
1389 printk (KERN_WARNING
"plip: couldn't register driver\n");
1396 module_init(plip_init
);
1397 module_exit(plip_cleanup_module
);
1398 MODULE_LICENSE("GPL");
1402 * compile-command: "gcc -DMODULE -DMODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -c plip.c"