Subversion Repositories test_project

/* $Id: plip.c,v 1.3.6.2 1997/04/16 15:07:56 phil Exp $ */

/* PLIP: A parallel port "network" driver for Linux. */

/* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */

/*

 * Authors:     Donald Becker <becker@scyld.com>

 *              Tommy Thorn <thorn@daimi.aau.dk>

 *              Tanabe Hiroyasu <hiro@sanpo.t.u-tokyo.ac.jp>

 *              Alan Cox <gw4pts@gw4pts.ampr.org>

 *              Peter Bauer <100136.3530@compuserve.com>

 *              Niibe Yutaka <gniibe@mri.co.jp>

 *              Nimrod Zimerman <zimerman@mailandnews.com>

 *

 * Enhancements:

 *              Modularization and ifreq/ifmap support by Alan Cox.

 *              Rewritten by Niibe Yutaka.

 *              parport-sharing awareness code by Philip Blundell.

 *              SMP locking by Niibe Yutaka.

 *              Support for parallel ports with no IRQ (poll mode),

 *              Modifications to use the parallel port API

 *              by Nimrod Zimerman.

 *

 * Fixes:

 *              Niibe Yutaka

 *                - Module initialization.

 *                - MTU fix.

 *                - Make sure other end is OK, before sending a packet.

 *                - Fix immediate timer problem.

 *

 *              Al Viro

 *                - Changed {enable,disable}_irq handling to make it work

 *                  with new ("stack") semantics.

 *

 *              This program is free software; you can redistribute it and/or

 *              modify it under the terms of the GNU General Public License

 *              as published by the Free Software Foundation; either version

 *              2 of the License, or (at your option) any later version.

 */

/*

 * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com>

 * inspired by Russ Nelson's parallel port packet driver.

 *

 * NOTE:

 *     Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0.

 *     Because of the necessity to communicate to DOS machines with the

 *     Crynwr packet driver, Peter Bauer changed the protocol again

 *     back to original protocol.

 *

 *     This version follows original PLIP protocol.

 *     So, this PLIP can't communicate the PLIP of Linux v1.0.

 */

/*

 *     To use with DOS box, please do (Turn on ARP switch):

 *      # ifconfig plip[0-2] arp

 */

static const char version[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n";

/*

  Sources:

        Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>

        "parallel.asm" parallel port packet driver.

  The "Crynwr" parallel port standard specifies the following protocol:

    Trigger by sending nibble '0x8' (this causes interrupt on other end)

    count-low octet

    count-high octet

    ... data octets

    checksum octet

  Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>

                        <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>

  The packet is encapsulated as if it were ethernet.

  The cable used is a de facto standard parallel null cable -- sold as

  a "LapLink" cable by various places.  You'll need a 12-conductor cable to

  make one yourself.  The wiring is:

    SLCTIN      17 - 17

    GROUND      25 - 25

    D0->ERROR   2 - 15          15 - 2

    D1->SLCT    3 - 13          13 - 3

    D2->PAPOUT  4 - 12          12 - 4

    D3->ACK     5 - 10          10 - 5

    D4->BUSY    6 - 11          11 - 6

  Do not connect the other pins.  They are

    D5,D6,D7 are 7,8,9

    STROBE is 1, FEED is 14, INIT is 16

    extra grounds are 18,19,20,21,22,23,24

*/

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/interrupt.h>

#include <linux/string.h>

#include <linux/if_ether.h>

#include <linux/in.h>

#include <linux/errno.h>

#include <linux/delay.h>

#include <linux/init.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/inetdevice.h>

#include <linux/skbuff.h>

#include <linux/if_plip.h>

#include <linux/workqueue.h>

#include <linux/spinlock.h>

#include <linux/parport.h>

#include <linux/bitops.h>

#include <net/neighbour.h>

#include <asm/system.h>

#include <asm/irq.h>

#include <asm/byteorder.h>

#include <asm/semaphore.h>

/* Maximum number of devices to support. */

#define PLIP_MAX  8

/* Use 0 for production, 1 for verification, >2 for debug */

#ifndef NET_DEBUG

#define NET_DEBUG 1

#endif

static const unsigned int net_debug = NET_DEBUG;

#define ENABLE(irq)  if (irq != -1) enable_irq(irq)

#define DISABLE(irq) if (irq != -1) disable_irq(irq)

/* In micro second */

#define PLIP_DELAY_UNIT            1

/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */

#define PLIP_TRIGGER_WAIT        500

/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */

#define PLIP_NIBBLE_WAIT        3000

/* Bottom halves */

static void plip_kick_bh(struct work_struct *work);

static void plip_bh(struct work_struct *work);

static void plip_timer_bh(struct work_struct *work);

/* Interrupt handler */

static void plip_interrupt(void *dev_id);

/* Functions for DEV methods */

static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev);

