Root/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 */
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>
101#include <linux/init.h>
102#include <linux/netdevice.h>
103#include <linux/etherdevice.h>
104#include <linux/inetdevice.h>
105#include <linux/skbuff.h>
106#include <linux/if_plip.h>
107#include <linux/workqueue.h>
108#include <linux/spinlock.h>
109#include <linux/completion.h>
110#include <linux/parport.h>
111#include <linux/bitops.h>
112
113#include <net/neighbour.h>
114
115#include <asm/system.h>
116#include <asm/irq.h>
117#include <asm/byteorder.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
126static const unsigned int net_debug = NET_DEBUG;
127
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 work_struct *work);
142static void plip_bh(struct work_struct *work);
143static void plip_timer_bh(struct work_struct *work);
144
145/* Interrupt handler */
146static void plip_interrupt(void *dev_id);
147
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, const void *daddr,
152                const void *saddr, unsigned len);
153static int plip_hard_header_cache(const 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 int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
158static int plip_preempt(void *handle);
159static void plip_wakeup(void *handle);
160
161enum plip_connection_state {
162    PLIP_CN_NONE=0,
163    PLIP_CN_RECEIVE,
164    PLIP_CN_SEND,
165    PLIP_CN_CLOSING,
166    PLIP_CN_ERROR
167};
168
169enum plip_packet_state {
170    PLIP_PK_DONE=0,
171    PLIP_PK_TRIGGER,
172    PLIP_PK_LENGTH_LSB,
173    PLIP_PK_LENGTH_MSB,
174    PLIP_PK_DATA,
175    PLIP_PK_CHECKSUM
176};
177
178enum plip_nibble_state {
179    PLIP_NB_BEGIN,
180    PLIP_NB_1,
181    PLIP_NB_2,
182};
183
184struct plip_local {
185    enum plip_packet_state state;
186    enum plip_nibble_state nibble;
187    union {
188        struct {
189#if defined(__LITTLE_ENDIAN)
190            unsigned char lsb;
191            unsigned char msb;
192#elif defined(__BIG_ENDIAN)
193            unsigned char msb;
194            unsigned char lsb;
195#else
196#error "Please fix the endianness defines in <asm/byteorder.h>"
197#endif
198        } b;
199        unsigned short h;
200    } length;
201    unsigned short byte;
202    unsigned char checksum;
203    unsigned char data;
204    struct sk_buff *skb;
205};
206
207struct net_local {
208    struct net_device *dev;
209    struct work_struct immediate;
210    struct delayed_work deferred;
211    struct delayed_work timer;
212    struct plip_local snd_data;
213    struct plip_local rcv_data;
214    struct pardevice *pardev;
215    unsigned long trigger;
216    unsigned long nibble;
217    enum plip_connection_state connection;
218    unsigned short timeout_count;
219    int is_deferred;
220    int port_owner;
221    int should_relinquish;
222    spinlock_t lock;
223    atomic_t kill_timer;
224    struct completion killed_timer_cmp;
225};
226
227static inline void enable_parport_interrupts (struct net_device *dev)
228{
229    if (dev->irq != -1)
230    {
231        struct parport *port =
232           ((struct net_local *)netdev_priv(dev))->pardev->port;
233        port->ops->enable_irq (port);
234    }
235}
236
237static inline void disable_parport_interrupts (struct net_device *dev)
238{
239    if (dev->irq != -1)
240    {
241        struct parport *port =
242           ((struct net_local *)netdev_priv(dev))->pardev->port;
243        port->ops->disable_irq (port);
244    }
245}
246
247static inline void write_data (struct net_device *dev, unsigned char data)
248{
249    struct parport *port =
250       ((struct net_local *)netdev_priv(dev))->pardev->port;
251
252    port->ops->write_data (port, data);
253}
254
255static inline unsigned char read_status (struct net_device *dev)
256{
257    struct parport *port =
258       ((struct net_local *)netdev_priv(dev))->pardev->port;
259
260    return port->ops->read_status (port);
261}
262
263static const struct header_ops plip_header_ops = {
264    .create = plip_hard_header,
265    .cache = plip_hard_header_cache,
266};
267
268static const struct net_device_ops plip_netdev_ops = {
269    .ndo_open = plip_open,
270    .ndo_stop = plip_close,
271    .ndo_start_xmit = plip_tx_packet,
272    .ndo_do_ioctl = plip_ioctl,
273    .ndo_change_mtu = eth_change_mtu,
274    .ndo_set_mac_address = eth_mac_addr,
275    .ndo_validate_addr = eth_validate_addr,
276};
277
278/* Entry point of PLIP driver.
279   Probe the hardware, and register/initialize the driver.
280
281   PLIP is rather weird, because of the way it interacts with the parport
282   system. It is _not_ initialised from Space.c. Instead, plip_init()
283   is called, and that function makes up a "struct net_device" for each port, and
284   then calls us here.
285
286   */
287static void
288plip_init_netdev(struct net_device *dev)
289{
290    struct net_local *nl = netdev_priv(dev);
291
292    /* Then, override parts of it */
293    dev->tx_queue_len = 10;
294    dev->flags = IFF_POINTOPOINT|IFF_NOARP;
295    memset(dev->dev_addr, 0xfc, ETH_ALEN);
296
297    dev->netdev_ops = &plip_netdev_ops;
298    dev->header_ops = &plip_header_ops;
299
300
301    nl->port_owner = 0;
302
303    /* Initialize constants */
304    nl->trigger = PLIP_TRIGGER_WAIT;
305    nl->nibble = PLIP_NIBBLE_WAIT;
306
307    /* Initialize task queue structures */
308    INIT_WORK(&nl->immediate, plip_bh);
309    INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);
310
311    if (dev->irq == -1)
312        INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);
313
314    spin_lock_init(&nl->lock);
315}
316
317/* Bottom half handler for the delayed request.
318   This routine is kicked by do_timer().
319   Request `plip_bh' to be invoked. */
320static void
321plip_kick_bh(struct work_struct *work)
322{
323    struct net_local *nl =
324        container_of(work, struct net_local, deferred.work);
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
354static 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};
362
363/* Bottom half handler of PLIP. */
364static void
365plip_bh(struct work_struct *work)
366{
367    struct net_local *nl = container_of(work, struct net_local, immediate);
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)(nl->dev, nl, snd, rcv)) != OK
376        && (r = plip_bh_timeout_error(nl->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 work_struct *work)
384{
385    struct net_local *nl =
386        container_of(work, struct net_local, timer.work);
387
388    if (!(atomic_read (&nl->kill_timer))) {
389        plip_interrupt (nl->dev);
390
391        schedule_delayed_work(&nl->timer, 1);
392    }
393    else {
394        complete(&nl->killed_timer_cmp);
395    }
396}
397
398static int
399plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,
400              struct plip_local *snd, struct plip_local *rcv,
401              int error)
402{
403    unsigned char c0;
404    /*
405     * This is tricky. If we got here from the beginning of send (either
406     * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's
407     * already disabled. With the old variant of {enable,disable}_irq()
408     * extra disable_irq() was a no-op. Now it became mortal - it's
409     * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,
410     * that is). So we have to treat HS_TIMEOUT and ERROR from send
411     * in a special way.
412     */
413
414    spin_lock_irq(&nl->lock);
415    if (nl->connection == PLIP_CN_SEND) {
416
417        if (error != ERROR) { /* Timeout */
418            nl->timeout_count++;
419            if ((error == HS_TIMEOUT
420                 && nl->timeout_count <= 10)
421                || nl->timeout_count <= 3) {
422                spin_unlock_irq(&nl->lock);
423                /* Try again later */
424                return TIMEOUT;
425            }
426            c0 = read_status(dev);
427            printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",
428                   dev->name, snd->state, c0);
429        } else
430            error = HS_TIMEOUT;
431        dev->stats.tx_errors++;
432        dev->stats.tx_aborted_errors++;
433    } else if (nl->connection == PLIP_CN_RECEIVE) {
434        if (rcv->state == PLIP_PK_TRIGGER) {
435            /* Transmission was interrupted. */
436            spin_unlock_irq(&nl->lock);
437            return OK;
438        }
439        if (error != ERROR) { /* Timeout */
440            if (++nl->timeout_count <= 3) {
441                spin_unlock_irq(&nl->lock);
442                /* Try again later */
443                return TIMEOUT;
444            }
445            c0 = read_status(dev);
446            printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",
447                   dev->name, rcv->state, c0);
448        }
449        dev->stats.rx_dropped++;
450    }
451    rcv->state = PLIP_PK_DONE;
452    if (rcv->skb) {
453        kfree_skb(rcv->skb);
454        rcv->skb = NULL;
455    }
456    snd->state = PLIP_PK_DONE;
457    if (snd->skb) {
458        dev_kfree_skb(snd->skb);
459        snd->skb = NULL;
460    }
461    spin_unlock_irq(&nl->lock);
462    if (error == HS_TIMEOUT) {
463        DISABLE(dev->irq);
464        synchronize_irq(dev->irq);
465    }
466    disable_parport_interrupts (dev);
467    netif_stop_queue (dev);
468    nl->connection = PLIP_CN_ERROR;
469    write_data (dev, 0x00);
470
471    return TIMEOUT;
472}
473
474static int
475plip_none(struct net_device *dev, struct net_local *nl,
476      struct plip_local *snd, struct plip_local *rcv)
477{
478    return OK;
479}
480
481/* PLIP_RECEIVE --- receive a byte(two nibbles)
482   Returns OK on success, TIMEOUT on timeout */
483static inline int
484plip_receive(unsigned short nibble_timeout, struct net_device *dev,
485         enum plip_nibble_state *ns_p, unsigned char *data_p)
486{
487    unsigned char c0, c1;
488    unsigned int cx;
489
490    switch (*ns_p) {
491    case PLIP_NB_BEGIN:
492        cx = nibble_timeout;
493        while (1) {
494            c0 = read_status(dev);
495            udelay(PLIP_DELAY_UNIT);
496            if ((c0 & 0x80) == 0) {
497                c1 = read_status(dev);
498                if (c0 == c1)
499                    break;
500            }
501            if (--cx == 0)
502                return TIMEOUT;
503        }
504        *data_p = (c0 >> 3) & 0x0f;
505        write_data (dev, 0x10); /* send ACK */
506        *ns_p = PLIP_NB_1;
507
508    case PLIP_NB_1:
509        cx = nibble_timeout;
510        while (1) {
511            c0 = read_status(dev);
512            udelay(PLIP_DELAY_UNIT);
513            if (c0 & 0x80) {
514                c1 = read_status(dev);
515                if (c0 == c1)
516                    break;
517            }
518            if (--cx == 0)
519                return TIMEOUT;
520        }
521        *data_p |= (c0 << 1) & 0xf0;
522        write_data (dev, 0x00); /* send ACK */
523        *ns_p = PLIP_NB_BEGIN;
524    case PLIP_NB_2:
525        break;
526    }
527    return OK;
528}
529
530/*
531 * Determine the packet's protocol ID. The rule here is that we
532 * assume 802.3 if the type field is short enough to be a length.
533 * This is normal practice and works for any 'now in use' protocol.
534 *
535 * PLIP is ethernet ish but the daddr might not be valid if unicast.
536 * PLIP fortunately has no bus architecture (its Point-to-point).
537 *
538 * We can't fix the daddr thing as that quirk (more bug) is embedded
539 * in far too many old systems not all even running Linux.
540 */
541
542static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)
543{
544    struct ethhdr *eth;
545    unsigned char *rawp;
546
547    skb_reset_mac_header(skb);
548    skb_pull(skb,dev->hard_header_len);
549    eth = eth_hdr(skb);
550
551    if(*eth->h_dest&1)
552    {
553        if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
554            skb->pkt_type=PACKET_BROADCAST;
555        else
556            skb->pkt_type=PACKET_MULTICAST;
557    }
558
559    /*
560     * This ALLMULTI check should be redundant by 1.4
561     * so don't forget to remove it.
562     */
563
564    if (ntohs(eth->h_proto) >= 1536)
565        return eth->h_proto;
566
567    rawp = skb->data;
568
569    /*
570     * This is a magic hack to spot IPX packets. Older Novell breaks
571     * the protocol design and runs IPX over 802.3 without an 802.2 LLC
572     * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
573     * won't work for fault tolerant netware but does for the rest.
574     */
575    if (*(unsigned short *)rawp == 0xFFFF)
576        return htons(ETH_P_802_3);
577
578    /*
579     * Real 802.2 LLC
580     */
581    return htons(ETH_P_802_2);
582}
583
584/* PLIP_RECEIVE_PACKET --- receive a packet */
585static int
586plip_receive_packet(struct net_device *dev, struct net_local *nl,
587            struct plip_local *snd, struct plip_local *rcv)
588{
589    unsigned short nibble_timeout = nl->nibble;
590    unsigned char *lbuf;
591
592    switch (rcv->state) {
593    case PLIP_PK_TRIGGER:
594        DISABLE(dev->irq);
595        /* Don't need to synchronize irq, as we can safely ignore it */
596        disable_parport_interrupts (dev);
597        write_data (dev, 0x01); /* send ACK */
598        if (net_debug > 2)
599            printk(KERN_DEBUG "%s: receive start\n", dev->name);
600        rcv->state = PLIP_PK_LENGTH_LSB;
601        rcv->nibble = PLIP_NB_BEGIN;
602
603    case PLIP_PK_LENGTH_LSB:
604        if (snd->state != PLIP_PK_DONE) {
605            if (plip_receive(nl->trigger, dev,
606                     &rcv->nibble, &rcv->length.b.lsb)) {
607                /* collision, here dev->tbusy == 1 */
608                rcv->state = PLIP_PK_DONE;
609                nl->is_deferred = 1;
610                nl->connection = PLIP_CN_SEND;
611                schedule_delayed_work(&nl->deferred, 1);
612                enable_parport_interrupts (dev);
613                ENABLE(dev->irq);
614                return OK;
615            }
616        } else {
617            if (plip_receive(nibble_timeout, dev,
618                     &rcv->nibble, &rcv->length.b.lsb))
619                return TIMEOUT;
620        }
621        rcv->state = PLIP_PK_LENGTH_MSB;
622
623    case PLIP_PK_LENGTH_MSB:
624        if (plip_receive(nibble_timeout, dev,
625                 &rcv->nibble, &rcv->length.b.msb))
626            return TIMEOUT;
627        if (rcv->length.h > dev->mtu + dev->hard_header_len
628            || rcv->length.h < 8) {
629            printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);
630            return ERROR;
631        }
632        /* Malloc up new buffer. */
633        rcv->skb = dev_alloc_skb(rcv->length.h + 2);
634        if (rcv->skb == NULL) {
635            printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);
636            return ERROR;
637        }
638        skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */
639        skb_put(rcv->skb,rcv->length.h);
640        rcv->skb->dev = dev;
641        rcv->state = PLIP_PK_DATA;
642        rcv->byte = 0;
643        rcv->checksum = 0;
644
645    case PLIP_PK_DATA:
646        lbuf = rcv->skb->data;
647        do {
648            if (plip_receive(nibble_timeout, dev,
649                     &rcv->nibble, &lbuf[rcv->byte]))
650                return TIMEOUT;
651        } while (++rcv->byte < rcv->length.h);
652        do {
653            rcv->checksum += lbuf[--rcv->byte];
654        } while (rcv->byte);
655        rcv->state = PLIP_PK_CHECKSUM;
656
657    case PLIP_PK_CHECKSUM:
658        if (plip_receive(nibble_timeout, dev,
659                 &rcv->nibble, &rcv->data))
660            return TIMEOUT;
661        if (rcv->data != rcv->checksum) {
662            dev->stats.rx_crc_errors++;
663            if (net_debug)
664                printk(KERN_DEBUG "%s: checksum error\n", dev->name);
665            return ERROR;
666        }
667        rcv->state = PLIP_PK_DONE;
668
669    case PLIP_PK_DONE:
670        /* Inform the upper layer for the arrival of a packet. */
671        rcv->skb->protocol=plip_type_trans(rcv->skb, dev);
672        netif_rx_ni(rcv->skb);
673        dev->stats.rx_bytes += rcv->length.h;
674        dev->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 */
702static inline int
703plip_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                dev->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                    dev->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        dev->stats.tx_bytes += snd->skb->len;
841        dev_kfree_skb(snd->skb);
842        dev->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}
902
903/* Handle the parallel port interrupts. */
904static void
905plip_interrupt(void *dev_id)
906{
907    struct net_device *dev = dev_id;
908    struct net_local *nl;
909    struct plip_local *rcv;
910    unsigned char c0;
911    unsigned long flags;
912
913    nl = netdev_priv(dev);
914    rcv = &nl->rcv_data;
915
916    spin_lock_irqsave (&nl->lock, flags);
917
918    c0 = read_status(dev);
919    if ((c0 & 0xf8) != 0xc0) {
920        if ((dev->irq != -1) && (net_debug > 1))
921            printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name);
922        spin_unlock_irqrestore (&nl->lock, flags);
923        return;
924    }
925
926    if (net_debug > 3)
927        printk(KERN_DEBUG "%s: interrupt.\n", dev->name);
928
929    switch (nl->connection) {
930    case PLIP_CN_CLOSING:
931        netif_wake_queue (dev);
932    case PLIP_CN_NONE:
933    case PLIP_CN_SEND:
934        rcv->state = PLIP_PK_TRIGGER;
935        nl->connection = PLIP_CN_RECEIVE;
936        nl->timeout_count = 0;
937        schedule_work(&nl->immediate);
938        break;
939
940    case PLIP_CN_RECEIVE:
941        /* May occur because there is race condition
942           around test and set of dev->interrupt.
943           Ignore this interrupt. */
944        break;
945
946    case PLIP_CN_ERROR:
947        printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name);
948        break;
949    }
950
951    spin_unlock_irqrestore(&nl->lock, flags);
952}
953
954static int
955plip_tx_packet(struct sk_buff *skb, struct net_device *dev)
956{
957    struct net_local *nl = netdev_priv(dev);
958    struct plip_local *snd = &nl->snd_data;
959
960    if (netif_queue_stopped(dev))
961        return NETDEV_TX_BUSY;
962
963    /* We may need to grab the bus */
964    if (!nl->port_owner) {
965        if (parport_claim(nl->pardev))
966            return NETDEV_TX_BUSY;
967        nl->port_owner = 1;
968    }
969
970    netif_stop_queue (dev);
971
972    if (skb->len > dev->mtu + dev->hard_header_len) {
973        printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len);
974        netif_start_queue (dev);
975        return NETDEV_TX_BUSY;
976    }
977
978    if (net_debug > 2)
979        printk(KERN_DEBUG "%s: send request\n", dev->name);
980
981    spin_lock_irq(&nl->lock);
982    dev->trans_start = jiffies;
983    snd->skb = skb;
984    snd->length.h = skb->len;
985    snd->state = PLIP_PK_TRIGGER;
986    if (nl->connection == PLIP_CN_NONE) {
987        nl->connection = PLIP_CN_SEND;
988        nl->timeout_count = 0;
989    }
990    schedule_work(&nl->immediate);
991    spin_unlock_irq(&nl->lock);
992
993    return 0;
994}
995
996static void
997plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth)
998{
999    const struct in_device *in_dev = dev->ip_ptr;
1000
1001    if (in_dev) {
1002        /* Any address will do - we take the first */
1003        const struct in_ifaddr *ifa = in_dev->ifa_list;
1004        if (ifa) {
1005            memcpy(eth->h_source, dev->dev_addr, 6);
1006            memset(eth->h_dest, 0xfc, 2);
1007            memcpy(eth->h_dest+2, &ifa->ifa_address, 4);
1008        }
1009    }
1010}
1011
1012static int
1013plip_hard_header(struct sk_buff *skb, struct net_device *dev,
1014         unsigned short type, const void *daddr,
1015         const void *saddr, unsigned len)
1016{
1017    int ret;
1018
1019    ret = eth_header(skb, dev, type, daddr, saddr, len);
1020    if (ret >= 0)
1021        plip_rewrite_address (dev, (struct ethhdr *)skb->data);
1022
1023    return ret;
1024}
1025
1026static int plip_hard_header_cache(const struct neighbour *neigh,
1027                  struct hh_cache *hh)
1028{
1029    int ret;
1030
1031    ret = eth_header_cache(neigh, hh);
1032    if (ret == 0) {
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    }
1039
1040    return ret;
1041}
1042
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_completion(&nl->killed_timer_cmp);
1122        atomic_set (&nl->kill_timer, 1);
1123        wait_for_completion(&nl->killed_timer_cmp);
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    }
1185
1186    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 int
1200plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1201{
1202    struct net_local *nl = netdev_priv(dev);
1203    struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru;
1204
1205    if (cmd != SIOCDEVPLIP)
1206        return -EOPNOTSUPP;
1207
1208    switch(pc->pcmd) {
1209    case PLIP_GET_TIMEOUT:
1210        pc->trigger = nl->trigger;
1211        pc->nibble = nl->nibble;
1212        break;
1213    case PLIP_SET_TIMEOUT:
1214        if(!capable(CAP_NET_ADMIN))
1215            return -EPERM;
1216        nl->trigger = pc->trigger;
1217        nl->nibble = pc->nibble;
1218        break;
1219    default:
1220        return -EOPNOTSUPP;
1221    }
1222    return 0;
1223}
1224
1225static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 };
1226static int timid;
1227
1228module_param_array(parport, int, NULL, 0);
1229module_param(timid, int, 0);
1230MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip");
1231
1232static struct net_device *dev_plip[PLIP_MAX] = { NULL, };
1233
1234static inline int
1235plip_searchfor(int list[], int a)
1236{
1237    int i;
1238    for (i = 0; i < PLIP_MAX && list[i] != -1; i++) {
1239        if (list[i] == a) return 1;
1240    }
1241    return 0;
1242}
1243
1244/* plip_attach() is called (by the parport code) when a port is
1245 * available to use. */
1246static void plip_attach (struct parport *port)
1247{
1248    static int unit;
1249    struct net_device *dev;
1250    struct net_local *nl;
1251    char name[IFNAMSIZ];
1252
1253    if ((parport[0] == -1 && (!timid || !port->devices)) ||
1254        plip_searchfor(parport, port->number)) {
1255        if (unit == PLIP_MAX) {
1256            printk(KERN_ERR "plip: too many devices\n");
1257            return;
1258        }
1259
1260        sprintf(name, "plip%d", unit);
1261        dev = alloc_etherdev(sizeof(struct net_local));
1262        if (!dev) {
1263            printk(KERN_ERR "plip: memory squeeze\n");
1264            return;
1265        }
1266
1267        strcpy(dev->name, name);
1268
1269        dev->irq = port->irq;
1270        dev->base_addr = port->base;
1271        if (port->irq == -1) {
1272            printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode,"
1273                         "which is fairly inefficient!\n", port->name);
1274        }
1275
1276        nl = netdev_priv(dev);
1277        nl->dev = dev;
1278        nl->pardev = parport_register_device(port, dev->name, plip_preempt,
1279                         plip_wakeup, plip_interrupt,
1280                         0, dev);
1281
1282        if (!nl->pardev) {
1283            printk(KERN_ERR "%s: parport_register failed\n", name);
1284            goto err_free_dev;
1285            return;
1286        }
1287
1288        plip_init_netdev(dev);
1289
1290        if (register_netdev(dev)) {
1291            printk(KERN_ERR "%s: network register failed\n", name);
1292            goto err_parport_unregister;
1293        }
1294
1295        printk(KERN_INFO "%s", version);
1296        if (dev->irq != -1)
1297            printk(KERN_INFO "%s: Parallel port at %#3lx, "
1298                     "using IRQ %d.\n",
1299                         dev->name, dev->base_addr, dev->irq);
1300        else
1301            printk(KERN_INFO "%s: Parallel port at %#3lx, "
1302                     "not using IRQ.\n",
1303                     dev->name, dev->base_addr);
1304        dev_plip[unit++] = dev;
1305    }
1306    return;
1307
1308err_parport_unregister:
1309    parport_unregister_device(nl->pardev);
1310err_free_dev:
1311    free_netdev(dev);
1312    return;
1313}
1314
1315/* plip_detach() is called (by the parport code) when a port is
1316 * no longer available to use. */
1317static void plip_detach (struct parport *port)
1318{
1319    /* Nothing to do */
1320}
1321
1322static struct parport_driver plip_driver = {
1323    .name = "plip",
1324    .attach = plip_attach,
1325    .detach = plip_detach
1326};
1327
1328static void __exit plip_cleanup_module (void)
1329{
1330    struct net_device *dev;
1331    int i;
1332
1333    parport_unregister_driver (&plip_driver);
1334
1335    for (i=0; i < PLIP_MAX; i++) {
1336        if ((dev = dev_plip[i])) {
1337            struct net_local *nl = netdev_priv(dev);
1338            unregister_netdev(dev);
1339            if (nl->port_owner)
1340                parport_release(nl->pardev);
1341            parport_unregister_device(nl->pardev);
1342            free_netdev(dev);
1343            dev_plip[i] = NULL;
1344        }
1345    }
1346}
1347
1348#ifndef MODULE
1349
1350static int parport_ptr;
1351
1352static int __init plip_setup(char *str)
1353{
1354    int ints[4];
1355
1356    str = get_options(str, ARRAY_SIZE(ints), ints);
1357
1358    /* Ugh. */
1359    if (!strncmp(str, "parport", 7)) {
1360        int n = simple_strtoul(str+7, NULL, 10);
1361        if (parport_ptr < PLIP_MAX)
1362            parport[parport_ptr++] = n;
1363        else
1364            printk(KERN_INFO "plip: too many ports, %s ignored.\n",
1365                   str);
1366    } else if (!strcmp(str, "timid")) {
1367        timid = 1;
1368    } else {
1369        if (ints[0] == 0 || ints[1] == 0) {
1370            /* disable driver on "plip=" or "plip=0" */
1371            parport[0] = -2;
1372        } else {
1373            printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n",
1374                   ints[1]);
1375        }
1376    }
1377    return 1;
1378}
1379
1380__setup("plip=", plip_setup);
1381
1382#endif /* !MODULE */
1383
1384static int __init plip_init (void)
1385{
1386    if (parport[0] == -2)
1387        return 0;
1388
1389    if (parport[0] != -1 && timid) {
1390        printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n");
1391        timid = 0;
1392    }
1393
1394    if (parport_register_driver (&plip_driver)) {
1395        printk (KERN_WARNING "plip: couldn't register driver\n");
1396        return 1;
1397    }
1398
1399    return 0;
1400}
1401
1402module_init(plip_init);
1403module_exit(plip_cleanup_module);
1404MODULE_LICENSE("GPL");
1405

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive