blob: 71afb274498f5558f1c2f33334441503d43a1a19 [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>
97#include <linux/if_ether.h>
98#include <linux/in.h>
99#include <linux/errno.h>
100#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108#include <linux/spinlock.h>
109#include <linux/parport.h>
110#include <linux/bitops.h>
111
112#include <net/neighbour.h>
113
114#include <asm/system.h>
115#include <asm/irq.h>
116#include <asm/byteorder.h>
117#include <asm/semaphore.h>
118
119/* Maximum number of devices to support. */
120#define PLIP_MAX 8
121
122/* Use 0 for production, 1 for verification, >2 for debug */
123#ifndef NET_DEBUG
124#define NET_DEBUG 1
125#endif
Arjan van de Venf71e1302006-03-03 21:33:57 -0500126static const unsigned int net_debug = NET_DEBUG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128#define ENABLE(irq) if (irq != -1) enable_irq(irq)
129#define DISABLE(irq) if (irq != -1) disable_irq(irq)
130
131/* In micro second */
132#define PLIP_DELAY_UNIT 1
133
134/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
135#define PLIP_TRIGGER_WAIT 500
136
137/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
138#define PLIP_NIBBLE_WAIT 3000
139
140/* Bottom halves */
141static void plip_kick_bh(struct net_device *dev);
142static void plip_bh(struct net_device *dev);
143static void plip_timer_bh(struct net_device *dev);
144
145/* Interrupt handler */
David Howells7d12e782006-10-05 14:55:46 +0100146static void plip_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148/* Functions for DEV methods */
149static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);
150static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,
151 unsigned short type, void *daddr,
152 void *saddr, unsigned len);
153static int plip_hard_header_cache(struct neighbour *neigh,
154 struct hh_cache *hh);
155static int plip_open(struct net_device *dev);
156static int plip_close(struct net_device *dev);
157static struct net_device_stats *plip_get_stats(struct net_device *dev);
158static 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 {
209 struct net_device_stats enet_stats;
210 struct work_struct immediate;
211 struct work_struct deferred;
212 struct work_struct timer;
213 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;
223 int (*orig_hard_header)(struct sk_buff *skb, struct net_device *dev,
224 unsigned short type, void *daddr,
225 void *saddr, unsigned len);
226 int (*orig_hard_header_cache)(struct neighbour *neigh,
227 struct hh_cache *hh);
228 spinlock_t lock;
229 atomic_t kill_timer;
230 struct semaphore killed_timer_sem;
231};
Jesper Juhl77933d72005-07-27 11:46:09 -0700232
233static inline void enable_parport_interrupts (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
235 if (dev->irq != -1)
236 {
237 struct parport *port =
238 ((struct net_local *)dev->priv)->pardev->port;
239 port->ops->enable_irq (port);
240 }
241}
242
Jesper Juhl77933d72005-07-27 11:46:09 -0700243static inline void disable_parport_interrupts (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
245 if (dev->irq != -1)
246 {
247 struct parport *port =
248 ((struct net_local *)dev->priv)->pardev->port;
249 port->ops->disable_irq (port);
250 }
251}
252
Jesper Juhl77933d72005-07-27 11:46:09 -0700253static inline void write_data (struct net_device *dev, unsigned char data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
255 struct parport *port =
256 ((struct net_local *)dev->priv)->pardev->port;
257
258 port->ops->write_data (port, data);
259}
260
Jesper Juhl77933d72005-07-27 11:46:09 -0700261static inline unsigned char read_status (struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 struct parport *port =
264 ((struct net_local *)dev->priv)->pardev->port;
265
266 return port->ops->read_status (port);
267}
Jesper Juhl77933d72005-07-27 11:46:09 -0700268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269/* Entry point of PLIP driver.
270 Probe the hardware, and register/initialize the driver.
271
272 PLIP is rather weird, because of the way it interacts with the parport
273 system. It is _not_ initialised from Space.c. Instead, plip_init()
274 is called, and that function makes up a "struct net_device" for each port, and
275 then calls us here.
276
277 */
278static void
279plip_init_netdev(struct net_device *dev)
280{
281 struct net_local *nl = netdev_priv(dev);
282
283 /* Then, override parts of it */
284 dev->hard_start_xmit = plip_tx_packet;
285 dev->open = plip_open;
286 dev->stop = plip_close;
287 dev->get_stats = plip_get_stats;
288 dev->do_ioctl = plip_ioctl;
289 dev->header_cache_update = NULL;
290 dev->tx_queue_len = 10;
291 dev->flags = IFF_POINTOPOINT|IFF_NOARP;
292 memset(dev->dev_addr, 0xfc, ETH_ALEN);
293
294 /* Set the private structure */
295 nl->orig_hard_header = dev->hard_header;
296 dev->hard_header = plip_hard_header;
297
298 nl->orig_hard_header_cache = dev->hard_header_cache;
299 dev->hard_header_cache = plip_hard_header_cache;
300
301
302 nl->port_owner = 0;
303
304 /* Initialize constants */
305 nl->trigger = PLIP_TRIGGER_WAIT;
306 nl->nibble = PLIP_NIBBLE_WAIT;
307
308 /* Initialize task queue structures */
309 INIT_WORK(&nl->immediate, (void (*)(void *))plip_bh, dev);
310 INIT_WORK(&nl->deferred, (void (*)(void *))plip_kick_bh, dev);
311
312 if (dev->irq == -1)
313 INIT_WORK(&nl->timer, (void (*)(void *))plip_timer_bh, dev);
314
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
322plip_kick_bh(struct net_device *dev)
323{
324 struct net_local *nl = netdev_priv(dev);
325
326 if (nl->is_deferred)
327 schedule_work(&nl->immediate);
328}
329
330/* Forward declarations of internal routines */
331static int plip_none(struct net_device *, struct net_local *,
332 struct plip_local *, struct plip_local *);
333static int plip_receive_packet(struct net_device *, struct net_local *,
334 struct plip_local *, struct plip_local *);
335static int plip_send_packet(struct net_device *, struct net_local *,
336 struct plip_local *, struct plip_local *);
337static int plip_connection_close(struct net_device *, struct net_local *,
338 struct plip_local *, struct plip_local *);
339static int plip_error(struct net_device *, struct net_local *,
340 struct plip_local *, struct plip_local *);
341static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
342 struct plip_local *snd,
343 struct plip_local *rcv,
344 int error);
345
346#define OK 0
347#define TIMEOUT 1
348#define ERROR 2
349#define HS_TIMEOUT 3
350
351typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
352 struct plip_local *snd, struct plip_local *rcv);
353
Arjan van de Venf71e1302006-03-03 21:33:57 -0500354static const plip_func connection_state_table[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
356 plip_none,
357 plip_receive_packet,
358 plip_send_packet,
359 plip_connection_close,
360 plip_error
361};
362
363/* Bottom half handler of PLIP. */
364static void
365plip_bh(struct net_device *dev)
366{
367 struct net_local *nl = netdev_priv(dev);
368 struct plip_local *snd = &nl->snd_data;
369 struct plip_local *rcv = &nl->rcv_data;
370 plip_func f;
371 int r;
372
373 nl->is_deferred = 0;
374 f = connection_state_table[nl->connection];
375 if ((r = (*f)(dev, nl, snd, rcv)) != OK
376 && (r = plip_bh_timeout_error(dev, nl, snd, rcv, r)) != OK) {
377 nl->is_deferred = 1;
378 schedule_delayed_work(&nl->deferred, 1);
379 }
380}
381
382static void
383plip_timer_bh(struct net_device *dev)
384{
385 struct net_local *nl = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if (!(atomic_read (&nl->kill_timer))) {
David Howells7d12e782006-10-05 14:55:46 +0100388 plip_interrupt (-1, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 schedule_delayed_work(&nl->timer, 1);
391 }
392 else {
393 up (&nl->killed_timer_sem);
394 }
395}
396
397static int
398plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
399 struct plip_local *snd, struct plip_local *rcv,
400 int error)
401{
402 unsigned char c0;
403 /*
404 * This is tricky. If we got here from the beginning of send (either
405 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
406 * already disabled. With the old variant of {enable,disable}_irq()
407 * extra disable_irq() was a no-op. Now it became mortal - it's
408 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
409 * that is). So we have to treat HS_TIMEOUT and ERROR from send
410 * in a special way.
411 */
412
413 spin_lock_irq(&nl->lock);
414 if (nl->connection == PLIP_CN_SEND) {
415
416 if (error != ERROR) { /* Timeout */
417 nl->timeout_count++;
418 if ((error == HS_TIMEOUT
419 && nl->timeout_count <= 10)
420 || nl->timeout_count <= 3) {
421 spin_unlock_irq(&nl->lock);
422 /* Try again later */
423 return TIMEOUT;
424 }
425 c0 = read_status(dev);
426 printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
427 dev->name, snd->state, c0);
428 } else
429 error = HS_TIMEOUT;
430 nl->enet_stats.tx_errors++;
431 nl->enet_stats.tx_aborted_errors++;
432 } else if (nl->connection == PLIP_CN_RECEIVE) {
433 if (rcv->state == PLIP_PK_TRIGGER) {
434 /* Transmission was interrupted. */
435 spin_unlock_irq(&nl->lock);
436 return OK;
437 }
438 if (error != ERROR) { /* Timeout */
439 if (++nl->timeout_count <= 3) {
440 spin_unlock_irq(&nl->lock);
441 /* Try again later */
442 return TIMEOUT;
443 }
444 c0 = read_status(dev);
445 printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
446 dev->name, rcv->state, c0);
447 }
448 nl->enet_stats.rx_dropped++;
449 }
450 rcv->state = PLIP_PK_DONE;
451 if (rcv->skb) {
452 kfree_skb(rcv->skb);
453 rcv->skb = NULL;
454 }
455 snd->state = PLIP_PK_DONE;
456 if (snd->skb) {
457 dev_kfree_skb(snd->skb);
458 snd->skb = NULL;
459 }
460 spin_unlock_irq(&nl->lock);
461 if (error == HS_TIMEOUT) {
462 DISABLE(dev->irq);
463 synchronize_irq(dev->irq);
464 }
465 disable_parport_interrupts (dev);
466 netif_stop_queue (dev);
467 nl->connection = PLIP_CN_ERROR;
468 write_data (dev, 0x00);
469
470 return TIMEOUT;
471}
Jesper Juhl77933d72005-07-27 11:46:09 -0700472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473static int
474plip_none(struct net_device *dev, struct net_local *nl,
475 struct plip_local *snd, struct plip_local *rcv)
476{
477 return OK;
478}
479
480/* PLIP_RECEIVE --- receive a byte(two nibbles)
481 Returns OK on success, TIMEOUT on timeout */
Jesper Juhl77933d72005-07-27 11:46:09 -0700482static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483plip_receive(unsigned short nibble_timeout, struct net_device *dev,
484 enum plip_nibble_state *ns_p, unsigned char *data_p)
485{
486 unsigned char c0, c1;
487 unsigned int cx;
488
489 switch (*ns_p) {
490 case PLIP_NB_BEGIN:
491 cx = nibble_timeout;
492 while (1) {
493 c0 = read_status(dev);
494 udelay(PLIP_DELAY_UNIT);
495 if ((c0 & 0x80) == 0) {
496 c1 = read_status(dev);
497 if (c0 == c1)
498 break;
499 }
500 if (--cx == 0)
501 return TIMEOUT;
502 }
503 *data_p = (c0 >> 3) & 0x0f;
504 write_data (dev, 0x10); /* send ACK */
505 *ns_p = PLIP_NB_1;
506
507 case PLIP_NB_1:
508 cx = nibble_timeout;
509 while (1) {
510 c0 = read_status(dev);
511 udelay(PLIP_DELAY_UNIT);
512 if (c0 & 0x80) {
513 c1 = read_status(dev);
514 if (c0 == c1)
515 break;
516 }
517 if (--cx == 0)
518 return TIMEOUT;
519 }
520 *data_p |= (c0 << 1) & 0xf0;
521 write_data (dev, 0x00); /* send ACK */
522 *ns_p = PLIP_NB_BEGIN;
523 case PLIP_NB_2:
524 break;
525 }
526 return OK;
527}
528
529/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400530 * Determine the packet's protocol ID. The rule here is that we
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 * assume 802.3 if the type field is short enough to be a length.
532 * This is normal practice and works for any 'now in use' protocol.
533 *
534 * PLIP is ethernet ish but the daddr might not be valid if unicast.
535 * PLIP fortunately has no bus architecture (its Point-to-point).
536 *
537 * We can't fix the daddr thing as that quirk (more bug) is embedded
538 * in far too many old systems not all even running Linux.
539 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400540
Alexey Dobriyanab611482005-07-12 12:08:43 -0700541static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
543 struct ethhdr *eth;
544 unsigned char *rawp;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 skb->mac.raw=skb->data;
547 skb_pull(skb,dev->hard_header_len);
548 eth = eth_hdr(skb);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if(*eth->h_dest&1)
551 {
552 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
553 skb->pkt_type=PACKET_BROADCAST;
554 else
555 skb->pkt_type=PACKET_MULTICAST;
556 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400557
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 /*
559 * This ALLMULTI check should be redundant by 1.4
560 * so don't forget to remove it.
561 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400562
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (ntohs(eth->h_proto) >= 1536)
564 return eth->h_proto;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 rawp = skb->data;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 /*
569 * This is a magic hack to spot IPX packets. Older Novell breaks
570 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
571 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
572 * won't work for fault tolerant netware but does for the rest.
573 */
574 if (*(unsigned short *)rawp == 0xFFFF)
575 return htons(ETH_P_802_3);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 /*
578 * Real 802.2 LLC
579 */
580 return htons(ETH_P_802_2);
581}
582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583/* PLIP_RECEIVE_PACKET --- receive a packet */
584static int
585plip_receive_packet(struct net_device *dev, struct net_local *nl,
586 struct plip_local *snd, struct plip_local *rcv)
587{
588 unsigned short nibble_timeout = nl->nibble;
589 unsigned char *lbuf;
590
591 switch (rcv->state) {
592 case PLIP_PK_TRIGGER:
593 DISABLE(dev->irq);
594 /* Don't need to synchronize irq, as we can safely ignore it */
595 disable_parport_interrupts (dev);
596 write_data (dev, 0x01); /* send ACK */
597 if (net_debug > 2)
598 printk(KERN_DEBUG "%s: receive start\n", dev->name);
599 rcv->state = PLIP_PK_LENGTH_LSB;
600 rcv->nibble = PLIP_NB_BEGIN;
601
602 case PLIP_PK_LENGTH_LSB:
603 if (snd->state != PLIP_PK_DONE) {
604 if (plip_receive(nl->trigger, dev,
605 &rcv->nibble, &rcv->length.b.lsb)) {
606 /* collision, here dev->tbusy == 1 */
607 rcv->state = PLIP_PK_DONE;
608 nl->is_deferred = 1;
609 nl->connection = PLIP_CN_SEND;
610 schedule_delayed_work(&nl->deferred, 1);
611 enable_parport_interrupts (dev);
612 ENABLE(dev->irq);
613 return OK;
614 }
615 } else {
616 if (plip_receive(nibble_timeout, dev,
617 &rcv->nibble, &rcv->length.b.lsb))
618 return TIMEOUT;
619 }
620 rcv->state = PLIP_PK_LENGTH_MSB;
621
622 case PLIP_PK_LENGTH_MSB:
623 if (plip_receive(nibble_timeout, dev,
624 &rcv->nibble, &rcv->length.b.msb))
625 return TIMEOUT;
626 if (rcv->length.h > dev->mtu + dev->hard_header_len
627 || rcv->length.h < 8) {
628 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
629 return ERROR;
630 }
631 /* Malloc up new buffer. */
632 rcv->skb = dev_alloc_skb(rcv->length.h + 2);
633 if (rcv->skb == NULL) {
634 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
635 return ERROR;
636 }
637 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */
638 skb_put(rcv->skb,rcv->length.h);
639 rcv->skb->dev = dev;
640 rcv->state = PLIP_PK_DATA;
641 rcv->byte = 0;
642 rcv->checksum = 0;
643
644 case PLIP_PK_DATA:
645 lbuf = rcv->skb->data;
646 do
647 if (plip_receive(nibble_timeout, dev,
648 &rcv->nibble, &lbuf[rcv->byte]))
649 return TIMEOUT;
650 while (++rcv->byte < rcv->length.h);
651 do
652 rcv->checksum += lbuf[--rcv->byte];
653 while (rcv->byte);
654 rcv->state = PLIP_PK_CHECKSUM;
655
656 case PLIP_PK_CHECKSUM:
657 if (plip_receive(nibble_timeout, dev,
658 &rcv->nibble, &rcv->data))
659 return TIMEOUT;
660 if (rcv->data != rcv->checksum) {
661 nl->enet_stats.rx_crc_errors++;
662 if (net_debug)
663 printk(KERN_DEBUG "%s: checksum error\n", dev->name);
664 return ERROR;
665 }
666 rcv->state = PLIP_PK_DONE;
667
668 case PLIP_PK_DONE:
669 /* Inform the upper layer for the arrival of a packet. */
670 rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
671 netif_rx(rcv->skb);
672 dev->last_rx = jiffies;
673 nl->enet_stats.rx_bytes += rcv->length.h;
674 nl->enet_stats.rx_packets++;
675 rcv->skb = NULL;
676 if (net_debug > 2)
677 printk(KERN_DEBUG "%s: receive end\n", dev->name);
678
679 /* Close the connection. */
680 write_data (dev, 0x00);
681 spin_lock_irq(&nl->lock);
682 if (snd->state != PLIP_PK_DONE) {
683 nl->connection = PLIP_CN_SEND;
684 spin_unlock_irq(&nl->lock);
685 schedule_work(&nl->immediate);
686 enable_parport_interrupts (dev);
687 ENABLE(dev->irq);
688 return OK;
689 } else {
690 nl->connection = PLIP_CN_NONE;
691 spin_unlock_irq(&nl->lock);
692 enable_parport_interrupts (dev);
693 ENABLE(dev->irq);
694 return OK;
695 }
696 }
697 return OK;
698}
699
700/* PLIP_SEND --- send a byte (two nibbles)
701 Returns OK on success, TIMEOUT when timeout */
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. */
776 nl->enet_stats.collisions++;
777 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);
792 nl->enet_stats.collisions++;
793 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:
825 do
826 if (plip_send(nibble_timeout, dev,
827 &snd->nibble, lbuf[snd->byte]))
828 return TIMEOUT;
829 while (++snd->byte < snd->length.h);
830 do
831 snd->checksum += lbuf[--snd->byte];
832 while (snd->byte);
833 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
840 nl->enet_stats.tx_bytes += snd->skb->len;
841 dev_kfree_skb(snd->skb);
842 nl->enet_stats.tx_packets++;
843 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
David Howells7d12e782006-10-05 14:55:46 +0100905plip_interrupt(int irq, 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;
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 nl = netdev_priv(dev);
913 rcv = &nl->rcv_data;
914
915 spin_lock_irq (&nl->lock);
916
917 c0 = read_status(dev);
918 if ((c0 & 0xf8) != 0xc0) {
919 if ((dev->irq != -1) && (net_debug > 1))
920 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
921 spin_unlock_irq (&nl->lock);
922 return;
923 }
924
925 if (net_debug > 3)
926 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
927
928 switch (nl->connection) {
929 case PLIP_CN_CLOSING:
930 netif_wake_queue (dev);
931 case PLIP_CN_NONE:
932 case PLIP_CN_SEND:
933 rcv->state = PLIP_PK_TRIGGER;
934 nl->connection = PLIP_CN_RECEIVE;
935 nl->timeout_count = 0;
936 schedule_work(&nl->immediate);
937 break;
938
939 case PLIP_CN_RECEIVE:
940 /* May occur because there is race condition
941 around test and set of dev->interrupt.
942 Ignore this interrupt. */
943 break;
944
945 case PLIP_CN_ERROR:
946 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
947 break;
948 }
949
950 spin_unlock_irq(&nl->lock);
951}
Jesper Juhl77933d72005-07-27 11:46:09 -0700952
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953static int
954plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
955{
956 struct net_local *nl = netdev_priv(dev);
957 struct plip_local *snd = &nl->snd_data;
958
959 if (netif_queue_stopped(dev))
960 return 1;
961
962 /* We may need to grab the bus */
963 if (!nl->port_owner) {
964 if (parport_claim(nl->pardev))
965 return 1;
966 nl->port_owner = 1;
967 }
968
969 netif_stop_queue (dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 if (skb->len > dev->mtu + dev->hard_header_len) {
972 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
973 netif_start_queue (dev);
974 return 1;
975 }
976
977 if (net_debug > 2)
978 printk(KERN_DEBUG "%s: send request\n", dev->name);
979
980 spin_lock_irq(&nl->lock);
981 dev->trans_start = jiffies;
982 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 return 0;
993}
994
995static void
996plip_rewrite_address(struct net_device *dev, struct ethhdr *eth)
997{
998 struct in_device *in_dev;
999
1000 if ((in_dev=dev->ip_ptr) != NULL) {
1001 /* Any address will do - we take the first */
1002 struct in_ifaddr *ifa=in_dev->ifa_list;
1003 if (ifa != NULL) {
1004 memcpy(eth->h_source, dev->dev_addr, 6);
1005 memset(eth->h_dest, 0xfc, 2);
1006 memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1007 }
1008 }
1009}
1010
1011static int
1012plip_hard_header(struct sk_buff *skb, struct net_device *dev,
1013 unsigned short type, void *daddr,
1014 void *saddr, unsigned len)
1015{
1016 struct net_local *nl = netdev_priv(dev);
1017 int ret;
1018
1019 if ((ret = nl->orig_hard_header(skb, dev, type, daddr, saddr, len)) >= 0)
1020 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1021
1022 return ret;
1023}
1024
1025int plip_hard_header_cache(struct neighbour *neigh,
1026 struct hh_cache *hh)
1027{
1028 struct net_local *nl = neigh->dev->priv;
1029 int ret;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if ((ret = nl->orig_hard_header_cache(neigh, hh)) == 0)
1032 {
1033 struct ethhdr *eth;
1034
1035 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1036 HH_DATA_OFF(sizeof(*eth)));
1037 plip_rewrite_address (neigh->dev, eth);
1038 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001039
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return ret;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001041}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042
1043/* Open/initialize the board. This is called (in the current kernel)
1044 sometime after booting when the 'ifconfig' program is run.
1045
1046 This routine gets exclusive access to the parallel port by allocating
1047 its IRQ line.
1048 */
1049static int
1050plip_open(struct net_device *dev)
1051{
1052 struct net_local *nl = netdev_priv(dev);
1053 struct in_device *in_dev;
1054
1055 /* Grab the port */
1056 if (!nl->port_owner) {
1057 if (parport_claim(nl->pardev)) return -EAGAIN;
1058 nl->port_owner = 1;
1059 }
1060
1061 nl->should_relinquish = 0;
1062
1063 /* Clear the data port. */
1064 write_data (dev, 0x00);
1065
1066 /* Enable rx interrupt. */
1067 enable_parport_interrupts (dev);
1068 if (dev->irq == -1)
1069 {
1070 atomic_set (&nl->kill_timer, 0);
1071 schedule_delayed_work(&nl->timer, 1);
1072 }
1073
1074 /* Initialize the state machine. */
1075 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1076 nl->rcv_data.skb = nl->snd_data.skb = NULL;
1077 nl->connection = PLIP_CN_NONE;
1078 nl->is_deferred = 0;
1079
1080 /* Fill in the MAC-level header.
1081 We used to abuse dev->broadcast to store the point-to-point
1082 MAC address, but we no longer do it. Instead, we fetch the
1083 interface address whenever it is needed, which is cheap enough
1084 because we use the hh_cache. Actually, abusing dev->broadcast
1085 didn't work, because when using plip_open the point-to-point
1086 address isn't yet known.
1087 PLIP doesn't have a real MAC address, but we need it to be
1088 DOS compatible, and to properly support taps (otherwise,
1089 when the device address isn't identical to the address of a
1090 received frame, the kernel incorrectly drops it). */
1091
1092 if ((in_dev=dev->ip_ptr) != NULL) {
1093 /* Any address will do - we take the first. We already
1094 have the first two bytes filled with 0xfc, from
1095 plip_init_dev(). */
1096 struct in_ifaddr *ifa=in_dev->ifa_list;
1097 if (ifa != NULL) {
1098 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1099 }
1100 }
1101
1102 netif_start_queue (dev);
1103
1104 return 0;
1105}
1106
1107/* The inverse routine to plip_open (). */
1108static int
1109plip_close(struct net_device *dev)
1110{
1111 struct net_local *nl = netdev_priv(dev);
1112 struct plip_local *snd = &nl->snd_data;
1113 struct plip_local *rcv = &nl->rcv_data;
1114
1115 netif_stop_queue (dev);
1116 DISABLE(dev->irq);
1117 synchronize_irq(dev->irq);
1118
1119 if (dev->irq == -1)
1120 {
1121 init_MUTEX_LOCKED (&nl->killed_timer_sem);
1122 atomic_set (&nl->kill_timer, 1);
1123 down (&nl->killed_timer_sem);
1124 }
1125
1126#ifdef NOTDEF
1127 outb(0x00, PAR_DATA(dev));
1128#endif
1129 nl->is_deferred = 0;
1130 nl->connection = PLIP_CN_NONE;
1131 if (nl->port_owner) {
1132 parport_release(nl->pardev);
1133 nl->port_owner = 0;
1134 }
1135
1136 snd->state = PLIP_PK_DONE;
1137 if (snd->skb) {
1138 dev_kfree_skb(snd->skb);
1139 snd->skb = NULL;
1140 }
1141 rcv->state = PLIP_PK_DONE;
1142 if (rcv->skb) {
1143 kfree_skb(rcv->skb);
1144 rcv->skb = NULL;
1145 }
1146
1147#ifdef NOTDEF
1148 /* Reset. */
1149 outb(0x00, PAR_CONTROL(dev));
1150#endif
1151 return 0;
1152}
1153
1154static int
1155plip_preempt(void *handle)
1156{
1157 struct net_device *dev = (struct net_device *)handle;
1158 struct net_local *nl = netdev_priv(dev);
1159
1160 /* Stand our ground if a datagram is on the wire */
1161 if (nl->connection != PLIP_CN_NONE) {
1162 nl->should_relinquish = 1;
1163 return 1;
1164 }
1165
1166 nl->port_owner = 0; /* Remember that we released the bus */
1167 return 0;
1168}
1169
1170static void
1171plip_wakeup(void *handle)
1172{
1173 struct net_device *dev = (struct net_device *)handle;
1174 struct net_local *nl = netdev_priv(dev);
1175
1176 if (nl->port_owner) {
1177 /* Why are we being woken up? */
1178 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1179 if (!parport_claim(nl->pardev))
1180 /* bus_owner is already set (but why?) */
1181 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1182 else
1183 return;
1184 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if (!(dev->flags & IFF_UP))
1187 /* Don't need the port when the interface is down */
1188 return;
1189
1190 if (!parport_claim(nl->pardev)) {
1191 nl->port_owner = 1;
1192 /* Clear the data port. */
1193 write_data (dev, 0x00);
1194 }
1195
1196 return;
1197}
1198
1199static struct net_device_stats *
1200plip_get_stats(struct net_device *dev)
1201{
1202 struct net_local *nl = netdev_priv(dev);
1203 struct net_device_stats *r = &nl->enet_stats;
1204
1205 return r;
1206}
1207
1208static int
1209plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1210{
1211 struct net_local *nl = netdev_priv(dev);
1212 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1213
1214 if (cmd != SIOCDEVPLIP)
1215 return -EOPNOTSUPP;
1216
1217 switch(pc->pcmd) {
1218 case PLIP_GET_TIMEOUT:
1219 pc->trigger = nl->trigger;
1220 pc->nibble = nl->nibble;
1221 break;
1222 case PLIP_SET_TIMEOUT:
1223 if(!capable(CAP_NET_ADMIN))
1224 return -EPERM;
1225 nl->trigger = pc->trigger;
1226 nl->nibble = pc->nibble;
1227 break;
1228 default:
1229 return -EOPNOTSUPP;
1230 }
1231 return 0;
1232}
Jesper Juhl77933d72005-07-27 11:46:09 -07001233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1235static int timid;
1236
1237module_param_array(parport, int, NULL, 0);
1238module_param(timid, int, 0);
1239MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1240
1241static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1242
1243static inline int
1244plip_searchfor(int list[], int a)
1245{
1246 int i;
1247 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1248 if (list[i] == a) return 1;
1249 }
1250 return 0;
1251}
1252
1253/* plip_attach() is called (by the parport code) when a port is
1254 * available to use. */
1255static void plip_attach (struct parport *port)
1256{
1257 static int unit;
1258 struct net_device *dev;
1259 struct net_local *nl;
1260 char name[IFNAMSIZ];
1261
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001262 if ((parport[0] == -1 && (!timid || !port->devices)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 plip_searchfor(parport, port->number)) {
1264 if (unit == PLIP_MAX) {
1265 printk(KERN_ERR "plip: too many devices\n");
1266 return;
1267 }
1268
1269 sprintf(name, "plip%d", unit);
1270 dev = alloc_etherdev(sizeof(struct net_local));
1271 if (!dev) {
1272 printk(KERN_ERR "plip: memory squeeze\n");
1273 return;
1274 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001275
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 strcpy(dev->name, name);
1277
1278 SET_MODULE_OWNER(dev);
1279 dev->irq = port->irq;
1280 dev->base_addr = port->base;
1281 if (port->irq == -1) {
1282 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1283 "which is fairly inefficient!\n", port->name);
1284 }
1285
1286 nl = netdev_priv(dev);
1287 nl->pardev = parport_register_device(port, name, plip_preempt,
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001288 plip_wakeup, plip_interrupt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 0, dev);
1290
1291 if (!nl->pardev) {
1292 printk(KERN_ERR "%s: parport_register failed\n", name);
1293 goto err_free_dev;
1294 return;
1295 }
1296
1297 plip_init_netdev(dev);
1298
1299 if (register_netdev(dev)) {
1300 printk(KERN_ERR "%s: network register failed\n", name);
1301 goto err_parport_unregister;
1302 }
1303
1304 printk(KERN_INFO "%s", version);
1305 if (dev->irq != -1)
1306 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1307 "using IRQ %d.\n",
1308 dev->name, dev->base_addr, dev->irq);
1309 else
1310 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1311 "not using IRQ.\n",
1312 dev->name, dev->base_addr);
1313 dev_plip[unit++] = dev;
1314 }
1315 return;
1316
1317err_parport_unregister:
1318 parport_unregister_device(nl->pardev);
1319err_free_dev:
1320 free_netdev(dev);
1321 return;
1322}
1323
1324/* plip_detach() is called (by the parport code) when a port is
1325 * no longer available to use. */
1326static void plip_detach (struct parport *port)
1327{
1328 /* Nothing to do */
1329}
1330
1331static struct parport_driver plip_driver = {
1332 .name = "plip",
1333 .attach = plip_attach,
1334 .detach = plip_detach
1335};
1336
1337static void __exit plip_cleanup_module (void)
1338{
1339 struct net_device *dev;
1340 int i;
1341
1342 parport_unregister_driver (&plip_driver);
1343
1344 for (i=0; i < PLIP_MAX; i++) {
1345 if ((dev = dev_plip[i])) {
1346 struct net_local *nl = netdev_priv(dev);
1347 unregister_netdev(dev);
1348 if (nl->port_owner)
1349 parport_release(nl->pardev);
1350 parport_unregister_device(nl->pardev);
1351 free_netdev(dev);
1352 dev_plip[i] = NULL;
1353 }
1354 }
1355}
1356
1357#ifndef MODULE
1358
1359static int parport_ptr;
1360
1361static int __init plip_setup(char *str)
1362{
1363 int ints[4];
1364
1365 str = get_options(str, ARRAY_SIZE(ints), ints);
1366
1367 /* Ugh. */
1368 if (!strncmp(str, "parport", 7)) {
1369 int n = simple_strtoul(str+7, NULL, 10);
1370 if (parport_ptr < PLIP_MAX)
1371 parport[parport_ptr++] = n;
1372 else
1373 printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1374 str);
1375 } else if (!strcmp(str, "timid")) {
1376 timid = 1;
1377 } else {
1378 if (ints[0] == 0 || ints[1] == 0) {
1379 /* disable driver on "plip=" or "plip=0" */
1380 parport[0] = -2;
1381 } else {
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001382 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 ints[1]);
1384 }
1385 }
1386 return 1;
1387}
1388
1389__setup("plip=", plip_setup);
1390
1391#endif /* !MODULE */
1392
1393static int __init plip_init (void)
1394{
1395 if (parport[0] == -2)
1396 return 0;
1397
1398 if (parport[0] != -1 && timid) {
1399 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1400 timid = 0;
1401 }
1402
1403 if (parport_register_driver (&plip_driver)) {
1404 printk (KERN_WARNING "plip: couldn't register driver\n");
1405 return 1;
1406 }
1407
1408 return 0;
1409}
1410
1411module_init(plip_init);
1412module_exit(plip_cleanup_module);
1413MODULE_LICENSE("GPL");
1414
1415/*
1416 * Local variables:
1417 * compile-command: "gcc -DMODULE -DMODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -c plip.c"
1418 * End:
1419 */