static int plip_hard_header(struct sk_buff *skb, struct net_device *dev,

                            unsigned short type, const void *daddr,

                            const void *saddr, unsigned len);

static int plip_hard_header_cache(const struct neighbour *neigh,

                                  struct hh_cache *hh);

static int plip_open(struct net_device *dev);

static int plip_close(struct net_device *dev);

static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);

static int plip_preempt(void *handle);

static void plip_wakeup(void *handle);

enum plip_connection_state {

        PLIP_CN_NONE=0,

        PLIP_CN_RECEIVE,

        PLIP_CN_SEND,

        PLIP_CN_CLOSING,

        PLIP_CN_ERROR

};

enum plip_packet_state {

        PLIP_PK_DONE=0,

        PLIP_PK_TRIGGER,

        PLIP_PK_LENGTH_LSB,

        PLIP_PK_LENGTH_MSB,

        PLIP_PK_DATA,

        PLIP_PK_CHECKSUM

};

enum plip_nibble_state {

        PLIP_NB_BEGIN,

        PLIP_NB_1,

        PLIP_NB_2,

};

struct plip_local {

        enum plip_packet_state state;

        enum plip_nibble_state nibble;

        union {

                struct {

#if defined(__LITTLE_ENDIAN)

                        unsigned char lsb;

                        unsigned char msb;

#elif defined(__BIG_ENDIAN)

                        unsigned char msb;

                        unsigned char lsb;

#else

#error  "Please fix the endianness defines in <asm/byteorder.h>"

#endif

                } b;

                unsigned short h;

        } length;

        unsigned short byte;

        unsigned char  checksum;

        unsigned char  data;

        struct sk_buff *skb;

};

struct net_local {

        struct net_device *dev;

        struct work_struct immediate;

        struct delayed_work deferred;

        struct delayed_work timer;

        struct plip_local snd_data;

        struct plip_local rcv_data;

        struct pardevice *pardev;

        unsigned long  trigger;

        unsigned long  nibble;

        enum plip_connection_state connection;

        unsigned short timeout_count;

        int is_deferred;

        int port_owner;

        int should_relinquish;

        spinlock_t lock;

        atomic_t kill_timer;

        struct semaphore killed_timer_sem;

};

static inline void enable_parport_interrupts (struct net_device *dev)

{

        if (dev->irq != -1)

        {

                struct parport *port =

                   ((struct net_local *)dev->priv)->pardev->port;

                port->ops->enable_irq (port);

        }

}

static inline void disable_parport_interrupts (struct net_device *dev)

{

        if (dev->irq != -1)

        {

                struct parport *port =

                   ((struct net_local *)dev->priv)->pardev->port;

                port->ops->disable_irq (port);

        }

}

static inline void write_data (struct net_device *dev, unsigned char data)

{

        struct parport *port =

           ((struct net_local *)dev->priv)->pardev->port;

        port->ops->write_data (port, data);

}

static inline unsigned char read_status (struct net_device *dev)

{

        struct parport *port =

           ((struct net_local *)dev->priv)->pardev->port;

        return port->ops->read_status (port);

}

static const struct header_ops plip_header_ops = {

        .create = plip_hard_header,

        .cache  = plip_hard_header_cache,

};

/* Entry point of PLIP driver.

   Probe the hardware, and register/initialize the driver.

   PLIP is rather weird, because of the way it interacts with the parport

   system.  It is _not_ initialised from Space.c.  Instead, plip_init()

   is called, and that function makes up a "struct net_device" for each port, and

   then calls us here.

   */

static void

plip_init_netdev(struct net_device *dev)

