ia64/linux-2.6.18-xen.hg

view drivers/net/plip.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
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 */
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 */
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";
59 /*
60 Sources:
61 Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
62 "parallel.asm" parallel port packet driver.
64 The "Crynwr" parallel port standard specifies the following protocol:
65 Trigger by sending nibble '0x8' (this causes interrupt on other end)
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)>
73 The packet is encapsulated as if it were ethernet.
75 The cable used is a de facto standard parallel null cable -- sold as
76 a "LapLink" cable by various places. You'll need a 12-conductor cable to
77 make one yourself. The wiring is:
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 */
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/init.h>
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/inetdevice.h>
105 #include <linux/skbuff.h>
106 #include <linux/if_plip.h>
107 #include <linux/workqueue.h>
108 #include <linux/spinlock.h>
109 #include <linux/parport.h>
110 #include <linux/bitops.h>
112 #include <net/neighbour.h>
114 #include <asm/system.h>
115 #include <asm/irq.h>
116 #include <asm/byteorder.h>
117 #include <asm/semaphore.h>
119 /* Maximum number of devices to support. */
120 #define PLIP_MAX 8
122 /* Use 0 for production, 1 for verification, >2 for debug */
123 #ifndef NET_DEBUG
124 #define NET_DEBUG 1
125 #endif
126 static const unsigned int net_debug = NET_DEBUG;
128 #define ENABLE(irq) if (irq != -1) enable_irq(irq)
129 #define DISABLE(irq) if (irq != -1) disable_irq(irq)
131 /* In micro second */
132 #define PLIP_DELAY_UNIT 1
134 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
135 #define PLIP_TRIGGER_WAIT 500
137 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
138 #define PLIP_NIBBLE_WAIT 3000
140 /* Bottom halves */
141 static void plip_kick_bh(struct net_device *dev);
142 static void plip_bh(struct net_device *dev);
143 static void plip_timer_bh(struct net_device *dev);
145 /* Interrupt handler */
146 static void plip_interrupt(int irq, void *dev_id, struct pt_regs *regs);
148 /* Functions for DEV methods */
149 static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);
150 static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,
151 unsigned short type, void *daddr,
152 void *saddr, unsigned len);
153 static int plip_hard_header_cache(struct neighbour *neigh,
154 struct hh_cache *hh);
155 static int plip_open(struct net_device *dev);
156 static int plip_close(struct net_device *dev);
157 static struct net_device_stats *plip_get_stats(struct net_device *dev);
158 static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
159 static int plip_preempt(void *handle);
160 static void plip_wakeup(void *handle);
162 enum 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 };
170 enum 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 };
179 enum plip_nibble_state {
180 PLIP_NB_BEGIN,
181 PLIP_NB_1,
182 PLIP_NB_2,
183 };
185 struct 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 };
208 struct 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 };
233 static inline void enable_parport_interrupts (struct net_device *dev)
234 {
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 }
243 static inline void disable_parport_interrupts (struct net_device *dev)
244 {
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 }
253 static inline void write_data (struct net_device *dev, unsigned char data)
254 {
255 struct parport *port =
256 ((struct net_local *)dev->priv)->pardev->port;
258 port->ops->write_data (port, data);
259 }
261 static inline unsigned char read_status (struct net_device *dev)
262 {
263 struct parport *port =
264 ((struct net_local *)dev->priv)->pardev->port;
266 return port->ops->read_status (port);
267 }
269 /* Entry point of PLIP driver.
270 Probe the hardware, and register/initialize the driver.
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.
277 */
278 static void
279 plip_init_netdev(struct net_device *dev)
280 {
281 struct net_local *nl = netdev_priv(dev);
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);
294 /* Set the private structure */
295 nl->orig_hard_header = dev->hard_header;
296 dev->hard_header = plip_hard_header;
298 nl->orig_hard_header_cache = dev->hard_header_cache;
299 dev->hard_header_cache = plip_hard_header_cache;
302 nl->port_owner = 0;
304 /* Initialize constants */
305 nl->trigger = PLIP_TRIGGER_WAIT;
306 nl->nibble = PLIP_NIBBLE_WAIT;
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);
312 if (dev->irq == -1)
313 INIT_WORK(&nl->timer, (void (*)(void *))plip_timer_bh, dev);
315 spin_lock_init(&nl->lock);
316 }
318 /* Bottom half handler for the delayed request.
319 This routine is kicked by do_timer().
320 Request `plip_bh' to be invoked. */
321 static void
322 plip_kick_bh(struct net_device *dev)
323 {
324 struct net_local *nl = netdev_priv(dev);
326 if (nl->is_deferred)
327 schedule_work(&nl->immediate);
328 }
330 /* Forward declarations of internal routines */
331 static int plip_none(struct net_device *, struct net_local *,
332 struct plip_local *, struct plip_local *);
333 static int plip_receive_packet(struct net_device *, struct net_local *,
334 struct plip_local *, struct plip_local *);
335 static int plip_send_packet(struct net_device *, struct net_local *,
336 struct plip_local *, struct plip_local *);
337 static int plip_connection_close(struct net_device *, struct net_local *,
338 struct plip_local *, struct plip_local *);
339 static int plip_error(struct net_device *, struct net_local *,
340 struct plip_local *, struct plip_local *);
341 static 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);
346 #define OK 0
347 #define TIMEOUT 1
348 #define ERROR 2
349 #define HS_TIMEOUT 3
351 typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,
352 struct plip_local *snd, struct plip_local *rcv);
354 static const plip_func connection_state_table[] =
355 {
356 plip_none,
357 plip_receive_packet,
358 plip_send_packet,
359 plip_connection_close,
360 plip_error
361 };
363 /* Bottom half handler of PLIP. */
364 static void
365 plip_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;
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 }
382 static void
383 plip_timer_bh(struct net_device *dev)
384 {
385 struct net_local *nl = netdev_priv(dev);
387 if (!(atomic_read (&nl->kill_timer))) {
388 plip_interrupt (-1, dev, NULL);
390 schedule_delayed_work(&nl->timer, 1);
391 }
392 else {
393 up (&nl->killed_timer_sem);
394 }
395 }
397 static int
398 plip_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 */
413 spin_lock_irq(&nl->lock);
414 if (nl->connection == PLIP_CN_SEND) {
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);
470 return TIMEOUT;
471 }
473 static int
474 plip_none(struct net_device *dev, struct net_local *nl,
475 struct plip_local *snd, struct plip_local *rcv)
476 {
477 return OK;
478 }
480 /* PLIP_RECEIVE --- receive a byte(two nibbles)
481 Returns OK on success, TIMEOUT on timeout */
482 static inline int
483 plip_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;
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;
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 }
529 /*
530 * Determine the packet's protocol ID. The rule here is that we
531 * 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 */
541 static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
542 {
543 struct ethhdr *eth;
544 unsigned char *rawp;
546 skb->mac.raw=skb->data;
547 skb_pull(skb,dev->hard_header_len);
548 eth = eth_hdr(skb);
550 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 }
558 /*
559 * This ALLMULTI check should be redundant by 1.4
560 * so don't forget to remove it.
561 */
563 if (ntohs(eth->h_proto) >= 1536)
564 return eth->h_proto;
566 rawp = skb->data;
568 /*
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);
577 /*
578 * Real 802.2 LLC
579 */
580 return htons(ETH_P_802_2);
581 }
583 /* PLIP_RECEIVE_PACKET --- receive a packet */
584 static int
585 plip_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;
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;
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;
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;
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;
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;
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);
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 }
700 /* PLIP_SEND --- send a byte (two nibbles)
701 Returns OK on success, TIMEOUT when timeout */
702 static inline int
703 plip_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;
709 switch (*ns_p) {
710 case PLIP_NB_BEGIN:
711 write_data (dev, data & 0x0f);
712 *ns_p = PLIP_NB_1;
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;
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 }
745 /* PLIP_SEND_PACKET --- send a packet */
746 static int
747 plip_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;
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 }
762 switch (snd->state) {
763 case PLIP_PK_TRIGGER:
764 if ((read_status(dev) & 0xf8) != 0x80)
765 return HS_TIMEOUT;
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 }
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;
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;
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;
835 case PLIP_PK_CHECKSUM:
836 if (plip_send(nibble_timeout, dev,
837 &snd->nibble, snd->checksum))
838 return TIMEOUT;
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;
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 }
861 static int
862 plip_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 }
878 /* PLIP_ERROR --- wait till other end settled */
879 static int
880 plip_error(struct net_device *dev, struct net_local *nl,
881 struct plip_local *snd, struct plip_local *rcv)
882 {
883 unsigned char status;
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 }
900 return OK;
901 }
903 /* Handle the parallel port interrupts. */
904 static void
905 plip_interrupt(int irq, void *dev_id, struct pt_regs * regs)
906 {
907 struct net_device *dev = dev_id;
908 struct net_local *nl;
909 struct plip_local *rcv;
910 unsigned char c0;
912 if (dev == NULL) {
913 printk(KERN_DEBUG "plip_interrupt: irq %d for unknown device.\n", irq);
914 return;
915 }
917 nl = netdev_priv(dev);
918 rcv = &nl->rcv_data;
920 spin_lock_irq (&nl->lock);
922 c0 = read_status(dev);
923 if ((c0 & 0xf8) != 0xc0) {
924 if ((dev->irq != -1) && (net_debug > 1))
925 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
926 spin_unlock_irq (&nl->lock);
927 return;
928 }
930 if (net_debug > 3)
931 printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
933 switch (nl->connection) {
934 case PLIP_CN_CLOSING:
935 netif_wake_queue (dev);
936 case PLIP_CN_NONE:
937 case PLIP_CN_SEND:
938 rcv->state = PLIP_PK_TRIGGER;
939 nl->connection = PLIP_CN_RECEIVE;
940 nl->timeout_count = 0;
941 schedule_work(&nl->immediate);
942 break;
944 case PLIP_CN_RECEIVE:
945 /* May occur because there is race condition
946 around test and set of dev->interrupt.
947 Ignore this interrupt. */
948 break;
950 case PLIP_CN_ERROR:
951 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
952 break;
953 }
955 spin_unlock_irq(&nl->lock);
956 }
958 static int
959 plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
960 {
961 struct net_local *nl = netdev_priv(dev);
962 struct plip_local *snd = &nl->snd_data;
964 if (netif_queue_stopped(dev))
965 return 1;
967 /* We may need to grab the bus */
968 if (!nl->port_owner) {
969 if (parport_claim(nl->pardev))
970 return 1;
971 nl->port_owner = 1;
972 }
974 netif_stop_queue (dev);
976 if (skb->len > dev->mtu + dev->hard_header_len) {
977 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
978 netif_start_queue (dev);
979 return 1;
980 }
982 if (net_debug > 2)
983 printk(KERN_DEBUG "%s: send request\n", dev->name);
985 spin_lock_irq(&nl->lock);
986 dev->trans_start = jiffies;
987 snd->skb = skb;
988 snd->length.h = skb->len;
989 snd->state = PLIP_PK_TRIGGER;
990 if (nl->connection == PLIP_CN_NONE) {
991 nl->connection = PLIP_CN_SEND;
992 nl->timeout_count = 0;
993 }
994 schedule_work(&nl->immediate);
995 spin_unlock_irq(&nl->lock);
997 return 0;
998 }
1000 static void
1001 plip_rewrite_address(struct net_device *dev, struct ethhdr *eth)
1003 struct in_device *in_dev;
1005 if ((in_dev=dev->ip_ptr) != NULL) {
1006 /* Any address will do - we take the first */
1007 struct in_ifaddr *ifa=in_dev->ifa_list;
1008 if (ifa != NULL) {
1009 memcpy(eth->h_source, dev->dev_addr, 6);
1010 memset(eth->h_dest, 0xfc, 2);
1011 memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1016 static int
1017 plip_hard_header(struct sk_buff *skb, struct net_device *dev,
1018 unsigned short type, void *daddr,
1019 void *saddr, unsigned len)
1021 struct net_local *nl = netdev_priv(dev);
1022 int ret;
1024 if ((ret = nl->orig_hard_header(skb, dev, type, daddr, saddr, len)) >= 0)
1025 plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1027 return ret;
1030 int plip_hard_header_cache(struct neighbour *neigh,
1031 struct hh_cache *hh)
1033 struct net_local *nl = neigh->dev->priv;
1034 int ret;
1036 if ((ret = nl->orig_hard_header_cache(neigh, hh)) == 0)
1038 struct ethhdr *eth;
1040 eth = (struct ethhdr*)(((u8*)hh->hh_data) +
1041 HH_DATA_OFF(sizeof(*eth)));
1042 plip_rewrite_address (neigh->dev, eth);
1045 return ret;
1048 /* Open/initialize the board. This is called (in the current kernel)
1049 sometime after booting when the 'ifconfig' program is run.
1051 This routine gets exclusive access to the parallel port by allocating
1052 its IRQ line.
1053 */
1054 static int
1055 plip_open(struct net_device *dev)
1057 struct net_local *nl = netdev_priv(dev);
1058 struct in_device *in_dev;
1060 /* Grab the port */
1061 if (!nl->port_owner) {
1062 if (parport_claim(nl->pardev)) return -EAGAIN;
1063 nl->port_owner = 1;
1066 nl->should_relinquish = 0;
1068 /* Clear the data port. */
1069 write_data (dev, 0x00);
1071 /* Enable rx interrupt. */
1072 enable_parport_interrupts (dev);
1073 if (dev->irq == -1)
1075 atomic_set (&nl->kill_timer, 0);
1076 schedule_delayed_work(&nl->timer, 1);
1079 /* Initialize the state machine. */
1080 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
1081 nl->rcv_data.skb = nl->snd_data.skb = NULL;
1082 nl->connection = PLIP_CN_NONE;
1083 nl->is_deferred = 0;
1085 /* Fill in the MAC-level header.
1086 We used to abuse dev->broadcast to store the point-to-point
1087 MAC address, but we no longer do it. Instead, we fetch the
1088 interface address whenever it is needed, which is cheap enough
1089 because we use the hh_cache. Actually, abusing dev->broadcast
1090 didn't work, because when using plip_open the point-to-point
1091 address isn't yet known.
1092 PLIP doesn't have a real MAC address, but we need it to be
1093 DOS compatible, and to properly support taps (otherwise,
1094 when the device address isn't identical to the address of a
1095 received frame, the kernel incorrectly drops it). */
1097 if ((in_dev=dev->ip_ptr) != NULL) {
1098 /* Any address will do - we take the first. We already
1099 have the first two bytes filled with 0xfc, from
1100 plip_init_dev(). */
1101 struct in_ifaddr *ifa=in_dev->ifa_list;
1102 if (ifa != NULL) {
1103 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4);
1107 netif_start_queue (dev);
1109 return 0;
1112 /* The inverse routine to plip_open (). */
1113 static int
1114 plip_close(struct net_device *dev)
1116 struct net_local *nl = netdev_priv(dev);
1117 struct plip_local *snd = &nl->snd_data;
1118 struct plip_local *rcv = &nl->rcv_data;
1120 netif_stop_queue (dev);
1121 DISABLE(dev->irq);
1122 synchronize_irq(dev->irq);
1124 if (dev->irq == -1)
1126 init_MUTEX_LOCKED (&nl->killed_timer_sem);
1127 atomic_set (&nl->kill_timer, 1);
1128 down (&nl->killed_timer_sem);
1131 #ifdef NOTDEF
1132 outb(0x00, PAR_DATA(dev));
1133 #endif
1134 nl->is_deferred = 0;
1135 nl->connection = PLIP_CN_NONE;
1136 if (nl->port_owner) {
1137 parport_release(nl->pardev);
1138 nl->port_owner = 0;
1141 snd->state = PLIP_PK_DONE;
1142 if (snd->skb) {
1143 dev_kfree_skb(snd->skb);
1144 snd->skb = NULL;
1146 rcv->state = PLIP_PK_DONE;
1147 if (rcv->skb) {
1148 kfree_skb(rcv->skb);
1149 rcv->skb = NULL;
1152 #ifdef NOTDEF
1153 /* Reset. */
1154 outb(0x00, PAR_CONTROL(dev));
1155 #endif
1156 return 0;
1159 static int
1160 plip_preempt(void *handle)
1162 struct net_device *dev = (struct net_device *)handle;
1163 struct net_local *nl = netdev_priv(dev);
1165 /* Stand our ground if a datagram is on the wire */
1166 if (nl->connection != PLIP_CN_NONE) {
1167 nl->should_relinquish = 1;
1168 return 1;
1171 nl->port_owner = 0; /* Remember that we released the bus */
1172 return 0;
1175 static void
1176 plip_wakeup(void *handle)
1178 struct net_device *dev = (struct net_device *)handle;
1179 struct net_local *nl = netdev_priv(dev);
1181 if (nl->port_owner) {
1182 /* Why are we being woken up? */
1183 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name);
1184 if (!parport_claim(nl->pardev))
1185 /* bus_owner is already set (but why?) */
1186 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name);
1187 else
1188 return;
1191 if (!(dev->flags & IFF_UP))
1192 /* Don't need the port when the interface is down */
1193 return;
1195 if (!parport_claim(nl->pardev)) {
1196 nl->port_owner = 1;
1197 /* Clear the data port. */
1198 write_data (dev, 0x00);
1201 return;
1204 static struct net_device_stats *
1205 plip_get_stats(struct net_device *dev)
1207 struct net_local *nl = netdev_priv(dev);
1208 struct net_device_stats *r = &nl->enet_stats;
1210 return r;
1213 static int
1214 plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1216 struct net_local *nl = netdev_priv(dev);
1217 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1219 if (cmd != SIOCDEVPLIP)
1220 return -EOPNOTSUPP;
1222 switch(pc->pcmd) {
1223 case PLIP_GET_TIMEOUT:
1224 pc->trigger = nl->trigger;
1225 pc->nibble = nl->nibble;
1226 break;
1227 case PLIP_SET_TIMEOUT:
1228 if(!capable(CAP_NET_ADMIN))
1229 return -EPERM;
1230 nl->trigger = pc->trigger;
1231 nl->nibble = pc->nibble;
1232 break;
1233 default:
1234 return -EOPNOTSUPP;
1236 return 0;
1239 static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1240 static int timid;
1242 module_param_array(parport, int, NULL, 0);
1243 module_param(timid, int, 0);
1244 MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1246 static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1248 static inline int
1249 plip_searchfor(int list[], int a)
1251 int i;
1252 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1253 if (list[i] == a) return 1;
1255 return 0;
1258 /* plip_attach() is called (by the parport code) when a port is
1259 * available to use. */
1260 static void plip_attach (struct parport *port)
1262 static int unit;
1263 struct net_device *dev;
1264 struct net_local *nl;
1265 char name[IFNAMSIZ];
1267 if ((parport[0] == -1 && (!timid || !port->devices)) ||
1268 plip_searchfor(parport, port->number)) {
1269 if (unit == PLIP_MAX) {
1270 printk(KERN_ERR "plip: too many devices\n");
1271 return;
1274 sprintf(name, "plip%d", unit);
1275 dev = alloc_etherdev(sizeof(struct net_local));
1276 if (!dev) {
1277 printk(KERN_ERR "plip: memory squeeze\n");
1278 return;
1281 strcpy(dev->name, name);
1283 SET_MODULE_OWNER(dev);
1284 dev->irq = port->irq;
1285 dev->base_addr = port->base;
1286 if (port->irq == -1) {
1287 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1288 "which is fairly inefficient!\n", port->name);
1291 nl = netdev_priv(dev);
1292 nl->pardev = parport_register_device(port, name, plip_preempt,
1293 plip_wakeup, plip_interrupt,
1294 0, dev);
1296 if (!nl->pardev) {
1297 printk(KERN_ERR "%s: parport_register failed\n", name);
1298 goto err_free_dev;
1299 return;
1302 plip_init_netdev(dev);
1304 if (register_netdev(dev)) {
1305 printk(KERN_ERR "%s: network register failed\n", name);
1306 goto err_parport_unregister;
1309 printk(KERN_INFO "%s", version);
1310 if (dev->irq != -1)
1311 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1312 "using IRQ %d.\n",
1313 dev->name, dev->base_addr, dev->irq);
1314 else
1315 printk(KERN_INFO "%s: Parallel port at %#3lx, "
1316 "not using IRQ.\n",
1317 dev->name, dev->base_addr);
1318 dev_plip[unit++] = dev;
1320 return;
1322 err_parport_unregister:
1323 parport_unregister_device(nl->pardev);
1324 err_free_dev:
1325 free_netdev(dev);
1326 return;
1329 /* plip_detach() is called (by the parport code) when a port is
1330 * no longer available to use. */
1331 static void plip_detach (struct parport *port)
1333 /* Nothing to do */
1336 static struct parport_driver plip_driver = {
1337 .name = "plip",
1338 .attach = plip_attach,
1339 .detach = plip_detach
1340 };
1342 static void __exit plip_cleanup_module (void)
1344 struct net_device *dev;
1345 int i;
1347 parport_unregister_driver (&plip_driver);
1349 for (i=0; i < PLIP_MAX; i++) {
1350 if ((dev = dev_plip[i])) {
1351 struct net_local *nl = netdev_priv(dev);
1352 unregister_netdev(dev);
1353 if (nl->port_owner)
1354 parport_release(nl->pardev);
1355 parport_unregister_device(nl->pardev);
1356 free_netdev(dev);
1357 dev_plip[i] = NULL;
1362 #ifndef MODULE
1364 static int parport_ptr;
1366 static int __init plip_setup(char *str)
1368 int ints[4];
1370 str = get_options(str, ARRAY_SIZE(ints), ints);
1372 /* Ugh. */
1373 if (!strncmp(str, "parport", 7)) {
1374 int n = simple_strtoul(str+7, NULL, 10);
1375 if (parport_ptr < PLIP_MAX)
1376 parport[parport_ptr++] = n;
1377 else
1378 printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1379 str);
1380 } else if (!strcmp(str, "timid")) {
1381 timid = 1;
1382 } else {
1383 if (ints[0] == 0 || ints[1] == 0) {
1384 /* disable driver on "plip=" or "plip=0" */
1385 parport[0] = -2;
1386 } else {
1387 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1388 ints[1]);
1391 return 1;
1394 __setup("plip=", plip_setup);
1396 #endif /* !MODULE */
1398 static int __init plip_init (void)
1400 if (parport[0] == -2)
1401 return 0;
1403 if (parport[0] != -1 && timid) {
1404 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1405 timid = 0;
1408 if (parport_register_driver (&plip_driver)) {
1409 printk (KERN_WARNING "plip: couldn't register driver\n");
1410 return 1;
1413 return 0;
1416 module_init(plip_init);
1417 module_exit(plip_cleanup_module);
1418 MODULE_LICENSE("GPL");
1420 /*
1421 * Local variables:
1422 * compile-command: "gcc -DMODULE -DMODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -c plip.c"
1423 * End:
1424 */