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