{

        struct net_local *nl = netdev_priv(dev);

        /* Then, override parts of it */

        dev->hard_start_xmit     = plip_tx_packet;

        dev->open                = plip_open;

        dev->stop                = plip_close;

        dev->do_ioctl            = plip_ioctl;

        dev->tx_queue_len        = 10;

        dev->flags               = IFF_POINTOPOINT|IFF_NOARP;

        memset(dev->dev_addr, 0xfc, ETH_ALEN);

        dev->header_ops          = &plip_header_ops;

        nl->port_owner = 0;

        /* Initialize constants */

        nl->trigger     = PLIP_TRIGGER_WAIT;

        nl->nibble      = PLIP_NIBBLE_WAIT;

        /* Initialize task queue structures */

        INIT_WORK(&nl->immediate, plip_bh);

        INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh);

        if (dev->irq == -1)

                INIT_DELAYED_WORK(&nl->timer, plip_timer_bh);

        spin_lock_init(&nl->lock);

}

/* Bottom half handler for the delayed request.

   This routine is kicked by do_timer().

   Request `plip_bh' to be invoked. */

static void

plip_kick_bh(struct work_struct *work)

{

        struct net_local *nl =

                container_of(work, struct net_local, deferred.work);

        if (nl->is_deferred)

                schedule_work(&nl->immediate);

}

/* Forward declarations of internal routines */

static int plip_none(struct net_device *, struct net_local *,

                     struct plip_local *, struct plip_local *);

static int plip_receive_packet(struct net_device *, struct net_local *,

                               struct plip_local *, struct plip_local *);

static int plip_send_packet(struct net_device *, struct net_local *,

                            struct plip_local *, struct plip_local *);

static int plip_connection_close(struct net_device *, struct net_local *,

                                 struct plip_local *, struct plip_local *);

static int plip_error(struct net_device *, struct net_local *,

                      struct plip_local *, struct plip_local *);

static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,

                                 struct plip_local *snd,

                                 struct plip_local *rcv,

                                 int error);

#define OK        0

#define TIMEOUT   1

#define ERROR     2

#define HS_TIMEOUT      3

typedef int (*plip_func)(struct net_device *dev, struct net_local *nl,

                         struct plip_local *snd, struct plip_local *rcv);

static const plip_func connection_state_table[] =

{

        plip_none,

        plip_receive_packet,

        plip_send_packet,

        plip_connection_close,

        plip_error

};

/* Bottom half handler of PLIP. */

static void

plip_bh(struct work_struct *work)

{

        struct net_local *nl = container_of(work, struct net_local, immediate);

        struct plip_local *snd = &nl->snd_data;

        struct plip_local *rcv = &nl->rcv_data;

        plip_func f;

        int r;

        nl->is_deferred = 0;

        f = connection_state_table[nl->connection];

        if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK

            && (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) {

                nl->is_deferred = 1;

                schedule_delayed_work(&nl->deferred, 1);

        }

}

static void

plip_timer_bh(struct work_struct *work)

{

        struct net_local *nl =

                container_of(work, struct net_local, timer.work);

        if (!(atomic_read (&nl->kill_timer))) {

                plip_interrupt (nl->dev);

                schedule_delayed_work(&nl->timer, 1);

        }

        else {

                up (&nl->killed_timer_sem);

        }

}

static int

plip_bh_timeout_error(struct net_device *dev, struct net_local *nl,

                      struct plip_local *snd, struct plip_local *rcv,

                      int error)

{

        unsigned char c0;

        /*

         * This is tricky. If we got here from the beginning of send (either

         * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's

         * already disabled. With the old variant of {enable,disable}_irq()

         * extra disable_irq() was a no-op. Now it became mortal - it's

         * unbalanced and thus we'll never re-enable IRQ (until rmmod plip,

         * that is). So we have to treat HS_TIMEOUT and ERROR from send

         * in a special way.

         */

        spin_lock_irq(&nl->lock);

        if (nl->connection == PLIP_CN_SEND) {

                if (error != ERROR) { /* Timeout */

                        nl->timeout_count++;

                        if ((error == HS_TIMEOUT

                             && nl->timeout_count <= 10)

                            || nl->timeout_count <= 3) {

                                spin_unlock_irq(&nl->lock);

                                /* Try again later */

                                return TIMEOUT;

                        }

                        c0 = read_status(dev);

                        printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n",

                               dev->name, snd->state, c0);

                } else

                        error = HS_TIMEOUT;

                dev->stats.tx_errors++;

                dev->stats.tx_aborted_errors++;

        } else if (nl->connection == PLIP_CN_RECEIVE) {

                if (rcv->state == PLIP_PK_TRIGGER) {

                        /* Transmission was interrupted. */

                        spin_unlock_irq(&nl->lock);

                        return OK;

                }

                if (error != ERROR) { /* Timeout */

                        if (++nl->timeout_count <= 3) {

                                spin_unlock_irq(&nl->lock);

                                /* Try again later */

                                return TIMEOUT;

                        }

                        c0 = read_status(dev);

                        printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n",

                               dev->name, rcv->state, c0);

                }

                dev->stats.rx_dropped++;

        }

        rcv->state = PLIP_PK_DONE;

        if (rcv->skb) {

                kfree_skb(rcv->skb);

                rcv->skb = NULL;

        }

        snd->state = PLIP_PK_DONE;

        if (snd->skb) {

                dev_kfree_skb(snd->skb);

                snd->skb = NULL;

        }

        spin_unlock_irq(&nl->lock);

        if (error == HS_TIMEOUT) {

                DISABLE(dev->irq);

                synchronize_irq(dev->irq);

        }

        disable_parport_interrupts (dev);

        netif_stop_queue (dev);

        nl->connection = PLIP_CN_ERROR;

        write_data (dev, 0x00);

        return TIMEOUT;

}

