blob: ca4df7f4cf21df0099c883a2484c482e202246b0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $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),
Jeff Garzik6aa20a22006-09-13 13:24:59 -040019 * Modifications to use the parallel port API
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * 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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090097#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#include <linux/if_ether.h>
99#include <linux/in.h>
100#include <linux/errno.h>
101#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#include <linux/spinlock.h>
Matthias Kaehlcke01f31ac2007-12-13 16:03:00 -0800110#include <linux/completion.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#include <linux/parport.h>
112#include <linux/bitops.h>
113
114#include <net/neighbour.h>
115
116#include <asm/system.h>
117#include <asm/irq.h>
118#include <asm/byteorder.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120/* Maximum number of devices to support. */
121#define PLIP_MAX 8
122
123/* Use 0 for production, 1 for verification, >2 for debug */
124#ifndef NET_DEBUG
125#define NET_DEBUG 1
126#endif
Arjan van de Venf71e1302006-03-03 21:33:57 -0500127static const unsigned int net_debug = NET_DEBUG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129#define ENABLE(irq) if (irq != -1) enable_irq(irq)
130#define DISABLE(irq) if (irq != -1) disable_irq(irq)
131
132/* In micro second */
133#define PLIP_DELAY_UNIT 1
134
135/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
136#define PLIP_TRIGGER_WAIT 500
137
138/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
139#define PLIP_NIBBLE_WAIT 3000
140
141/* Bottom halves */
David Howellsc4028952006-11-22 14:57:56 +0000142static void plip_kick_bh(struct work_struct *work);
143static void plip_bh(struct work_struct *work);
144static void plip_timer_bh(struct work_struct *work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146/* Interrupt handler */
Jeff Garzik5712cb32007-10-19 02:54:26 -0400147static void plip_interrupt(void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149/* Functions for DEV methods */
150static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);
151static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700152 unsigned short type, const void *daddr,
153 const void *saddr, unsigned len);
154static int plip_hard_header_cache(const struct neighbour *neigh,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 struct hh_cache *hh);
156static int plip_open(struct net_device *dev);
157static int plip_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
159static int plip_preempt(void *handle);
160static void plip_wakeup(void *handle);
Jesper Juhl77933d72005-07-27 11:46:09 -0700161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162enum plip_connection_state {
163 PLIP_CN_NONE=0,
164 PLIP_CN_RECEIVE,
165 PLIP_CN_SEND,
166 PLIP_CN_CLOSING,
167 PLIP_CN_ERROR
168};
169
170enum plip_packet_state {
171 PLIP_PK_DONE=0,
172 PLIP_PK_TRIGGER,
173 PLIP_PK_LENGTH_LSB,
174 PLIP_PK_LENGTH_MSB,
175 PLIP_PK_DATA,
176 PLIP_PK_CHECKSUM
177};
178
179enum plip_nibble_state {
180 PLIP_NB_BEGIN,
181 PLIP_NB_1,
182 PLIP_NB_2,
183};
184
185struct plip_local {
186 enum plip_packet_state state;
187 enum plip_nibble_state nibble;
188 union {
189 struct {
190#if defined(__LITTLE_ENDIAN)
191 unsigned char lsb;
192 unsigned char msb;
193#elif defined(__BIG_ENDIAN)
194 unsigned char msb;
195 unsigned char lsb;
196#else
197#error "Please fix the endianness defines in <asm/byteorder.h>"
198#endif
199 } b;
200 unsigned short h;
201 } length;
202 unsigned short byte;
203 unsigned char checksum;
204 unsigned char data;
205 struct sk_buff *skb;
206};
207
208struct net_local {
David Howellsc4028952006-11-22 14:57:56 +0000209 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 struct work_struct immediate;
David Howellsc4028952006-11-22 14:57:56 +0000211 struct delayed_work deferred;
212 struct delayed_work timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 struct plip_local snd_data;
214 struct plip_local rcv_data;
215 struct pardevice *pardev;
216 unsigned long trigger;
217 unsigned long nibble;
218 enum plip_connection_state connection;
219 unsigned short timeout_count;
220 int is_deferred;
221 int port_owner;
222 int should_relinquish;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 spinlock_t lock;
224 atomic_t kill_timer;
Matthias Kaehlcke01f31ac2007-12-13 16:03:00 -0800225 struct completion killed_timer_cmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226};
Jesper Juhl77933d72005-07-27 11:46:09 -0700227
228static inline void enable_parport_interrupts (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
230 if (dev->irq != -1)
231 {
232 struct parport *port =
Wang Chen4cf16532008-11-12 23:38:14 -0800233 ((struct net_local *)netdev_priv(dev))->pardev->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 port->ops->enable_irq (port);
235 }
236}
237
Jesper Juhl77933d72005-07-27 11:46:09 -0700238static inline void disable_parport_interrupts (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
240 if (dev->irq != -1)
241 {
242 struct parport *port =
Wang Chen4cf16532008-11-12 23:38:14 -0800243 ((struct net_local *)netdev_priv(dev))->pardev->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 port->ops->disable_irq (port);
245 }
246}
247
Jesper Juhl77933d72005-07-27 11:46:09 -0700248static inline void write_data (struct net_device *dev, unsigned char data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
250 struct parport *port =
Wang Chen4cf16532008-11-12 23:38:14 -0800251 ((struct net_local *)netdev_priv(dev))->pardev->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 port->ops->write_data (port, data);
254}
255
Jesper Juhl77933d72005-07-27 11:46:09 -0700256static inline unsigned char read_status (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
258 struct parport *port =
Wang Chen4cf16532008-11-12 23:38:14 -0800259 ((struct net_local *)netdev_priv(dev))->pardev->port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 return port->ops->read_status (port);
262}
Jesper Juhl77933d72005-07-27 11:46:09 -0700263
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700264static const struct header_ops plip_header_ops = {
265 .create = plip_hard_header,
266 .cache = plip_hard_header_cache,
267};
268
Stephen Hemmingered8cf432009-01-07 17:26:48 -0800269static const struct net_device_ops plip_netdev_ops = {
270 .ndo_open = plip_open,
271 .ndo_stop = plip_close,
272 .ndo_start_xmit = plip_tx_packet,
273 .ndo_do_ioctl = plip_ioctl,
Ben Hutchings635ecaa2009-07-09 17:59:01 +0000274 .ndo_change_mtu = eth_change_mtu,
Ben Hutchings240c1022009-07-09 17:54:35 +0000275 .ndo_set_mac_address = eth_mac_addr,
276 .ndo_validate_addr = eth_validate_addr,
Stephen Hemmingered8cf432009-01-07 17:26:48 -0800277};
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279/* Entry point of PLIP driver.
280 Probe the hardware, and register/initialize the driver.
281
282 PLIP is rather weird, because of the way it interacts with the parport
283 system. It is _not_ initialised from Space.c. Instead, plip_init()
284 is called, and that function makes up a "struct net_device" for each port, and
285 then calls us here.
286
287 */
288static void
289plip_init_netdev(struct net_device *dev)
290{
291 struct net_local *nl = netdev_priv(dev);
292
293 /* Then, override parts of it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 dev->tx_queue_len = 10;
295 dev->flags = IFF_POINTOPOINT|IFF_NOARP;
296 memset(dev->dev_addr, 0xfc, ETH_ALEN);
297
Stephen Hemmingered8cf432009-01-07 17:26:48 -0800298 dev->netdev_ops = &plip_netdev_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700299 dev->header_ops = &plip_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301
302 nl->port_owner = 0;
303
304 /* Initialize constants */
305 nl->trigger = PLIP_TRIGGER_WAIT;
306 nl->nibble = PLIP_NIBBLE_WAIT;
307
308 /* Initialize task queue structures */
David Howellsc4028952006-11-22 14:57:56 +0000309 INIT_WORK(&nl->immediate, plip_bh);
310 INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
312 if (dev->irq == -1)
David Howellsc4028952006-11-22 14:57:56 +0000313 INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 spin_lock_init(&nl->lock);
316}
Jesper Juhl77933d72005-07-27 11:46:09 -0700317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318/* Bottom half handler for the delayed request.
319 This routine is kicked by do_timer().
320 Request `plip_bh' to be invoked. */
321static void
David Howellsc4028952006-11-22 14:57:56 +0000322plip_kick_bh(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
David Howellsc4028952006-11-22 14:57:56 +0000324 struct net_local *nl =
325 container_of(work, struct net_local, deferred.work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 if (nl->is_deferred)
328 schedule_work(&nl->immediate);
329}
330
331/* Forward declarations of internal routines */
332static int plip_none(struct net_device *, struct net_local *,
333 struct plip_local *, struct plip_local *);
334static int plip_receive_packet(struct net_device *, struct net_local *,
335 struct plip_local *, struct plip_local *);
336static int plip_send_packet(struct net_device *, struct net_local *,
337 struct plip_local *, struct plip_local *);
338static int plip_connection_close(struct net_device *, struct net_local *,
339 struct plip_local *, struct plip_local *);
340static int plip_error(struct net_device *, struct net_local *,
341 struct plip_local *, struct plip_local *);
342static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
343 struct plip_local *snd,
344 struct plip_local *rcv,
345 int error);
346
347#define OK 0
348#define TIMEOUT 1
349#define ERROR 2
350#define HS_TIMEOUT 3
351
352typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
353 struct plip_local *snd, struct plip_local *rcv);
354
Arjan van de Venf71e1302006-03-03 21:33:57 -0500355static const plip_func connection_state_table[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
357 plip_none,
358 plip_receive_packet,
359 plip_send_packet,
360 plip_connection_close,
361 plip_error
362};
363
364/* Bottom half handler of PLIP. */
365static void
David Howellsc4028952006-11-22 14:57:56 +0000366plip_bh(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
David Howellsc4028952006-11-22 14:57:56 +0000368 struct net_local *nl = container_of(work, struct net_local, immediate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 struct plip_local *snd = &nl->snd_data;
370 struct plip_local *rcv = &nl->rcv_data;
371 plip_func f;
372 int r;
373
374 nl->is_deferred = 0;
375 f = connection_state_table[nl->connection];
Joe Perches8e95a202009-12-03 07:58:21 +0000376 if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK &&
377 (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 nl->is_deferred = 1;
379 schedule_delayed_work(&nl->deferred, 1);
380 }
381}
382
383static void
David Howellsc4028952006-11-22 14:57:56 +0000384plip_timer_bh(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
David Howellsc4028952006-11-22 14:57:56 +0000386 struct net_local *nl =
387 container_of(work, struct net_local, timer.work);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (!(atomic_read (&nl->kill_timer))) {
Jeff Garzik5712cb32007-10-19 02:54:26 -0400390 plip_interrupt (nl->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 schedule_delayed_work(&nl->timer, 1);
393 }
394 else {
Matthias Kaehlcke01f31ac2007-12-13 16:03:00 -0800395 complete(&nl->killed_timer_cmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
397}
398
399static int
400plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
401 struct plip_local *snd, struct plip_local *rcv,
402 int error)
403{
404 unsigned char c0;
405 /*
406 * This is tricky. If we got here from the beginning of send (either
407 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
408 * already disabled. With the old variant of {enable,disable}_irq()
409 * extra disable_irq() was a no-op. Now it became mortal - it's
410 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
411 * that is). So we have to treat HS_TIMEOUT and ERROR from send
412 * in a special way.
413 */
414
415 spin_lock_irq(&nl->lock);
416 if (nl->connection == PLIP_CN_SEND) {
417
418 if (error != ERROR) { /* Timeout */
419 nl->timeout_count++;
Joe Perches8e95a202009-12-03 07:58:21 +0000420 if ((error == HS_TIMEOUT && nl->timeout_count <= 10) ||
421 nl->timeout_count <= 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 spin_unlock_irq(&nl->lock);
423 /* Try again later */
424 return TIMEOUT;
425 }
426 c0 = read_status(dev);
427 printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
428 dev->name, snd->state, c0);
429 } else
430 error = HS_TIMEOUT;
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700431 dev->stats.tx_errors++;
432 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 } else if (nl->connection == PLIP_CN_RECEIVE) {
434 if (rcv->state == PLIP_PK_TRIGGER) {
435 /* Transmission was interrupted. */
436 spin_unlock_irq(&nl->lock);
437 return OK;
438 }
439 if (error != ERROR) { /* Timeout */
440 if (++nl->timeout_count <= 3) {
441 spin_unlock_irq(&nl->lock);
442 /* Try again later */
443 return TIMEOUT;
444 }
445 c0 = read_status(dev);
446 printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
447 dev->name, rcv->state, c0);
448 }
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700449 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
451 rcv->state = PLIP_PK_DONE;
452 if (rcv->skb) {
453 kfree_skb(rcv->skb);
454 rcv->skb = NULL;
455 }
456 snd->state = PLIP_PK_DONE;
457 if (snd->skb) {
458 dev_kfree_skb(snd->skb);
459 snd->skb = NULL;
460 }
461 spin_unlock_irq(&nl->lock);
462 if (error == HS_TIMEOUT) {
463 DISABLE(dev->irq);
464 synchronize_irq(dev->irq);
465 }
466 disable_parport_interrupts (dev);
467 netif_stop_queue (dev);
468 nl->connection = PLIP_CN_ERROR;
469 write_data (dev, 0x00);
470
471 return TIMEOUT;
472}
Jesper Juhl77933d72005-07-27 11:46:09 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474static int
475plip_none(struct net_device *dev, struct net_local *nl,
476 struct plip_local *snd, struct plip_local *rcv)
477{
478 return OK;
479}
480
481/* PLIP_RECEIVE --- receive a byte(two nibbles)
482 Returns OK on success, TIMEOUT on timeout */
Jesper Juhl77933d72005-07-27 11:46:09 -0700483static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484plip_receive(unsigned short nibble_timeout, struct net_device *dev,
485 enum plip_nibble_state *ns_p, unsigned char *data_p)
486{
487 unsigned char c0, c1;
488 unsigned int cx;
489
490 switch (*ns_p) {
491 case PLIP_NB_BEGIN:
492 cx = nibble_timeout;
493 while (1) {
494 c0 = read_status(dev);
495 udelay(PLIP_DELAY_UNIT);
496 if ((c0 & 0x80) == 0) {
497 c1 = read_status(dev);
498 if (c0 == c1)
499 break;
500 }
501 if (--cx == 0)
502 return TIMEOUT;
503 }
504 *data_p = (c0 >> 3) & 0x0f;
505 write_data (dev, 0x10); /* send ACK */
506 *ns_p = PLIP_NB_1;
507
508 case PLIP_NB_1:
509 cx = nibble_timeout;
510 while (1) {
511 c0 = read_status(dev);
512 udelay(PLIP_DELAY_UNIT);
513 if (c0 & 0x80) {
514 c1 = read_status(dev);
515 if (c0 == c1)
516 break;
517 }
518 if (--cx == 0)
519 return TIMEOUT;
520 }
521 *data_p |= (c0 << 1) & 0xf0;
522 write_data (dev, 0x00); /* send ACK */
523 *ns_p = PLIP_NB_BEGIN;
524 case PLIP_NB_2:
525 break;
526 }
527 return OK;
528}
529
530/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400531 * Determine the packet's protocol ID. The rule here is that we
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 * assume 802.3 if the type field is short enough to be a length.
533 * This is normal practice and works for any 'now in use' protocol.
534 *
535 * PLIP is ethernet ish but the daddr might not be valid if unicast.
536 * PLIP fortunately has no bus architecture (its Point-to-point).
537 *
538 * We can't fix the daddr thing as that quirk (more bug) is embedded
539 * in far too many old systems not all even running Linux.
540 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400541
Alexey Dobriyanab611482005-07-12 12:08:43 -0700542static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
544 struct ethhdr *eth;
545 unsigned char *rawp;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400546
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700547 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 skb_pull(skb,dev->hard_header_len);
549 eth = eth_hdr(skb);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if(*eth->h_dest&1)
552 {
553 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
554 skb->pkt_type=PACKET_BROADCAST;
555 else
556 skb->pkt_type=PACKET_MULTICAST;
557 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400558
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 /*
560 * This ALLMULTI check should be redundant by 1.4
561 * so don't forget to remove it.
562 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 if (ntohs(eth->h_proto) >= 1536)
565 return eth->h_proto;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 rawp = skb->data;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 /*
570 * This is a magic hack to spot IPX packets. Older Novell breaks
571 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
572 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
573 * won't work for fault tolerant netware but does for the rest.
574 */
575 if (*(unsigned short *)rawp == 0xFFFF)
576 return htons(ETH_P_802_3);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400577
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 /*
579 * Real 802.2 LLC
580 */
581 return htons(ETH_P_802_2);
582}
583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584/* PLIP_RECEIVE_PACKET --- receive a packet */
585static int
586plip_receive_packet(struct net_device *dev, struct net_local *nl,
587 struct plip_local *snd, struct plip_local *rcv)
588{
589 unsigned short nibble_timeout = nl->nibble;
590 unsigned char *lbuf;
591
592 switch (rcv->state) {
593 case PLIP_PK_TRIGGER:
594 DISABLE(dev->irq);
595 /* Don't need to synchronize irq, as we can safely ignore it */
596 disable_parport_interrupts (dev);
597 write_data (dev, 0x01); /* send ACK */
598 if (net_debug > 2)
599 printk(KERN_DEBUG "%s: receive start\n", dev->name);
600 rcv->state = PLIP_PK_LENGTH_LSB;
601 rcv->nibble = PLIP_NB_BEGIN;
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
623 case PLIP_PK_LENGTH_MSB:
624 if (plip_receive(nibble_timeout, dev,
625 &rcv->nibble, &rcv->length.b.msb))
626 return TIMEOUT;
Joe Perches8e95a202009-12-03 07:58:21 +0000627 if (rcv->length.h > dev->mtu + dev->hard_header_len ||
628 rcv->length.h < 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
630 return ERROR;
631 }
632 /* Malloc up new buffer. */
633 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
634 if (rcv->skb == NULL) {
635 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
636 return ERROR;
637 }
638 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */
639 skb_put(rcv->skb,rcv->length.h);
640 rcv->skb->dev = dev;
641 rcv->state = PLIP_PK_DATA;
642 rcv->byte = 0;
643 rcv->checksum = 0;
644
645 case PLIP_PK_DATA:
646 lbuf = rcv->skb->data;
Hannes Edere4c3c132008-12-25 23:55:35 -0800647 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (plip_receive(nibble_timeout, dev,
649 &rcv->nibble, &lbuf[rcv->byte]))
650 return TIMEOUT;
Hannes Edere4c3c132008-12-25 23:55:35 -0800651 } while (++rcv->byte < rcv->length.h);
652 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 rcv->checksum += lbuf[--rcv->byte];
Hannes Edere4c3c132008-12-25 23:55:35 -0800654 } while (rcv->byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 rcv->state = PLIP_PK_CHECKSUM;
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) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700662 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (net_debug)
664 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
665 return ERROR;
666 }
667 rcv->state = PLIP_PK_DONE;
668
669 case PLIP_PK_DONE:
670 /* Inform the upper layer for the arrival of a packet. */
671 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
Mikulas Patockaf6ce5cc2007-11-22 21:19:39 +0100672 netif_rx_ni(rcv->skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700673 dev->stats.rx_bytes += rcv->length.h;
674 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 rcv->skb = NULL;
676 if (net_debug > 2)
677 printk(KERN_DEBUG "%s: receive end\n", dev->name);
678
679 /* Close the connection. */
680 write_data (dev, 0x00);
681 spin_lock_irq(&nl->lock);
682 if (snd->state != PLIP_PK_DONE) {
683 nl->connection = PLIP_CN_SEND;
684 spin_unlock_irq(&nl->lock);
685 schedule_work(&nl->immediate);
686 enable_parport_interrupts (dev);
687 ENABLE(dev->irq);
688 return OK;
689 } else {
690 nl->connection = PLIP_CN_NONE;
691 spin_unlock_irq(&nl->lock);
692 enable_parport_interrupts (dev);
693 ENABLE(dev->irq);
694 return OK;
695 }
696 }
697 return OK;
698}
699
700/* PLIP_SEND --- send a byte (two nibbles)
701 Returns OK on success, TIMEOUT when timeout */
Jesper Juhl77933d72005-07-27 11:46:09 -0700702static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703plip_send(unsigned short nibble_timeout, struct net_device *dev,
704 enum plip_nibble_state *ns_p, unsigned char data)
705{
706 unsigned char c0;
707 unsigned int cx;
708
709 switch (*ns_p) {
710 case PLIP_NB_BEGIN:
711 write_data (dev, data & 0x0f);
712 *ns_p = PLIP_NB_1;
713
714 case PLIP_NB_1:
715 write_data (dev, 0x10 | (data & 0x0f));
716 cx = nibble_timeout;
717 while (1) {
718 c0 = read_status(dev);
719 if ((c0 & 0x80) == 0)
720 break;
721 if (--cx == 0)
722 return TIMEOUT;
723 udelay(PLIP_DELAY_UNIT);
724 }
725 write_data (dev, 0x10 | (data >> 4));
726 *ns_p = PLIP_NB_2;
727
728 case PLIP_NB_2:
729 write_data (dev, (data >> 4));
730 cx = nibble_timeout;
731 while (1) {
732 c0 = read_status(dev);
733 if (c0 & 0x80)
734 break;
735 if (--cx == 0)
736 return TIMEOUT;
737 udelay(PLIP_DELAY_UNIT);
738 }
739 *ns_p = PLIP_NB_BEGIN;
740 return OK;
741 }
742 return OK;
743}
744
745/* PLIP_SEND_PACKET --- send a packet */
746static int
747plip_send_packet(struct net_device *dev, struct net_local *nl,
748 struct plip_local *snd, struct plip_local *rcv)
749{
750 unsigned short nibble_timeout = nl->nibble;
751 unsigned char *lbuf;
752 unsigned char c0;
753 unsigned int cx;
754
755 if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
756 printk(KERN_DEBUG "%s: send skb lost\n", dev->name);
757 snd->state = PLIP_PK_DONE;
758 snd->skb = NULL;
759 return ERROR;
760 }
761
762 switch (snd->state) {
763 case PLIP_PK_TRIGGER:
764 if ((read_status(dev) & 0xf8) != 0x80)
765 return HS_TIMEOUT;
766
767 /* Trigger remote rx interrupt. */
768 write_data (dev, 0x08);
769 cx = nl->trigger;
770 while (1) {
771 udelay(PLIP_DELAY_UNIT);
772 spin_lock_irq(&nl->lock);
773 if (nl->connection == PLIP_CN_RECEIVE) {
774 spin_unlock_irq(&nl->lock);
775 /* Interrupted. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700776 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 return OK;
778 }
779 c0 = read_status(dev);
780 if (c0 & 0x08) {
781 spin_unlock_irq(&nl->lock);
782 DISABLE(dev->irq);
783 synchronize_irq(dev->irq);
784 if (nl->connection == PLIP_CN_RECEIVE) {
785 /* Interrupted.
786 We don't need to enable irq,
787 as it is soon disabled. */
788 /* Yes, we do. New variant of
789 {enable,disable}_irq *counts*
790 them. -- AV */
791 ENABLE(dev->irq);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700792 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 return OK;
794 }
795 disable_parport_interrupts (dev);
796 if (net_debug > 2)
797 printk(KERN_DEBUG "%s: send start\n", dev->name);
798 snd->state = PLIP_PK_LENGTH_LSB;
799 snd->nibble = PLIP_NB_BEGIN;
800 nl->timeout_count = 0;
801 break;
802 }
803 spin_unlock_irq(&nl->lock);
804 if (--cx == 0) {
805 write_data (dev, 0x00);
806 return HS_TIMEOUT;
807 }
808 }
809
810 case PLIP_PK_LENGTH_LSB:
811 if (plip_send(nibble_timeout, dev,
812 &snd->nibble, snd->length.b.lsb))
813 return TIMEOUT;
814 snd->state = PLIP_PK_LENGTH_MSB;
815
816 case PLIP_PK_LENGTH_MSB:
817 if (plip_send(nibble_timeout, dev,
818 &snd->nibble, snd->length.b.msb))
819 return TIMEOUT;
820 snd->state = PLIP_PK_DATA;
821 snd->byte = 0;
822 snd->checksum = 0;
823
824 case PLIP_PK_DATA:
Hannes Edere4c3c132008-12-25 23:55:35 -0800825 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 if (plip_send(nibble_timeout, dev,
827 &snd->nibble, lbuf[snd->byte]))
828 return TIMEOUT;
Hannes Edere4c3c132008-12-25 23:55:35 -0800829 } while (++snd->byte < snd->length.h);
830 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 snd->checksum += lbuf[--snd->byte];
Hannes Edere4c3c132008-12-25 23:55:35 -0800832 } while (snd->byte);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 snd->state = PLIP_PK_CHECKSUM;
834
835 case PLIP_PK_CHECKSUM:
836 if (plip_send(nibble_timeout, dev,
837 &snd->nibble, snd->checksum))
838 return TIMEOUT;
839
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700840 dev->stats.tx_bytes += snd->skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 dev_kfree_skb(snd->skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700842 dev->stats.tx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 snd->state = PLIP_PK_DONE;
844
845 case PLIP_PK_DONE:
846 /* Close the connection */
847 write_data (dev, 0x00);
848 snd->skb = NULL;
849 if (net_debug > 2)
850 printk(KERN_DEBUG "%s: send end\n", dev->name);
851 nl->connection = PLIP_CN_CLOSING;
852 nl->is_deferred = 1;
853 schedule_delayed_work(&nl->deferred, 1);
854 enable_parport_interrupts (dev);
855 ENABLE(dev->irq);
856 return OK;
857 }
858 return OK;
859}
860
861static int
862plip_connection_close(struct net_device *dev, struct net_local *nl,
863 struct plip_local *snd, struct plip_local *rcv)
864{
865 spin_lock_irq(&nl->lock);
866 if (nl->connection == PLIP_CN_CLOSING) {
867 nl->connection = PLIP_CN_NONE;
868 netif_wake_queue (dev);
869 }
870 spin_unlock_irq(&nl->lock);
871 if (nl->should_relinquish) {
872 nl->should_relinquish = nl->port_owner = 0;
873 parport_release(nl->pardev);
874 }
875 return OK;
876}
877
878/* PLIP_ERROR --- wait till other end settled */
879static int
880plip_error(struct net_device *dev, struct net_local *nl,
881 struct plip_local *snd, struct plip_local *rcv)
882{
883 unsigned char status;
884
885 status = read_status(dev);
886 if ((status & 0xf8) == 0x80) {
887 if (net_debug > 2)
888 printk(KERN_DEBUG "%s: reset interface.\n", dev->name);
889 nl->connection = PLIP_CN_NONE;
890 nl->should_relinquish = 0;
891 netif_start_queue (dev);
892 enable_parport_interrupts (dev);
893 ENABLE(dev->irq);
894 netif_wake_queue (dev);
895 } else {
896 nl->is_deferred = 1;
897 schedule_delayed_work(&nl->deferred, 1);
898 }
899
900 return OK;
901}
Jesper Juhl77933d72005-07-27 11:46:09 -0700902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903/* Handle the parallel port interrupts. */
904static void
Jeff Garzik5712cb32007-10-19 02:54:26 -0400905plip_interrupt(void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906{
907 struct net_device *dev = dev_id;
908 struct net_local *nl;
909 struct plip_local *rcv;
910 unsigned char c0;
Mikulas Patockacabce282008-04-01 01:22:45 +0200911 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 nl = netdev_priv(dev);
914 rcv = &nl->rcv_data;
915
Mikulas Patockacabce282008-04-01 01:22:45 +0200916 spin_lock_irqsave (&nl->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
918 c0 = read_status(dev);
919 if ((c0 & 0xf8) != 0xc0) {
920 if ((dev->irq != -1) && (net_debug > 1))
921 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
Mikulas Patockacabce282008-04-01 01:22:45 +0200922 spin_unlock_irqrestore (&nl->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 return;
924 }
925
926 if (net_debug > 3)
927 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
928
929 switch (nl->connection) {
930 case PLIP_CN_CLOSING:
931 netif_wake_queue (dev);
932 case PLIP_CN_NONE:
933 case PLIP_CN_SEND:
934 rcv->state = PLIP_PK_TRIGGER;
935 nl->connection = PLIP_CN_RECEIVE;
936 nl->timeout_count = 0;
937 schedule_work(&nl->immediate);
938 break;
939
940 case PLIP_CN_RECEIVE:
941 /* May occur because there is race condition
942 around test and set of dev->interrupt.
943 Ignore this interrupt. */
944 break;
945
946 case PLIP_CN_ERROR:
947 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
948 break;
949 }
950
Mikulas Patockacabce282008-04-01 01:22:45 +0200951 spin_unlock_irqrestore(&nl->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
Jesper Juhl77933d72005-07-27 11:46:09 -0700953
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954static int
955plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
956{
957 struct net_local *nl = netdev_priv(dev);
958 struct plip_local *snd = &nl->snd_data;
959
960 if (netif_queue_stopped(dev))
Patrick McHardy5b548142009-06-12 06:22:29 +0000961 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962
963 /* We may need to grab the bus */
964 if (!nl->port_owner) {
965 if (parport_claim(nl->pardev))
Patrick McHardy5b548142009-06-12 06:22:29 +0000966 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 nl->port_owner = 1;
968 }
969
970 netif_stop_queue (dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 if (skb->len > dev->mtu + dev->hard_header_len) {
973 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
974 netif_start_queue (dev);
Patrick McHardy5b548142009-06-12 06:22:29 +0000975 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977
978 if (net_debug > 2)
979 printk(KERN_DEBUG "%s: send request\n", dev->name);
980
981 spin_lock_irq(&nl->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 snd->skb = skb;
983 snd->length.h = skb->len;
984 snd->state = PLIP_PK_TRIGGER;
985 if (nl->connection == PLIP_CN_NONE) {
986 nl->connection = PLIP_CN_SEND;
987 nl->timeout_count = 0;
988 }
989 schedule_work(&nl->immediate);
990 spin_unlock_irq(&nl->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400991
Patrick McHardy6ed10652009-06-23 06:03:08 +0000992 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993}
994
995static void
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700996plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997{
Eric Dumazet95ae6b22010-09-15 04:04:31 +0000998 const struct in_device *in_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001000 rcu_read_lock();
1001 in_dev = __in_dev_get_rcu(dev);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001002 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 /* Any address will do - we take the first */
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001004 const struct in_ifaddr *ifa = in_dev->ifa_list;
1005 if (ifa) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 memcpy(eth->h_source, dev->dev_addr, 6);
1007 memset(eth->h_dest, 0xfc, 2);
1008 memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1009 }
1010 }
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001011 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012}
1013
1014static int
1015plip_hard_header(struct sk_buff *skb, struct net_device *dev,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001016 unsigned short type, const void *daddr,
1017 const void *saddr, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 int ret;
1020
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001021 ret = eth_header(skb, dev, type, daddr, saddr, len);
1022 if (ret >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1024
1025 return ret;
1026}
1027
Hannes Ederdac499f2008-12-25 23:56:45 -08001028static int plip_hard_header_cache(const struct neighbour *neigh,
1029 struct hh_cache *hh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 int ret;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001032
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001033 ret = eth_header_cache(neigh, hh);
1034 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 struct ethhdr *eth;
1036
1037 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1038 HH_DATA_OFF(sizeof(*eth)));
1039 plip_rewrite_address (neigh->dev, eth);
1040 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return ret;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001043}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044
1045/* Open/initialize the board. This is called (in the current kernel)
1046 sometime after booting when the 'ifconfig' program is run.
1047
1048 This routine gets exclusive access to the parallel port by allocating
1049 its IRQ line.
1050 */
1051static int
1052plip_open(struct net_device *dev)
1053{
1054 struct net_local *nl = netdev_priv(dev);
1055 struct in_device *in_dev;
1056
1057 /* Grab the port */
1058 if (!nl->port_owner) {
1059 if (parport_claim(nl->pardev)) return -EAGAIN;
1060 nl->port_owner = 1;
1061 }
1062
1063 nl->should_relinquish = 0;
1064
1065 /* Clear the data port. */
1066 write_data (dev, 0x00);
1067
1068 /* Enable rx interrupt. */
1069 enable_parport_interrupts (dev);
1070 if (dev->irq == -1)
1071 {
1072 atomic_set (&nl->kill_timer, 0);
1073 schedule_delayed_work(&nl->timer, 1);
1074 }
1075
1076 /* Initialize the state machine. */
1077 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1078 nl->rcv_data.skb = nl->snd_data.skb = NULL;
1079 nl->connection = PLIP_CN_NONE;
1080 nl->is_deferred = 0;
1081
1082 /* Fill in the MAC-level header.
1083 We used to abuse dev->broadcast to store the point-to-point
1084 MAC address, but we no longer do it. Instead, we fetch the
1085 interface address whenever it is needed, which is cheap enough
1086 because we use the hh_cache. Actually, abusing dev->broadcast
1087 didn't work, because when using plip_open the point-to-point
1088 address isn't yet known.
1089 PLIP doesn't have a real MAC address, but we need it to be
1090 DOS compatible, and to properly support taps (otherwise,
1091 when the device address isn't identical to the address of a
1092 received frame, the kernel incorrectly drops it). */
1093
Eric Dumazet95ae6b22010-09-15 04:04:31 +00001094 in_dev=__in_dev_get_rtnl(dev);
1095 if (in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 /* Any address will do - we take the first. We already
1097 have the first two bytes filled with 0xfc, from
1098 plip_init_dev(). */
1099 struct in_ifaddr *ifa=in_dev->ifa_list;
1100 if (ifa != NULL) {
1101 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1102 }
1103 }
1104
1105 netif_start_queue (dev);
1106
1107 return 0;
1108}
1109
1110/* The inverse routine to plip_open (). */
1111static int
1112plip_close(struct net_device *dev)
1113{
1114 struct net_local *nl = netdev_priv(dev);
1115 struct plip_local *snd = &nl->snd_data;
1116 struct plip_local *rcv = &nl->rcv_data;
1117
1118 netif_stop_queue (dev);
1119 DISABLE(dev->irq);
1120 synchronize_irq(dev->irq);
1121
1122 if (dev->irq == -1)
1123 {
Matthias Kaehlcke01f31ac2007-12-13 16:03:00 -08001124 init_completion(&nl->killed_timer_cmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 atomic_set (&nl->kill_timer, 1);
Matthias Kaehlcke01f31ac2007-12-13 16:03:00 -08001126 wait_for_completion(&nl->killed_timer_cmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 }
1128
1129#ifdef NOTDEF
1130 outb(0x00, PAR_DATA(dev));
1131#endif
1132 nl->is_deferred = 0;
1133 nl->connection = PLIP_CN_NONE;
1134 if (nl->port_owner) {
1135 parport_release(nl->pardev);
1136 nl->port_owner = 0;
1137 }
1138
1139 snd->state = PLIP_PK_DONE;
1140 if (snd->skb) {
1141 dev_kfree_skb(snd->skb);
1142 snd->skb = NULL;
1143 }
1144 rcv->state = PLIP_PK_DONE;
1145 if (rcv->skb) {
1146 kfree_skb(rcv->skb);
1147 rcv->skb = NULL;
1148 }
1149
1150#ifdef NOTDEF
1151 /* Reset. */
1152 outb(0x00, PAR_CONTROL(dev));
1153#endif
1154 return 0;
1155}
1156
1157static int
1158plip_preempt(void *handle)
1159{
1160 struct net_device *dev = (struct net_device *)handle;
1161 struct net_local *nl = netdev_priv(dev);
1162
1163 /* Stand our ground if a datagram is on the wire */
1164 if (nl->connection != PLIP_CN_NONE) {
1165 nl->should_relinquish = 1;
1166 return 1;
1167 }
1168
1169 nl->port_owner = 0; /* Remember that we released the bus */
1170 return 0;
1171}
1172
1173static void
1174plip_wakeup(void *handle)
1175{
1176 struct net_device *dev = (struct net_device *)handle;
1177 struct net_local *nl = netdev_priv(dev);
1178
1179 if (nl->port_owner) {
1180 /* Why are we being woken up? */
1181 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1182 if (!parport_claim(nl->pardev))
1183 /* bus_owner is already set (but why?) */
1184 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1185 else
1186 return;
1187 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001188
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 if (!(dev->flags & IFF_UP))
1190 /* Don't need the port when the interface is down */
1191 return;
1192
1193 if (!parport_claim(nl->pardev)) {
1194 nl->port_owner = 1;
1195 /* Clear the data port. */
1196 write_data (dev, 0x00);
1197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200static int
1201plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1202{
1203 struct net_local *nl = netdev_priv(dev);
1204 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1205
1206 if (cmd != SIOCDEVPLIP)
1207 return -EOPNOTSUPP;
1208
1209 switch(pc->pcmd) {
1210 case PLIP_GET_TIMEOUT:
1211 pc->trigger = nl->trigger;
1212 pc->nibble = nl->nibble;
1213 break;
1214 case PLIP_SET_TIMEOUT:
1215 if(!capable(CAP_NET_ADMIN))
1216 return -EPERM;
1217 nl->trigger = pc->trigger;
1218 nl->nibble = pc->nibble;
1219 break;
1220 default:
1221 return -EOPNOTSUPP;
1222 }
1223 return 0;
1224}
Jesper Juhl77933d72005-07-27 11:46:09 -07001225
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1227static int timid;
1228
1229module_param_array(parport, int, NULL, 0);
1230module_param(timid, int, 0);
1231MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1232
1233static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1234
1235static inline int
1236plip_searchfor(int list[], int a)
1237{
1238 int i;
1239 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1240 if (list[i] == a) return 1;
1241 }
1242 return 0;
1243}
1244
1245/* plip_attach() is called (by the parport code) when a port is
1246 * available to use. */
1247static void plip_attach (struct parport *port)
1248{
1249 static int unit;
1250 struct net_device *dev;
1251 struct net_local *nl;
1252 char name[IFNAMSIZ];
1253
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001254 if ((parport[0] == -1 && (!timid || !port->devices)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 plip_searchfor(parport, port->number)) {
1256 if (unit == PLIP_MAX) {
1257 printk(KERN_ERR "plip: too many devices\n");
1258 return;
1259 }
1260
1261 sprintf(name, "plip%d", unit);
1262 dev = alloc_etherdev(sizeof(struct net_local));
1263 if (!dev) {
1264 printk(KERN_ERR "plip: memory squeeze\n");
1265 return;
1266 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 strcpy(dev->name, name);
1269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 dev->irq = port->irq;
1271 dev->base_addr = port->base;
1272 if (port->irq == -1) {
1273 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1274 "which is fairly inefficient!\n", port->name);
1275 }
1276
1277 nl = netdev_priv(dev);
David Howellsc4028952006-11-22 14:57:56 +00001278 nl->dev = dev;
Mikulas Patockacdb32702007-11-22 21:26:01 +01001279 nl->pardev = parport_register_device(port, dev->name, plip_preempt,
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001280 plip_wakeup, plip_interrupt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 0, dev);
1282
1283 if (!nl->pardev) {
1284 printk(KERN_ERR "%s: parport_register failed\n", name);
1285 goto err_free_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
1287
1288 plip_init_netdev(dev);
1289
1290 if (register_netdev(dev)) {
1291 printk(KERN_ERR "%s: network register failed\n", name);
1292 goto err_parport_unregister;
1293 }
1294
1295 printk(KERN_INFO "%s", version);
1296 if (dev->irq != -1)
1297 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1298 "using IRQ %d.\n",
1299 dev->name, dev->base_addr, dev->irq);
1300 else
1301 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1302 "not using IRQ.\n",
1303 dev->name, dev->base_addr);
1304 dev_plip[unit++] = dev;
1305 }
1306 return;
1307
1308err_parport_unregister:
1309 parport_unregister_device(nl->pardev);
1310err_free_dev:
1311 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312}
1313
1314/* plip_detach() is called (by the parport code) when a port is
1315 * no longer available to use. */
1316static void plip_detach (struct parport *port)
1317{
1318 /* Nothing to do */
1319}
1320
1321static struct parport_driver plip_driver = {
1322 .name = "plip",
1323 .attach = plip_attach,
1324 .detach = plip_detach
1325};
1326
1327static void __exit plip_cleanup_module (void)
1328{
1329 struct net_device *dev;
1330 int i;
1331
1332 parport_unregister_driver (&plip_driver);
1333
1334 for (i=0; i < PLIP_MAX; i++) {
1335 if ((dev = dev_plip[i])) {
1336 struct net_local *nl = netdev_priv(dev);
1337 unregister_netdev(dev);
1338 if (nl->port_owner)
1339 parport_release(nl->pardev);
1340 parport_unregister_device(nl->pardev);
1341 free_netdev(dev);
1342 dev_plip[i] = NULL;
1343 }
1344 }
1345}
1346
1347#ifndef MODULE
1348
1349static int parport_ptr;
1350
1351static int __init plip_setup(char *str)
1352{
1353 int ints[4];
1354
1355 str = get_options(str, ARRAY_SIZE(ints), ints);
1356
1357 /* Ugh. */
1358 if (!strncmp(str, "parport", 7)) {
1359 int n = simple_strtoul(str+7, NULL, 10);
1360 if (parport_ptr < PLIP_MAX)
1361 parport[parport_ptr++] = n;
1362 else
1363 printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1364 str);
1365 } else if (!strcmp(str, "timid")) {
1366 timid = 1;
1367 } else {
1368 if (ints[0] == 0 || ints[1] == 0) {
1369 /* disable driver on "plip=" or "plip=0" */
1370 parport[0] = -2;
1371 } else {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001372 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 ints[1]);
1374 }
1375 }
1376 return 1;
1377}
1378
1379__setup("plip=", plip_setup);
1380
1381#endif /* !MODULE */
1382
1383static int __init plip_init (void)
1384{
1385 if (parport[0] == -2)
1386 return 0;
1387
1388 if (parport[0] != -1 && timid) {
1389 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1390 timid = 0;
1391 }
1392
1393 if (parport_register_driver (&plip_driver)) {
1394 printk (KERN_WARNING "plip: couldn't register driver\n");
1395 return 1;
1396 }
1397
1398 return 0;
1399}
1400
1401module_init(plip_init);
1402module_exit(plip_cleanup_module);
1403MODULE_LICENSE("GPL");