static int

plip_none(struct net_device *dev, struct net_local *nl,

          struct plip_local *snd, struct plip_local *rcv)

{

        return OK;

}

/* PLIP_RECEIVE --- receive a byte(two nibbles)

   Returns OK on success, TIMEOUT on timeout */

static inline int

plip_receive(unsigned short nibble_timeout, struct net_device *dev,

             enum plip_nibble_state *ns_p, unsigned char *data_p)

{

        unsigned char c0, c1;

        unsigned int cx;

        switch (*ns_p) {

        case PLIP_NB_BEGIN:

                cx = nibble_timeout;

                while (1) {

                        c0 = read_status(dev);

                        udelay(PLIP_DELAY_UNIT);

                        if ((c0 & 0x80) == 0) {

                                c1 = read_status(dev);

                                if (c0 == c1)

                                        break;

                        }

                        if (--cx == 0)

                                return TIMEOUT;

                }

                *data_p = (c0 >> 3) & 0x0f;

                write_data (dev, 0x10); /* send ACK */

                *ns_p = PLIP_NB_1;

        case PLIP_NB_1:

                cx = nibble_timeout;

                while (1) {

                        c0 = read_status(dev);

                        udelay(PLIP_DELAY_UNIT);

                        if (c0 & 0x80) {

                                c1 = read_status(dev);

                                if (c0 == c1)

                                        break;

                        }

                        if (--cx == 0)

                                return TIMEOUT;

                }

                *data_p |= (c0 << 1) & 0xf0;

                write_data (dev, 0x00); /* send ACK */

                *ns_p = PLIP_NB_BEGIN;

        case PLIP_NB_2:

                break;

        }

        return OK;

}

/*

 *      Determine the packet's protocol ID. The rule here is that we

 *      assume 802.3 if the type field is short enough to be a length.

 *      This is normal practice and works for any 'now in use' protocol.

 *

 *      PLIP is ethernet ish but the daddr might not be valid if unicast.

 *      PLIP fortunately has no bus architecture (its Point-to-point).

 *

 *      We can't fix the daddr thing as that quirk (more bug) is embedded

 *      in far too many old systems not all even running Linux.

 */

static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev)

{

        struct ethhdr *eth;

        unsigned char *rawp;

        skb_reset_mac_header(skb);

        skb_pull(skb,dev->hard_header_len);

        eth = eth_hdr(skb);

        if(*eth->h_dest&1)

        {

                if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)

                        skb->pkt_type=PACKET_BROADCAST;

                else

                        skb->pkt_type=PACKET_MULTICAST;

        }

        /*

         *      This ALLMULTI check should be redundant by 1.4

         *      so don't forget to remove it.

         */

        if (ntohs(eth->h_proto) >= 1536)

                return eth->h_proto;

        rawp = skb->data;

        /*

         *      This is a magic hack to spot IPX packets. Older Novell breaks

         *      the protocol design and runs IPX over 802.3 without an 802.2 LLC

         *      layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This

         *      won't work for fault tolerant netware but does for the rest.

         */

        if (*(unsigned short *)rawp == 0xFFFF)

                return htons(ETH_P_802_3);

        /*

         *      Real 802.2 LLC

         */

        return htons(ETH_P_802_2);

}

/* PLIP_RECEIVE_PACKET --- receive a packet */

static int

plip_receive_packet(struct net_device *dev, struct net_local *nl,

                    struct plip_local *snd, struct plip_local *rcv)

{

        unsigned short nibble_timeout = nl->nibble;

        unsigned char *lbuf;

        switch (rcv->state) {

        case PLIP_PK_TRIGGER:

                DISABLE(dev->irq);

                /* Don't need to synchronize irq, as we can safely ignore it */

                disable_parport_interrupts (dev);

                write_data (dev, 0x01); /* send ACK */

                if (net_debug > 2)

                        printk(KERN_DEBUG "%s: receive start\n", dev->name);

                rcv->state = PLIP_PK_LENGTH_LSB;

                rcv->nibble = PLIP_NB_BEGIN;

        case PLIP_PK_LENGTH_LSB:

                if (snd->state != PLIP_PK_DONE) {

                        if (plip_receive(nl->trigger, dev,

                                         &rcv->nibble, &rcv->length.b.lsb)) {

                                /* collision, here dev->tbusy == 1 */

                                rcv->state = PLIP_PK_DONE;

                                nl->is_deferred = 1;

                                nl->connection = PLIP_CN_SEND;

                                schedule_delayed_work(&nl->deferred, 1);

                                enable_parport_interrupts (dev);

                                ENABLE(dev->irq);

                                return OK;

                        }

                } else {

                        if (plip_receive(nibble_timeout, dev,

                                         &rcv->nibble, &rcv->length.b.lsb))

                                return TIMEOUT;

                }

                rcv->state = PLIP_PK_LENGTH_MSB;

        case PLIP_PK_LENGTH_MSB:

                if (plip_receive(nibble_timeout, dev,

                                 &rcv->nibble, &rcv->length.b.msb))

                        return TIMEOUT;

                if (rcv->length.h > dev->mtu + dev->hard_header_len

                    || rcv->length.h < 8) {

                        printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h);

                        return ERROR;

                }

                /* Malloc up new buffer. */

                rcv->skb = dev_alloc_skb(rcv->length.h + 2);

                if (rcv->skb == NULL) {

                        printk(KERN_ERR "%s: Memory squeeze.\n", dev->name);

                        return ERROR;

                }

                skb_reserve(rcv->skb, 2);       /* Align IP on 16 byte boundaries */

                skb_put(rcv->skb,rcv->length.h);

                rcv->skb->dev = dev;

                rcv->state = PLIP_PK_DATA;

                rcv->byte = 0;

                rcv->checksum = 0;

        case PLIP_PK_DATA:

                lbuf = rcv->skb->data;

                do

                        if (plip_receive(nibble_timeout, dev,

                                         &rcv->nibble, &lbuf[rcv->byte]))

                                return TIMEOUT;

                while (++rcv->byte < rcv->length.h);

                do

                        rcv->checksum += lbuf[--rcv->byte];

                while (rcv->byte);

                rcv->state = PLIP_PK_CHECKSUM;

        case PLIP_PK_CHECKSUM:

                if (plip_receive(nibble_timeout, dev,

                                 &rcv->nibble, &rcv->data))

                        return TIMEOUT;

                if (rcv->data != rcv->checksum) {

                        dev->stats.rx_crc_errors++;

                        if (net_debug)

                                printk(KERN_DEBUG "%s: checksum error\n", dev->name);

                        return ERROR;

                }

                rcv->state = PLIP_PK_DONE;

        case PLIP_PK_DONE:

                /* Inform the upper layer for the arrival of a packet. */

                rcv->skb->protocol=plip_type_trans(rcv->skb, dev);

                netif_rx_ni(rcv->skb);

                dev->last_rx = jiffies;

                dev->stats.rx_bytes += rcv->length.h;

                dev->stats.rx_packets++;

                rcv->skb = NULL;

                if (net_debug > 2)

                        printk(KERN_DEBUG "%s: receive end\n", dev->name);

                /* Close the connection. */

                write_data (dev, 0x00);

                spin_lock_irq(&nl->lock);

                if (snd->state != PLIP_PK_DONE) {

                        nl->connection = PLIP_CN_SEND;

                        spin_unlock_irq(&nl->lock);

                        schedule_work(&nl->immediate);

                        enable_parport_interrupts (dev);

                        ENABLE(dev->irq);

                        return OK;

                } else {

                        nl->connection = PLIP_CN_NONE;

                        spin_unlock_irq(&nl->lock);

                        enable_parport_interrupts (dev);

                        ENABLE(dev->irq);

                        return OK;

                }

        }