URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [s390/] [net/] [c7000.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
        Cisco/7000 driver -- Copyright (C) 2000 UTS Global LLC.
        Author: Bob Scardapane (UTS Global LLC).
        Version: 3.
 
        To use this driver, run the LINUX command:
 
        insmod c7000 base0=0xYYYY lhost0=s1 uhost0=s2 lappl0=s3 uappl0=s4 dbg=x
 
        base0=0xYYYY defines the base unit address of the interface.
        lhost0=s1 defines the local host name.
        uhost0=s2 defines the unit host name.
        lappl0=s3 defines the local application name.
        uappl0=s4 defines the unit application name.
        dbg=x defines the message level.  Higher values will result in
        additional diagnostic messages.
 
        Additional interfaces are defined on insmod by using the variable
        name groups "base1,lhost1,lappl1,uhost1,uappl1", etc... up to three
        additional groups.
 
        In addition, the module will automatically detect the unit base
        addresses by scanning all active irq's for a control unit type
        of 0x3088 and a model of 0x61 (CLAW mode). The noauto parameter
        can be used to suppress automatic detection.
 
        The values of lhostx, lapplx, uhostx and uapplx default to:
 
        lapplx - TCPIP
        lhostx - UTS
        uapplx - TCPIP
        uhostx - C7011
 
        Note that the values passed in the insmod command will always
        override the automatic detection of the unit base addreeses and
        the default values of lapplx, lhostx, uapplx and uhostx.
 
        The parameter noauto can be used to disable automatic detection of
        devices:
 
        noauto=1 (disable automatic detection)
        noauto=0 (Enable automatic detectio.  This is the default value.)
 
        The values in base0 - base3 will be copied to the bases array when
        the module is loaded.
 
        To configure the interface(s), run the LINUX command(s):
 
        ifconfig ci0 ...
        ifconfig ci1 ...
        ifconfig ci2 ...
        ifconfig ci3 ...
 
        There is one device structure for each controller in the c7000_devices
        array.  The base address of each controller is in the bases array.
        These arrays parallel each other.  There is also one c7000_controller
        structure for each controller.  This structure is pointed to by field
        priv in the individual device structure.
 
        In each c7000_controller, there are embedded c7000_unit structures.
        There is one c7000_unit structure per device number that makes up
        a controller (currently 2 units per controller).
*/
 
#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/string.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>
#include <linux/tcp.h>
#include <linux/skbuff.h>
#include <asm/io.h>
#include <asm/bitops.h>
#include <asm/irq.h>
 
/*
        Global defines
*/
 
/*
        Maximum number of controllers.
*/
 
#define MAX_C7000       4
 
/*
        Number of units per controller.
*/
 
#define NUNITS          2
 
/*
        Define indexes of read and write units in the cunits array.
*/
 
#define C7000_RD        0
#define C7000_WR        1
 
/*
        Number of device buffers.
*/
 
#define C7000_MAXBUF    40
 
/*
        Transmission queue length.
*/
 
#define C7000_TXQUEUE_LEN       100
/*
        Size of the IP packet data.
*/
 
#define C7000_DATAL     4096
 
/*
        Size of the read header data.
*/
 
#define C7000_READHDRL  4
 
/*
        Size of read flag byte.
*/
 
#define C7000_READFFL   1
 
/*
        Size of a device buffer.  This is how it is arranged in memory:
        4096 (IP packet data) + 4 (read header) + 1 (read flag) = 4101.
*/
 
#define C7000_BUFSIZE   C7000_DATAL + C7000_READHDRL + C7000_READFFL
 
/*
        Size of sigsmod data.
*/
 
#define C7000_SIGSMODL  1
 
/*
        Flag value that indicates a read was completed in the flag
        field of a c7000_rd_header.
*/
 
#define FLAG_FF         0xff
/*
        Size of C7000 sense id data.
*/
 
#define SIDL            32
 
/*
        Maximum number of read and write retries.
*/
 
#define C7000_MAX_RETRIES       3
 
/*
        Define sense byte0 value for a box reset.
*/
 
#define C7000_BOX_RESET         0x41
 
/*
        CCW commands.
*/
 
#define C7000_WRITE_CCW         0x01    /* normal write */
#define C7000_READ_CCW          0x02    /* normal read */
#define C7000_NOOP_CCW          0x03    /* no operation */
#define C7000_SIGSMOD_CCW       0x05    /* signal status modifier */
#define C7000_TIC_CCW           0x08    /* transfer in channel */
#define C7000_READHDR_CCW       0x12    /* read header  */
#define C7000_READFF_CCW        0x22    /* read FF flag */
#define C7000_SID_CCW           0xe4    /* sense identification */
 
/*
        Control commands.
*/
 
#define C7000_SYS_VALIDATE              1
#define C7000_SYS_VALIDATE_RESP         2
#define C7000_CONN_REQ                  33
#define C7000_CONN_RESP                 34
#define C7000_CONN_CONFRM               35
#define C7000_DISCONN                   36
#define C7000_BOXERROR                  65
 
/*
        State machine values.
*/
 
#define C7000_INIT      1
#define C7000_HALT      2
#define C7000_SID       3
#define C7000_SYSVAL    4
#define C7000_CONNECT   5
#define C7000_READY     6
#define C7000_READ      7
#define C7000_WRITE     8
#define C7000_DISC      9
#define C7000_STOP      10
#define C7000_STOPPED   11
#define C7000_ERROR     12
 
/*
        The lower subchannel is used for read operations and the one that is
        one higher is used for write operations.
 
        Both subchannels are initially in state C7000_INIT.  A transition to
        state C7000_HALT occurs when halt_IO is issued on each.  When the
        halts completes a transition to state C7000_SID occurs and a channel
        program is issued to do a sense identification on both subchannels.
 
        When the sense identification completes, the state C7000_SYSVAL is
        entered on the read subchannel.  A read channel program is issued.
 
        When the sense identification completes, the write subchannel enters
        state C7000_SYSVAL and a system validation request is written.  The
        read subchannel is also put into this state.
 
        When both the system validation response is read and an inbound system
        validation request is read, the inbound system validation request is
        responded to and both subchannels enter the C7000_CONNECT state.
 
        A read channel program is posted to look for the inbound connect
        request.  When that is received a connection confirmation is written.
        The state of both subchannels is then changed to C7000_READY.  A
        read channel program is then posted and the state is changed to
        C7000_READ.  When a read completes, the packet is sent to the higher
        layers and the read channel program is restarted.
 
        When there is a packet to be written, state C7000_WRITE is entered
        and a channel program is issued to write the data.  The subchannel
        is in state C7000_READY when there is nothing to be written.
 
        When the stop method is executed, a disconnect message is sent and
        the state is changed to C7000_DISC in both subchannels.  A halt_IO
        will be issued to both subchannels and state C7000_STOP will be entered.
        When the halt IO completes, state C7000_STOPPED will be set.
 
        State C7000_ERROR is set when an error occurs in the interrupt
        routine.  Recycle the interface (ifconfig down / ifconfig up)
        to reset this state.
*/
 
/*
        Results from c7000_check_csw.
*/
 
enum    c7000_rupt {
        C7000_NORMAL,
        C7000_CHANERR,
        C7000_UCK,
        C7000_UCK_RESET,
        C7000_UE,
        C7000_ATTN,
        C7000_BUSY,
        C7000_OTHER
};
 
/*
        Bits set in device structure tbusy field.
*/
 
#define TB_TX           0        /* sk buffer handling in progress */
#define TB_STOP         1       /* network device stop in progress */
#define TB_RETRY        2       /* retry in progress */
#define TB_NOBUFFER     3       /* no buffer on free queue */
 
/*
        Bit in c7000_unit.flag_a that indicates the bh routine is busy.
*/
 
#define C7000_BH_ACTIVE 0
 
#define CPrintk(level, args...) \
        if (level <= dbg) \
                printk(args)
 
/*
        Maximum length of a system validation string.
*/
 
#define NAMLEN  8
 
#define Err_Conn_Confirm        1
#define Err_Names_not_Matched   166
#define Err_C7000_NOT_READY     167
#define Err_Duplicate           170
#define Err_Closing             171
#define Err_No_Such_App         172
#define Err_Host_Not_Ready      173
#define Err_CLOSING             174
#define Err_Dup_Link            175
#define Err_Wrong_Version       179
#define Err_Wrong_Frame_Size    180
 
/*
        Define a macro to extract the logical link identifier from
        the c7000 read header command field.
*/
 
#define C7000_LINKID(cmd)       ((unsigned char)cmd >> 3)
 
/*
        Define the control unit type for a Cisco 7000.
*/
 
#define C7000_CU_TYPE           0x3088
 
/*
        Define the control unit model for a Cisco 7000.
*/
 
#define C7000_CU_MODEL          0x61
 
/*
        Define the default system validate parameters (lapplx,
        lhostx, uapplx, uhostx).
*/
 
#define C7000_DFLT_LAPPL        "TCPIP"
#define C7000_DFLT_LHOST        "UTS"
#define C7000_DFLT_UAPPL        "TCPIP"
#define C7000_DFLT_UHOST        "C7011"
 
/*
        Global variables.
*/
 
/*
        Base device addresses of the controllers.
*/
 
static int      base0 = -1;
static int      base1 = -1;
static int      base2 = -1;
static int      base3 = -1;
 
static int      bases[MAX_C7000];
 
/*
        Local application names.
*/
 
static char     *lappl0;
static char     *lappl1;
static char     *lappl2;
static char     *lappl3;
 
/*
        Local host names.
*/
 
static char     *lhost0;
static char     *lhost1;
static char     *lhost2;
static char     *lhost3;
 
/*
        Unit application names.
*/
 
static char     *uappl0;
static char     *uappl1;
static char     *uappl2;
static char     *uappl3;
 
/*
        Unit hosts names.
*/
 
static char     *uhost0;
static char     *uhost1;
static char     *uhost2;
static char     *uhost3;
 
/*
        Debugging level (higher numbers emit lower priority messages).
*/
 
static unsigned int     dbg = 0;
 
/*
        Parameter that controls auto detection.
*/
 
static int      noauto = 0;
 
/*
        Interface names.
*/
 
static char     ifnames[MAX_C7000][8] = {"ci0", "ci1", "ci2", "ci3"};
 
/*
        One device structure per controller.
*/
 
/* RBH Try out the new code for 2.4.0 */
#define NEWSTUFF
 
#ifdef NEWSTUFF
#define STRUCT_NET_DEVICE struct net_device
#else
#define STRUCT_NET_DEVICE struct device
#endif
 
STRUCT_NET_DEVICE       c7000_devices[MAX_C7000];
 
/*
        Scratch variable filled in with controller name.
*/
 
static char     *controller;
 
/*
        Identify parameters that can be passed on the LINUX insmod command.
*/
 
MODULE_AUTHOR("Robert Scardapane (UTS Global)");
MODULE_DESCRIPTION("Network module for Cisco 7000 box.");
 
MODULE_PARM(base0, "1i");
MODULE_PARM_DESC(base0, "Base unit address for 1st C7000 box.");
MODULE_PARM(base1, "1i");
MODULE_PARM_DESC(base1, "Base unit address for 2nd C7000 box.");
MODULE_PARM(base2, "1i");
MODULE_PARM_DESC(base2, "Base unit address for 3rd C7000 box.");
MODULE_PARM(base3, "1i");
MODULE_PARM_DESC(base3, "Base unit address for 4th C7000 box.");
 
MODULE_PARM(lappl0, "s");
MODULE_PARM_DESC(lappl0, "Application name for 1st C7000 box.");
MODULE_PARM(lappl1, "s");
MODULE_PARM_DESC(lappl1, "Application name for 2nd C7000 box.");
MODULE_PARM(lappl2, "s");
MODULE_PARM_DESC(lappl2, "Application name for 3rd C7000 box.");
MODULE_PARM(lappl3, "s");
MODULE_PARM_DESC(lappl3, "Application name for 4th C7000 box.");
 
MODULE_PARM(lhost0, "s");
MODULE_PARM_DESC(lhost0, "Host name for 1st C7000 box.");
MODULE_PARM(lhost1, "s");
MODULE_PARM_DESC(lhost1, "Host name for 2nd C7000 box.");
MODULE_PARM(lhost2, "s");
MODULE_PARM_DESC(lhost2, "Host name for 3rd C7000 box.");
MODULE_PARM(lhost3, "s");
MODULE_PARM_DESC(lhost3, "Host name for 4th C7000 box.");
 
MODULE_PARM(uhost0, "s");
MODULE_PARM_DESC(uhost0, "Unit name for 1st C7000 box.");
MODULE_PARM(uhost1, "s");
MODULE_PARM_DESC(uhost1, "Unit name for 2nd C7000 box.");
MODULE_PARM(uhost2, "s");
MODULE_PARM_DESC(uhost2, "Unit name for 3rd C7000 box.");
MODULE_PARM(uhost3, "s");
MODULE_PARM_DESC(uhost3, "Unit name for 4th C7000 box.");
 
MODULE_PARM(uappl0, "s");
MODULE_PARM_DESC(uappl0, "Unit application name for 1st C7000 box.");
MODULE_PARM(uappl1, "s");
MODULE_PARM_DESC(uappl1, "Unit application name for 2nd C7000 box.");
MODULE_PARM(uappl2, "s");
MODULE_PARM_DESC(uappl2, "Unit application name for 3rd C7000 box.");
MODULE_PARM(uappl3, "s");
MODULE_PARM_DESC(uappl3, "Unit application name for 4th C7000 box.");
 
MODULE_PARM(dbg, "1i");
MODULE_PARM_DESC(dbg, "Message level for debugging.");
 
MODULE_PARM(noauto, "1i");
MODULE_PARM_DESC(noauto, "Control automatic detection of unit base addresses.");
 
/*
        Structure used to manage unit buffers.
*/
 
struct  c7000_buffer {
        ccw1_t                  ccws[7];        /* channel program */
        struct  c7000_buffer    *next;          /* list pointer */
        char                    *data;          /* pointer to actual data */
        int                     len;            /* length of the data */
};
 
/*
        C7000 Control Block.
 */
 
struct  c7000_control_blk {
        unsigned char   cmd;
        unsigned char   ver;
        unsigned char   link_id;
        unsigned char   correlator;
        unsigned char   ret_code;
        unsigned char   resvd1[3];
        unsigned char   unitname[NAMLEN];
        unsigned char   hostname[NAMLEN];
        unsigned short  rdsize;         /* read frame size   */
        unsigned short  wrtsize;        /* write frame size  */
        unsigned char   resvd2[4];
};
 
/*
        Per unit structure contained within the c7000_controller structure.
*/
 
struct  c7000_unit {
        ccw1_t                          ccws[5];        /* control ccws */
        int                             devno;          /* device number */
        int                             irq;            /* subchannel number */
        int                             IO_active;      /* IO activity flag */
        int                             state;          /* fsm state */
        int                             retries;        /* retry counter */
        unsigned long                   flag_a;         /* bh activity flag */
        devstat_t                       devstat;        /* device status */
#ifdef NEWSTUFF
        wait_queue_head_t               wait;           /* sleep q head */
#else
        struct wait_queue               *wait;          /* sleep q pointer */
#endif
        struct c7000_controller         *cntlp;         /* controller pointer */
        struct c7000_buffer             *free;          /* free buffer anchor */
        struct c7000_buffer             *proc_head;     /* proc head */
        struct c7000_buffer             *proc_tail;     /* proc tail */
        struct c7000_buffer             *bh_head;       /* bh head */
        struct c7000_buffer             *bh_tail;       /* bh tail */
        struct tq_struct                tq;             /* bh scheduling */
        char                            senseid[SIDL];  /* sense id data */
        struct c7000_control_blk        control_blk;    /* control block */
        unsigned char                   sigsmod;        /* sigsmod flag */
        unsigned char                   readhdr[4];     /* read header */
        unsigned char                   readff;         /* readff flag */
};
 
/*
        Private structure pointed to by dev->priv.
*/
 
struct c7000_controller {
        struct  net_device_stats        stats;          /* statistics */
        STRUCT_NET_DEVICE               *dev;           /* -> device struct */
        unsigned int                    base_addr;      /* base address */
        char                            lappl[NAMLEN];  /* local appl */
        char                            lhost[NAMLEN];  /* local host */
        char                            uappl[NAMLEN];  /* unit appl */
        char                            uhost[NAMLEN];  /* unit host */
        unsigned char                   version;        /* version = 2 */
        unsigned char                   linkid;         /* link id */
        struct  c7000_unit              cunits[NUNITS]; /* embedded units */
#ifdef NEWSTUFF
        int                             tbusy;
#endif
};
 
/*
        This is the structure returned by the C7000_READHDR_CCW.
*/
 
struct  c7000_rd_header {
        unsigned short  len;    /* packet length */
        unsigned char   cmd;    /* command code */
        unsigned char   flag;   /* flag */
};
 
/*
        Set the device structure transmission busy flag.
*/
 
#ifdef NEWSTUFF
#define c7000_set_busy(dev) netif_stop_queue(dev)
#else
static __inline__ void
c7000_set_busy(STRUCT_NET_DEVICE *dev)
{
        dev->tbusy = 1;
        eieio();
        return;
}
#endif
 
/*
        Clear the device structure transmission busy flag.
*/
 
#ifdef NEWSTUFF
#define c7000_clear_busy(dev) netif_wake_queue(dev)
#else
static __inline__ void
c7000_clear_busy(STRUCT_NET_DEVICE *dev)
{
        dev->tbusy = 0;
        eieio();
        return;
}
#endif
 
/*
        Extract the device structure transmission busy flag.
*/
 
#ifdef NEWSTUFF
#define c7000_check_busy(dev) netif_queue_stopped(dev)
#else
static __inline__ int
c7000_check_busy(STRUCT_NET_DEVICE *dev)
{
        eieio();
        return(dev->tbusy);
}
#endif
 
/*
        Set a bit in the device structure transmission busy flag.
*/
 
static __inline__ void
c7000_setbit_busy(int nr, STRUCT_NET_DEVICE *dev)
{
#ifdef NEWSTUFF
        netif_stop_queue(dev);
        test_and_set_bit(nr, &((struct c7000_controller *)dev->priv)->tbusy);
#else
        set_bit(nr, (void *)&dev->tbusy);
#endif
        return;
}
 
/*
        Clear a bit in the device structure transmission busy flag.
*/
 
static __inline__ void
c7000_clearbit_busy(int nr, STRUCT_NET_DEVICE *dev)
{
#ifdef NEWSTUFF
        clear_bit(nr, &((struct c7000_controller *)dev->priv)->tbusy);
        netif_wake_queue(dev);
#else
        clear_bit(nr, (void *)&dev->tbusy);
#endif
        return;
}
 
/*
        Test and set a bit in the device structure transmission busy flag.
*/
 
static __inline__ int
c7000_ts_busy(int nr, STRUCT_NET_DEVICE *dev)
{
#ifdef NEWSTUFF
        netif_stop_queue(dev);
        return test_and_set_bit(nr, &((struct c7000_controller *)dev->priv)->tbusy);
#else
        return(test_and_set_bit(nr, (void *)&dev->tbusy));
#endif
}
 
/*
        Set the C7000 controller in the error state.
*/
 
static void
c7000_error(struct c7000_controller *ccp)
{
        int                     i;
        struct  c7000_unit      *cup;
        STRUCT_NET_DEVICE       *dev = ccp->dev;
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
                cup->state = C7000_ERROR;
        }
 
        if (dev != NULL)
#ifdef NEWSTUFF
                /* RBH XXX Should we be doing this? */
                dev->state &= ~__LINK_STATE_START;
#else
                dev->flags &= ~IFF_RUNNING;
#endif
 
        CPrintk(0, "c7000: c7000_error: base unit 0x%x is down\n", ccp->base_addr);
        return;
}
 
/*
        Based on the SENSE ID information, fill in the
        controller name.  Note that this is the SENSE ID
        information saved by LINUX/390 at boot time.
*/
 
static int
c7000_check_type(senseid_t *id)
{
 
        switch (id->cu_type) {
 
                case C7000_CU_TYPE:
 
                        if (id->cu_model == C7000_CU_MODEL) {
                                controller = "C7000  ";
                                return(0);
                        }
 
                        break;
 
                default:
                        break;
        }
 
        return(-1);
}
 
/*
        Check the device information for the controller.
*/
 
static int
c7000_check_devices(int devno)
{
        int             i;
        s390_dev_info_t temp;
 
        /*
                Get the SENSE ID information for each device.
        */
 
        for (i = devno; i < (devno + NUNITS); i++) {
 
                if (get_dev_info_by_devno(devno, &temp) != 0)
                        return(-1);
 
                if (c7000_check_type(&temp.sid_data) == -1)
                        return(-1);
        }
 
        CPrintk(1, "c7000: c7000_check_devices: device type is %s\n", controller);
        return(0);
}
 
/*
        Issue a halt I/O to device pointed to by cup.
*/
 
static int
c7000_haltio(struct c7000_unit *cup)
{
        __u32                   parm;
        __u8                    flags = 0x00;
        __u32                   saveflags;
        DECLARE_WAITQUEUE(wait, current);
        int                     rc;
 
        s390irq_spin_lock_irqsave(cup->irq, saveflags);
        parm = (unsigned long)cup;
 
        if ((rc = halt_IO(cup->irq, parm, flags)) != 0) {
                s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                return(rc);
        }
 
        /*
                Wait for the halt I/O to finish.
        */
 
        add_wait_queue(&cup->wait, &wait);
        current->state = TASK_UNINTERRUPTIBLE;
        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
        schedule();
        remove_wait_queue(&cup->wait, &wait);
        return(0);
}
 
/*
        Issue a start I/O to device pointed to by cup.
*/
 
static int
c7000_doio(struct c7000_unit *cup)
{
        __u32                   parm;
        __u8                    flags = 0x00;
        __u32                   saveflags;
        DECLARE_WAITQUEUE(wait, current);
        int                     rc;
 
        /*
                Do no further I/O while the device is in the ERROR, STOP
                or STOPPED state.
        */
 
        if (cup->state == C7000_ERROR || cup->state == C7000_STOP || cup->state == C7000_STOPPED)
                return(-1);
 
        s390irq_spin_lock_irqsave(cup->irq, saveflags);
        parm = (unsigned long)cup;
 
        if ((rc = do_IO(cup->irq, &cup->ccws[0], parm, 0xff, flags)) != 0) {
                s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                return(rc);
        }
 
        /*
                Wait for the I/O to complete.
        */
 
        add_wait_queue(&cup->wait, &wait);
        current->state = TASK_UNINTERRUPTIBLE;
        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
        schedule();
        remove_wait_queue(&cup->wait, &wait);
 
        /*
                Interrupt handling may have marked the device in ERROR.
        */
 
        if (cup->state == C7000_ERROR)
                return(-1);
 
        return(0);
}
 
/*
        Build a channel program to do a sense id channel program.
*/
 
static void
c7000_bld_senseid_chpgm(struct c7000_unit *cup)
{
        ccw1_t  *ccwp;
 
        ccwp = &cup->ccws[0];
        ccwp->cmd_code = C7000_SID_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->senseid);
        ccwp->count = SIDL;
        ccwp++;
        ccwp->cmd_code = C7000_NOOP_CCW;
        ccwp->flags = CCW_FLAG_SLI;
        ccwp->cda = (__u32)NULL;
        ccwp->count = 1;
        return;
}
 
/*
        Build a channel program to write a control message.
*/
 
static void
c7000_bld_wrtctl_chpgm(struct c7000_unit *cup)
{
        ccw1_t  *ccwp;
 
        ccwp = &cup->ccws[0];
        ccwp->cmd_code = C7000_WRITE_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->control_blk);
        ccwp->count = sizeof(struct c7000_control_blk);
        ccwp++;
        ccwp->cmd_code = C7000_READFF_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->readff);
        ccwp->count = C7000_READFFL;
        ccwp++;
        ccwp->cmd_code = C7000_TIC_CCW;
        ccwp->flags = 0;
        ccwp->cda = (__u32)virt_to_phys(ccwp + 1);
        ccwp->count = 0;
        ccwp++;
        ccwp->cmd_code = C7000_NOOP_CCW;
        ccwp->flags = CCW_FLAG_SLI;
        ccwp->cda = (__u32)NULL;
        ccwp->count = 1;
        return;
}
 
/*
        Build a write channel program to write the indicated buffer.
*/
 
static void
c7000_bld_wrt_chpgm(struct c7000_unit *cup, struct c7000_buffer *buf)
{
        ccw1_t                          *ccwp;
        struct  c7000_controller        *ccp = cup->cntlp;
 
        ccwp = &buf->ccws[0];
        ccwp->cmd_code = C7000_WRITE_CCW | (ccp->linkid << 3);
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(buf->data);
        ccwp->count = buf->len;
        ccwp++;
        ccwp->cmd_code = C7000_READFF_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(buf->data + C7000_DATAL + C7000_READHDRL);
        ccwp->count = C7000_READFFL;
        ccwp++;
        ccwp->cmd_code = C7000_TIC_CCW;
        ccwp->flags = 0;
        ccwp->cda = (__u32)virt_to_phys(ccwp + 1);
        ccwp->count = 0;
        ccwp++;
        ccwp->cmd_code = C7000_NOOP_CCW;
        ccwp->flags = (CCW_FLAG_SLI);
        ccwp->cda = (__u32)NULL;
        ccwp->count = 1;
        return;
}
 
/*
        Build a channel program to read a control message.
*/
 
static void
c7000_bld_readctl_chpgm(struct c7000_unit *cup)
{
        ccw1_t  *ccwp;
 
        ccwp = &cup->ccws[0];
        ccwp->cmd_code = C7000_READ_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->control_blk);
        ccwp->count = sizeof(struct c7000_control_blk);
        ccwp++;
        ccwp->cmd_code = C7000_READHDR_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->readhdr);
        ccwp->count = C7000_READHDRL;
        ccwp++;
        ccwp->cmd_code = C7000_SIGSMOD_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->sigsmod);
        ccwp->count = C7000_SIGSMODL;
        ccwp++;
        ccwp->cmd_code = C7000_TIC_CCW;
        ccwp->flags = 0;
        ccwp->cda = (__u32)virt_to_phys(ccwp + 1);
        ccwp->count = 0;
        ccwp++;
        ccwp->cmd_code = C7000_NOOP_CCW;
        ccwp->flags = (CCW_FLAG_SLI);
        ccwp->cda = (__u32)NULL;
        ccwp->count = 1;
        return;
}
 
/*
        Build a channel program to read the indicated buffer.
*/
 
static void
c7000_bld_read_chpgm(struct c7000_unit *cup, struct c7000_buffer *buf)
{
        ccw1_t  *ccwp;
 
        ccwp = &buf->ccws[0];
        ccwp->cmd_code = C7000_READ_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(buf->data);
        ccwp->count = C7000_DATAL;
        ccwp++;
        ccwp->cmd_code = C7000_READHDR_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(buf->data + C7000_DATAL);
        ccwp->count = C7000_READHDRL;
        ccwp++;
        ccwp->cmd_code = C7000_SIGSMOD_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC);
        ccwp->cda = (__u32)virt_to_phys(&cup->sigsmod);
        ccwp->count = C7000_SIGSMODL;
        ccwp++;
        ccwp->cmd_code = C7000_TIC_CCW;
        ccwp->flags = 0;
        ccwp->cda = (__u32)virt_to_phys(ccwp + 3);
        ccwp->count = 0;
        ccwp++;
        ccwp->cmd_code = C7000_READFF_CCW;
        ccwp->flags = (CCW_FLAG_SLI | CCW_FLAG_CC | CCW_FLAG_PCI);
        ccwp->cda = (__u32)virt_to_phys(&cup->readff);
        ccwp->count = C7000_READFFL;
        ccwp++;
        ccwp->cmd_code = C7000_TIC_CCW;
        ccwp->flags = 0;
        ccwp->cda = (__u32)virt_to_phys(ccwp + 1);
        ccwp->count = 0;
        ccwp++;
        ccwp->cmd_code = C7000_NOOP_CCW;
        ccwp->flags = (CCW_FLAG_SLI);
        ccwp->cda = (__u32)NULL;
        ccwp->count = 1;
        return;
}
 
/*
        Allocate buffer structure headers and buffers for all units
        A return value of 0 means that all allocations worked.  A -1
        means that an allocation failed.  It is expected that the caller
        will call c7000_free_buffers when -1 is returned.
*/
 
static int
c7000_alloc_buffers(STRUCT_NET_DEVICE *dev)
{
        int                             i;
        int                             j;
        char                            *data;
        struct  c7000_buffer            *bufptr;
        struct  c7000_controller        *ccp = (struct c7000_controller *) dev->priv;
        struct  c7000_unit              *cup;
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
                cup->free = NULL;
 
                for (j = 0; j < C7000_MAXBUF; j++) {
                        bufptr = kmalloc(sizeof(struct c7000_buffer), GFP_KERNEL);
                        data = kmalloc(C7000_BUFSIZE, GFP_KERNEL);
 
                        if (bufptr == NULL)
                        {
                                if(data)
                                        kfree(data);
                                return(-1);
                        }
 
                        /*
                                Place filled in buffer header on free anchor.
                        */
 
                        bufptr->next = cup->free;
                        bufptr->data = data;
                        bufptr->len = 0;
                        cup->free = bufptr;
 
                        if (data == NULL)
                                return(-1);
 
                        memset(data, '\0', C7000_BUFSIZE);
                }
 
        }
 
        CPrintk(1, "c7000: c7000_alloc_buffers: allocated buffers for base unit 0x%lx\n", dev->base_addr);
        return(0);
}
 
/*
        Free buffers on a chain.
*/
 
static void
c7000_free_chain(struct c7000_buffer *buf)
{
        char                    *data;
        struct  c7000_buffer    *bufptr = buf;
        struct  c7000_buffer    *tmp;
 
        while (bufptr != NULL) {
                data = bufptr->data;
 
                if (data != NULL)
                        kfree(data);
 
                tmp = bufptr;
                bufptr = bufptr->next;
                kfree(tmp);
        }
 
        return;
}
 
/*
        Free buffers on all possible chains for all units.
*/
 
static void
c7000_free_buffers(STRUCT_NET_DEVICE *dev)
{
        int                             i;
        struct  c7000_controller        *ccp = (struct c7000_controller *) dev->priv;
        struct  c7000_unit      *cup;
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
                c7000_free_chain(cup->free);
                cup->free = NULL;
                c7000_free_chain(cup->proc_head);
                cup->proc_head = cup->proc_tail = NULL;
                c7000_free_chain(cup->bh_head);
                cup->bh_head = cup->bh_tail = NULL;
        }
 
        CPrintk(1, "c7000: c7000_free_buffers: freed buffers for base unit 0x%lx\n", dev->base_addr);
        return;
}
 
/*
        Obtain a free buffer.  Return a pointer to the c7000_buffer
        structure OR NULL.
*/
 
struct c7000_buffer *
c7000_get_buffer(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf;
 
        buf = cup->free;
 
        if (buf == NULL)
                return(NULL);
 
        cup->free = buf->next;
        buf->next = NULL;
        return(buf);
}
 
/*
        Release a buffer to the free list.
*/
 
void
c7000_release_buffer(struct c7000_unit *cup, struct c7000_buffer *buf)
{
        struct  c7000_buffer    *tmp;
 
        tmp = cup->free;
        cup->free = buf;
        buf->next = tmp;
        return;
}
 
/*
        Queue a buffer on the end of the processing (proc) chain.
*/
 
void
c7000_queue_buffer(struct c7000_unit *cup, struct c7000_buffer *buf)
{
        buf->next = NULL;
 
        if (cup->proc_head == NULL) {
                cup->proc_head = cup->proc_tail = buf;
                return;
        }
 
        cup->proc_tail->next = buf;
        cup->proc_tail = buf;
        return;
}
 
/*
        Dequeue a buffer from the start of the processing (proc) chain.
*/
 
struct c7000_buffer *
c7000_dequeue_buffer(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf = cup->proc_head;
 
        if (buf == NULL)
                return(NULL);
 
        cup->proc_head = buf->next;
 
        if (cup->proc_head == NULL)
                cup->proc_tail = NULL;
 
        buf->next = NULL;
        return(buf);
}
 
/*
        Queue a buffer on the end of the bh routine chain.
*/
 
void
c7000_queue_bh_buffer(struct c7000_unit *cup, struct c7000_buffer *buf)
{
        buf->next = NULL;
 
        if (cup->bh_head == NULL) {
                cup->bh_head = cup->bh_tail = buf;
                return;
        }
 
        cup->bh_tail->next = buf;
        cup->bh_tail = buf;
        return;
}
 
/*
        Dequeue a buffer from the start of the bh routine chain.
*/
 
struct c7000_buffer *
c7000_dequeue_bh_buffer(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf = cup->bh_head;
 
        if (buf == NULL)
                return(NULL);
 
        cup->bh_head = buf->next;
 
        if (cup->bh_head == NULL)
                cup->bh_tail = NULL;
 
        buf->next = NULL;
        return(buf);
}
 
/*
        Build up a list of buffers to read.  Each buffer is described
        by one c7000_buffer structure.  The c7000_buffer structure
        contains a channel segment that will read that one buffer.
        The channel program segments are chained together via TIC
        CCWS.
*/
 
static int
c7000_bld_read_chain(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf, *pbuf = NULL;
        struct  c7000_rd_header *head;
        int                     num = 0;
 
        while (cup->free != NULL) {
 
                /*
                        Obtain a buffer for a read channel segment.
                */
 
                if ((buf = c7000_get_buffer(cup)) == NULL) {
                        CPrintk(0, "c7000: c7000_bld_read_chain: can not obtain a read buffer for unit 0x%x\n", cup->devno);
                        return(-ENOMEM);
                }
 
                num++;
                buf->len = 0;
 
                /*
                        Clear out the read header flag.
                */
 
                head = (struct c7000_rd_header *)(buf->data + C7000_DATAL);
                head->flag = 0x00;
                c7000_queue_buffer(cup, buf);
 
                /*
                        Build the read channel program segment.
                */
 
                c7000_bld_read_chpgm(cup, buf);
 
                /*
                        Chain the prior (if any) channel program segment to
                        this one.
                */
 
                if (pbuf != NULL)
                        pbuf->ccws[3].cda = pbuf->ccws[5].cda = (__u32)virt_to_phys(&buf->ccws[0]);
 
                pbuf = buf;
        }
 
        CPrintk(1, "c7000: c7000_bld_read_chain: chained %d buffers for unit 0x%x\n", num, cup->devno);
        return(0);
}
 
/*
        Build up a list of buffers to write.  Each buffer is described
        by one c7000_buffer structure.  The c7000_buffer structure
        contains a channel segment that will write that one buffer.
        The channel program segments are chained together via TIC
        CCWS.
*/
 
static void
c7000_bld_wrt_chain(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf = cup->proc_head, *pbuf = NULL;
        int                     num = 0;
 
        while (buf != NULL) {
                c7000_bld_wrt_chpgm(cup, buf);
 
                /*
                        Chain the channel program segments together.
                */
 
                if (pbuf != NULL)
                        pbuf->ccws[2].cda = (__u32)virt_to_phys(&buf->ccws[0]);
 
                pbuf = buf;
                buf = buf->next;
                num++;
        }
 
        CPrintk(1, "c7000: c7000_bld_wrt_chain: chained %d buffers for unit 0x%x\n", num, cup->devno);
        return;
}
 
/*
        Interrupt handler bottom half (bh) routine.
        Process all of the buffers on the c7000_unit bh chain.
        The bh chain is populated by the interrupt routine when
        a READ channel program completes on a buffer.
*/
 
static void
c7000_irq_bh(struct c7000_unit *cup)
{
        struct  c7000_buffer            *buf, *pbuf;
        struct  c7000_rd_header         *head;
        struct  sk_buff                 *skb;
        struct  c7000_controller        *ccp;
        STRUCT_NET_DEVICE               *dev;
        int                             rc;
        __u16                           data_length;
        __u32                           parm;
        __u8                            flags = 0x00;
        __u32                           saveflags;
 
        ccp = cup->cntlp;
        dev = ccp->dev;
 
        s390irq_spin_lock_irqsave(cup->irq, saveflags);
 
        /*
                Process all buffers sent to bh by the interrupt routine.
        */
 
        while (cup->bh_head != NULL) {
                buf = c7000_dequeue_bh_buffer(cup);
 
                /*
                        Deference the data as a c7000 header.
                */
 
                head = (struct c7000_rd_header *)(buf->data + C7000_DATAL);
 
                /*
                        If it is a control message, release the buffer and
                        continue the loop.
                */
 
                if (C7000_LINKID(head->cmd) == 0) {
                        CPrintk(0, "c7000: c7000_irq_bh: unexpected control command %d on unit 0x%x\n", head->cmd, cup->devno);
                        c7000_release_buffer(cup, buf);
                        continue;
                }
 
                /*
                        Allocate a socket buffer.
                */
 
                data_length = head->len;
                skb = dev_alloc_skb(data_length);
 
                /*
                        Copy the data to the skb.
                        Send it to the upper layers.
                */
 
                if (skb != NULL) {
                        memcpy(skb_put(skb, data_length), buf->data, data_length);
                        skb->dev = dev;
                        skb->protocol = htons(ETH_P_IP);
                        skb->pkt_type = PACKET_HOST;
                        skb->mac.raw = skb->data;
                        skb->ip_summed = CHECKSUM_UNNECESSARY;
                        netif_rx(skb);
                        ccp->stats.rx_packets++;
                } else {
                        CPrintk(0, "c7000: c7000_irq_bh: can not allocate a skb for unit 0x%x\n", cup->devno);
                        ccp->stats.rx_dropped++;
                }
 
                /*
                        Rechain the buffer on the processing list.
                */
 
                head->flag = 0x00;
                buf->len = 0;
                pbuf = cup->proc_tail;
                c7000_queue_buffer(cup, buf);
 
                /*
                        Rechain the buffer on the running channel program.
                */
 
                if (pbuf != NULL)
                        pbuf->ccws[3].cda = pbuf->ccws[5].cda = (__u32)virt_to_phys(&buf->ccws[0]);
 
        }
 
        /*
                Restart the READ channel program if IO_active is 0.
        */
 
        if (test_and_set_bit(0, (void *)&cup->IO_active) == 0) {
 
                if ((rc = c7000_bld_read_chain(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_irq_bh: can not build read chain for unit 0x%x, return code %d\n", cup->devno, rc);
                        c7000_error(cup->cntlp);
                        clear_bit(C7000_BH_ACTIVE, (void *)&cup->flag_a);
                        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                        return;
                }
 
                parm = (__u32)cup;
                cup->state = C7000_READ;
 
                if ((rc = do_IO(cup->irq, &cup->proc_head->ccws[0], parm, 0xff, flags)) != 0) {
                        CPrintk(0, "c7000: c7000_irq_bh: can not start READ IO to unit 0x%x, return code %d\n", cup->devno, rc);
                        c7000_error(cup->cntlp);
                        clear_bit(C7000_BH_ACTIVE, (void *)&cup->flag_a);
                        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                        return;
                }
 
                CPrintk(1, "c7000: c7000_irq_bh: started READ IO to unit 0x%x\n", cup->devno);
        }
 
        /*
                Clear the bh active indication.
        */
 
        clear_bit(C7000_BH_ACTIVE, (void *)&cup->flag_a);
        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
        return;
}
 
/*
        Send a system validate control command to a unit.
*/
 
static int
c7000_send_sysval(struct c7000_unit *cup)
{
        int                             rc;
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &(cup->control_blk);
 
        CPrintk(1, "c7000: c7000_send_sysval: send sysval for device 0x%x\n", cup->devno);
 
        /*
                Build the system validate control message.
        */
 
        memset(ctlblkp, '\0', sizeof(struct c7000_control_blk));
        ctlblkp->cmd = C7000_SYS_VALIDATE;
        ctlblkp->correlator = 0;
        ctlblkp->link_id = ccp->linkid;
        ctlblkp->ver = ccp->version;
        memcpy(ctlblkp->hostname, ccp->lhost, NAMLEN);
        memcpy(ctlblkp->unitname, ccp->uhost, NAMLEN);
        ctlblkp->rdsize = C7000_DATAL;
        ctlblkp->wrtsize = C7000_DATAL;
 
        /*
                Build the channel program.
        */
 
        c7000_bld_wrtctl_chpgm(cup);
 
        /*
                Do the IO and wait for write to complete.
        */
 
        if ((rc = c7000_doio(cup)) != 0) {
                CPrintk(0, "c7000: c7000_send_sysval failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                return(-1);
        }
 
        return(0);
}
 
/*
        Send a system validate response control command to a unit.
*/
 
static int
c7000_send_sysval_resp(struct c7000_unit *cup, unsigned char correlator, int ret_code)
{
        int                             rc;
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &(cup->control_blk);
 
        CPrintk(1, "c7000: c7000_send_sysval_resp: send sysval response for device 0x%x\n", cup->devno);
 
        /*
                Build the system validate response control message.
        */
 
        memset(ctlblkp, '\0', sizeof(struct c7000_control_blk));
        ctlblkp->cmd = C7000_SYS_VALIDATE_RESP;
        ctlblkp->correlator = correlator;
        ctlblkp->ret_code = ret_code;
        ctlblkp->link_id = ccp->linkid;
        ctlblkp->ver = ccp->version;
        memcpy(ctlblkp->hostname, ccp->lhost, NAMLEN);
        memcpy(ctlblkp->unitname, ccp->uhost, NAMLEN);
        ctlblkp->rdsize = C7000_DATAL;
        ctlblkp->wrtsize = C7000_DATAL;
 
        /*
                Build the channel program.
        */
 
        c7000_bld_wrtctl_chpgm(cup);
 
        /*
                Do the IO and wait for write to complete.
        */
 
        if ((rc = c7000_doio(cup)) != 0) {
                CPrintk(0, "c7000: c7000_send_sysval_resp failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                return(-1);
        }
 
        return(0);
}
 
/*
        Check the information read in a SYS_VALIDATE control message.
*/
 
static int
c7000_checkinfo(struct c7000_unit *cup)
{
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &cup->control_blk;
        int                             ret_code = 0;
 
        if (memcmp(ccp->lhost, ctlblkp->hostname, NAMLEN) ||
                memcmp(ccp->uhost, ctlblkp->unitname, NAMLEN))
                ret_code = Err_Names_not_Matched;
 
        if (ctlblkp->ver != ccp->version)
                ret_code = Err_Wrong_Version;
 
        if ((ctlblkp->rdsize < C7000_DATAL) || (ctlblkp->wrtsize < C7000_DATAL))
                ret_code = Err_Wrong_Frame_Size;
 
        if (ret_code != 0)
                CPrintk(0, "c7000: c7000_checkinfo: ret_code %d for device 0x%x\n", ret_code, cup->devno);
 
        return(ret_code);
}
 
/*
        Keep reading until a sysval response comes in or an error.
*/
 
static int
c7000_get_sysval_resp(struct c7000_unit *cup)
{
        struct  c7000_controller        *ccp = cup->cntlp;
        int                             resp = 1;
        int                             req = 1;
        int                             rc;
        int                             ret_code = 0;
 
        CPrintk(1, "c7000: c7000_get_sysval_resp: get sysval response for unit 0x%x\n", cup->devno);
 
        /*
                Wait for the response to C7000_SYS_VALIDATE and for an
                inbound C7000_SYS_VALIDATE.
        */
 
        while (resp || req) {
 
                /*
                        Build the read channel program.
                */
 
                c7000_bld_readctl_chpgm(cup);
 
                if ((rc = c7000_doio(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_get_sysval_resp: failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                        return(-1);
                }
 
                /*
                        Process the control message.
                */
 
                switch (cup->control_blk.cmd) {
 
                        /*
                                Check that response is positive and return
                                with success. Otherwise, return with an
                                error.
                        */
 
                        case C7000_SYS_VALIDATE_RESP:
 
                                if (cup->control_blk.ret_code == 0)
                                        resp = 0;
                                else {
                                        CPrintk(0, "c7000: c7000_get_sysval_resp: receive sysval response for device 0x%x, return code %d\n",
                                                cup->devno,
                                                cup->control_blk.ret_code);
                                        return(-1);
                                }
 
                                break;
 
                        /*
                                Check that the request is reasonable and
                                send a SYS_VALIDATE_RESP.  Otherwise,
                                return with an error.
                        */
 
                        case C7000_SYS_VALIDATE:
                                CPrintk(1, "c7000: c7000_get_sysval_resp: receive sysval for device 0x%x\n", cup->devno);
                                req = 0;
                                ret_code = c7000_checkinfo(cup);
 
                                if (c7000_send_sysval_resp(&ccp->cunits[C7000_WR], cup->control_blk.correlator, ret_code) != 0)
                                        return(-1);
 
                                if (ret_code != 0)
                                        return(-1);
 
                                break;
 
                        /*
                                Anything else is unexpected and will result
                                in a return with an error.
                        */
 
                        default:
                                CPrintk(0, "c7000: c7000_get_sysval_resp: receive unexpected command for device 0x%x, command %d\n", cup->devno, cup->control_blk.cmd);
                                return(-1);
                                break;
                }
 
        }
 
        return(0);
}
 
/*
        Send a connection confirm control message.
*/
 
static int
c7000_conn_confrm(struct c7000_unit *cup, unsigned char correlator, int linkid)
{
        int                             rc;
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &(cup->control_blk);
 
        CPrintk(1, "c7000: c7000_conn_confrm: send the connection confirmation message for unit 0x%x\n", cup->devno);
 
        /*
                Build the connection confirm control message.
        */
 
        memset(ctlblkp, '\0', sizeof(struct c7000_control_blk));
        ctlblkp->cmd = C7000_CONN_CONFRM;
        ctlblkp->ver = ccp->version;
        ctlblkp->link_id = linkid;
        ctlblkp->correlator = correlator;
        ctlblkp->rdsize = 0;
        ctlblkp->wrtsize = 0;
        memcpy(ctlblkp->hostname, ccp->lappl, NAMLEN);
        memcpy(ctlblkp->unitname, ccp->uappl, NAMLEN);
 
        /*
                Build the channel program.
        */
 
        c7000_bld_wrtctl_chpgm(cup);
 
        /*
                Do the IO and wait for write to complete.
        */
 
        if ((rc = c7000_doio(cup)) != 0) {
                CPrintk(0, "c7000: c7000_conn_confrm: failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                return(-1);
        }
 
        return(0);
}
 
/*
        Send a connection request control message.
*/
 
static int
c7000_send_conn(struct c7000_unit *cup)
{
        int                             rc;
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &(cup->control_blk);
 
        CPrintk(1, "c7000: c7000_send_conn: send the connection request message for unit 0x%x\n", cup->devno);
 
        /*
                Build the connection request control message.
        */
 
        memset(ctlblkp, '\0', sizeof(struct c7000_control_blk));
        ctlblkp->cmd = C7000_CONN_REQ;
        ctlblkp->ver = ccp->version;
        ctlblkp->link_id = 0;
        ctlblkp->correlator = 0;
        ctlblkp->rdsize = C7000_DATAL;
        ctlblkp->wrtsize = C7000_DATAL;
        memcpy(ctlblkp->hostname, ccp->lappl, NAMLEN);
        memcpy(ctlblkp->unitname, ccp->uappl, NAMLEN);
 
        /*
                Build the channel program.
        */
 
        c7000_bld_wrtctl_chpgm(cup);
 
        /*
                Do the IO and wait for write to complete.
        */
 
        if ((rc = c7000_doio(cup)) != 0) {
                CPrintk(0, "c7000: c7000_send_conn: failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                return(-1);
        }
 
        return(0);
}
 
/*
        Send a disconnect control message to the link with the value of
        linkid.
*/
 
static int
c7000_send_disc(struct c7000_unit *cup, int linkid)
{
        int                             rc;
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_control_blk       *ctlblkp = &(cup->control_blk);
 
        CPrintk(1, "c7000: c7000_send_disc: send disconnect message for unit 0x%x\n", cup->devno);
 
        /*
                Build the disconnect control message.
        */
 
        memset(ctlblkp, '\0', sizeof(struct c7000_control_blk));
        ctlblkp->cmd = C7000_DISCONN;
        ctlblkp->ver = ccp->version;
        ctlblkp->link_id = linkid;
        ctlblkp->correlator = 0;
        ctlblkp->rdsize = C7000_DATAL;
        ctlblkp->wrtsize = C7000_DATAL;
        memcpy(ctlblkp->hostname, ccp->lappl, NAMLEN);
        memcpy(ctlblkp->unitname, ccp->uappl, NAMLEN);
 
        /*
                Build the channel program.
        */
 
        c7000_bld_wrtctl_chpgm(cup);
 
        /*
                Do the IO and wait for write to complete.
        */
 
        if ((rc = c7000_doio(cup)) != 0) {
                CPrintk(0, "c7000: c7000_send_disc: failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                return(-1);
        }
 
        return(0);
}
 
/*
        Resolve the race condition based on the link identifier value.
        The adapter microcode assigns the identifiers.  A higher value implies
        that the race was lost. A side effect of this function is that
        ccp->linkid is set to the link identifier to be used for this
        connection (provided that 0 is returned).
*/
 
static int
c7000_resolve_race(struct c7000_unit *cup, int local_linkid, int remote_linkid)
{
        struct c7000_controller         *ccp = cup->cntlp;
 
        CPrintk(1, "c7000: c7000_resolve_race: for unit 0x%x, local linkid %d, remote linkid %d\n", cup->devno, local_linkid, remote_linkid);
 
        /*
                This local link identifier should not be zero..
        */
 
        if (local_linkid == 0) {
                CPrintk(0, "c7000: c7000_resolve_race: error for unit 0x%x, local linkid is null\n", cup->devno);
                return(-1);
        }
 
        /*
                This indicates that there is no race.  Just use our
                local link identifier.
        */
 
        if (remote_linkid == 0) {
                ccp->linkid = local_linkid;
                return(0);
        }
 
        /*
                Send a connection confirm message if we lost the race to
                the winning link identifier.
 
                Either way, save the winning link identifier.
        */
 
        if (local_linkid > remote_linkid) {
 
                if (c7000_conn_confrm(&ccp->cunits[C7000_WR], cup->control_blk.correlator, remote_linkid) != 0) {
                        CPrintk(0, "c7000: c7000_resolve_race: failed for unit 0x%x\n", cup->devno);
                        return(-1);
                }
 
                ccp->linkid = remote_linkid;
        } else {
                ccp->linkid = local_linkid;
        }
 
        return(0);
}
 
/*
        Get connected by processing the connection request/response/confirm
        control messages.  A connection request has already been sent by
        calling function c7000_send_conn.
*/
 
static int
c7000_get_conn(struct c7000_unit *cup)
{
        struct c7000_controller         *ccp = cup->cntlp;
        int                             rc;
        int                             cont = 1;
        int                             remote_linkid = 0;
        int                             local_linkid = 0;
 
        CPrintk(1, "c7000: c7000_get_conn: read the connected message for unit 0x%x\n", cup->devno);
        ccp->linkid = 0;
 
        while (cont == 1) {
 
                /*
                        Build the read channel program.
                */
 
                c7000_bld_readctl_chpgm(cup);
 
                /*
                        Start the channel program to read a control message.
                */
 
                if ((rc = c7000_doio(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_get_conn: failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                        return(-1);
                }
 
                /*
                        Process the control message that was received based
                        on the command code.
                */
 
                CPrintk(1, "c7000: c7000_get_conn: received command %d for unit 0x%x\n", cup->control_blk.cmd, cup->devno);
 
                switch(cup->control_blk.cmd) {
 
                        /*
                                Save the remote link_id in the message for
                                a check in c7000_resolve_race.
                        */
 
                        case C7000_CONN_REQ:
                                remote_linkid = cup->control_blk.link_id;
                                break;
 
                        /*
                                A connection response received.  Resolve
                                the network race condition (if any) by
                                comparing the link identifier values.
                        */
 
                        case C7000_CONN_RESP:
 
                                if (cup->control_blk.ret_code != 0) {
                                        CPrintk(0, "c7000: c7000_get_conn: failed for unit 0x%x , connection response return code %d\n",
                                                cup->devno, cup->control_blk.ret_code);
                                        return(-1);
                                }
 
                                local_linkid = cup->control_blk.link_id;
 
                                if (c7000_resolve_race(cup, local_linkid, remote_linkid) != 0)
                                        return(-1);
 
                                break;
 
                        /*
                                Got a confirmation to our connection request.
                                Disconnect the remote link identifier (if any).
                                Break out of the loop.
                        */
 
                        case C7000_CONN_CONFRM:
 
                                if (remote_linkid != 0) {
 
                                        if (c7000_send_disc(&ccp->cunits[C7000_WR], remote_linkid) != 0) {
                                                CPrintk(0, "c7000: c7000_get_conn: send disconnect failed for unit 0x%x\n", cup->devno);
                                                return(-1);
                                        }
 
                                }
 
                                cont = 0;
                                break;
 
                        /*
                                Got a disconnect to our connection request.
                                Break out of the loop.
                        */
 
                        case C7000_DISCONN:
                                cont = 0;
                                break;
 
                        /*
                                Anything else must be an error.
                                Return with an error immediately.
                        */
 
                        default:
                                CPrintk(0, "c7000: c7000_get_conn: failed for unit 0x%x unexpected command %d\n",
                                        cup->devno, cup->control_blk.cmd);
                                return(-1);
                }
 
        }
 
        /*
                Be sure that we now have a link identifier.
        */
 
        if (ccp->linkid == 0)
                return(-1);
 
        return(0);
}
 
/*
        Get statistics method.
*/
 
struct net_device_stats *
c7000_stats(STRUCT_NET_DEVICE *dev)
{
        struct  c7000_controller        *ccp = (struct c7000_controller *)dev->priv;
 
        return(&ccp->stats);
}
 
/*
        Open method.
*/
 
static int
c7000_open(STRUCT_NET_DEVICE *dev)
{
        int                             i;
        struct  c7000_controller        *ccp = (struct c7000_controller *)dev->priv;
        struct  c7000_unit              *cup;
        int                             rc;
        __u32                           parm;
        __u8                            flags = 0x00;
 
        c7000_set_busy(dev);
 
        /*
                Allocate space for the unit buffers.
        */
 
        if (c7000_alloc_buffers(dev) == -1) {
                CPrintk(0, "c7000: c7000_open: can not allocate buffer space for base unit 0x%lx\n", dev->base_addr);
                c7000_free_buffers(dev);  /* free partially allocated buffers */
                c7000_clear_busy(dev);
                return(-ENOMEM);
        }
 
        /*
                Perform the initialization for all units.
        */
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
 
                /*
                        Initialize task queue structure used for the bottom
                        half routine.
                */
 
#ifndef NEWSTUFF
                cup->tq.next = NULL;
#endif
                cup->tq.sync = 0;
                cup->tq.routine = (void *)(void *)c7000_irq_bh;
                cup->tq.data = cup;
                cup->state = C7000_HALT;
#ifdef NEWSTUFF
                init_waitqueue_head(&cup->wait);
#endif
                CPrintk(1, "c7000: c7000_open: issuing halt to unit 0x%x\n", cup->devno);
 
                /*
                        Issue a halt I/O to the unit
                */
 
                if ((rc = c7000_haltio(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_open: halt_IO failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                        continue;
                }
 
                cup->IO_active = 0;
                cup->flag_a = 0;
                cup->sigsmod = 0x00;
 
                CPrintk(1, "c7000: c7000_open: halt complete for unit 0x%x\n", cup->devno);
        }
 
        /*
                On each subchannel send a sense id.
        */
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
 
                /*
                        Build SENSE ID channel program.
                */
 
                c7000_bld_senseid_chpgm(cup);
 
                /*
                        Issue the start I/O for SENSE ID channel program.
                */
 
                CPrintk(1, "c7000: c7000_open: issuing SENSEID to unit 0x%x\n", cup->devno);
 
                if ((rc = c7000_doio(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_open: SENSEID failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                        c7000_clear_busy(dev);
                        return(-EIO);
                }
 
                CPrintk(1, "c7000: c7000_open: SENSEID complete for unit 0x%x\n", cup->devno);
        }
 
        /*
                Send the system validation control message.
        */
 
        cup = &ccp->cunits[C7000_WR];
 
        if (c7000_send_sysval(cup) != 0) {
                CPrintk(0, "c7000: c7000_open: can not send sysval for unit 0x%x\n", cup->devno);
                c7000_clear_busy(dev);
                return(-EIO);
        }
 
        CPrintk(1, "c7000: c7000_open: successfully sent sysval for unit 0x%x\n", cup->devno);
        /*
                Get the system validation response message.
        */
 
        cup = &ccp->cunits[C7000_RD];
 
        if (c7000_get_sysval_resp(cup) != 0) {
                CPrintk(0, "c7000: c7000_open: can not read sysval response for unit 0x%x\n", cup->devno);
                c7000_clear_busy(dev);
                return(-EIO);
        }
 
        CPrintk(1, "c7000: c7000_open: successfully received sysval reply for unit 0x%x\n", cup->devno);
        ccp->cunits[C7000_RD].state = ccp->cunits[C7000_WR].state = C7000_CONNECT;
 
        cup = &ccp->cunits[C7000_WR];
 
        /*
                Send a connection request.
        */
 
        if (c7000_send_conn(cup) != 0) {
                CPrintk(0, "c7000: c7000_open: connection failed for unit 0x%x\n", cup->devno);
                c7000_clear_busy(dev);
                return(-EIO);
        }
 
        cup = &ccp->cunits[C7000_RD];
 
        /*
                Get the response to our connection request Note that a
                network race may occur.  This is handled in c7000_get_conn.
        */
 
        if (c7000_get_conn(cup) != 0) {
                CPrintk(0, "c7000: c7000_open: unit 0x%x has connected\n", cup->devno);
                c7000_clear_busy(dev);
                return(-EIO);
        }
 
        CPrintk(1, "c7000: c7000_open: successfully received connection request for unit 0x%x\n", cup->devno);
        ccp->cunits[C7000_RD].state = ccp->cunits[C7000_WR].state = C7000_READY;
 
        /*
                Clear the interface statistics.
        */
 
        memset(&ccp->stats, '\0', sizeof(struct net_device_stats));
 
        if ((rc = c7000_bld_read_chain(cup)) != 0) {
                c7000_clear_busy(dev);
                return(rc);
        }
 
        /*
                Start the C7000_READ channel program but do not wait for it's
                completion.
        */
 
        cup->state = C7000_READ;
        parm = (__u32) cup;
        set_bit(0, (void *)&cup->IO_active);
 
        if ((rc = do_IO(cup->irq, &cup->proc_head->ccws[0], parm, 0xff, flags)) != 0) {
                CPrintk(0, "c7000: c7000_open: READ failed with return code %d for unit 0x%x\n", rc, cup->devno);
                c7000_error(cup->cntlp);
                clear_bit(0, (void *)&cup->IO_active);
                c7000_clear_busy(dev);
                return(-EIO);
        }
 
#ifdef NEWSTUFF
        netif_start_queue(dev);
#else
        dev->start = 1;
#endif
        CPrintk(0, "c7000: c7000_open: base unit 0x%lx is opened\n", dev->base_addr);
        c7000_clear_busy(dev);
        MOD_INC_USE_COUNT;      /* increment module usage count */
        return(0);
}
 
/*
        Stop method.
*/
 
static int
c7000_stop(STRUCT_NET_DEVICE *dev)
{
        int                             i;
        struct  c7000_controller        *ccp = (struct c7000_controller *)dev->priv;
        struct  c7000_unit              *cup;
        int                             rc;
 
#ifdef NEWSTUFF
/* nothing? */
#else
        dev->start = 0;
#endif
        c7000_set_busy(dev);
 
        /*
                Send a disconnect message.
        */
 
        ccp->cunits[C7000_RD].state = ccp->cunits[C7000_WR].state = C7000_DISC;
        cup = &ccp->cunits[C7000_WR];
 
        if (c7000_send_disc(cup, ccp->linkid) != 0) {
                CPrintk(0, "c7000: c7000_stop: send of disconnect message failed for unit 0x%x\n", cup->devno);
        }
 
        CPrintk(1, "c7000: c7000_stop: successfully sent disconnect message to unit 0x%x\n", cup->devno);
 
        /*
                Issue a halt I/O to all units.
        */
 
        for (i = 0; i < NUNITS; i++) {
                cup = &ccp->cunits[i];
                cup->state = C7000_STOP;
                CPrintk(1, "c7000: c7000_stop: issuing halt to unit 0x%x\n", cup->devno);
 
                if ((rc = c7000_haltio(cup)) != 0) {
                        CPrintk(0, "c7000: c7000_stop: halt_IO failed with rc = %d for unit 0x%x\n", rc, cup->devno);
                        continue;
                }
 
                CPrintk(1, "c7000: c7000_stop: halt complete for unit 0x%x\n", cup->devno);
        }
 
        c7000_free_buffers(dev);
        CPrintk(0, "c7000: c7000_stop: base unit 0x%lx is stopped\n", dev->base_addr);
        MOD_DEC_USE_COUNT;      /* Decrement module usage count */
        return(0);
}
 
/*
        Configure the interface.
*/
 
static int
c7000_config(STRUCT_NET_DEVICE *dev, struct ifmap *map)
{
        CPrintk(1, "c7000: c7000_config: entered for base unit 0x%lx\n", dev->base_addr);
        return(0);
}
 
/*
        Transmit a packet.
*/
 
static int
c7000_xmit(struct sk_buff *skb, STRUCT_NET_DEVICE *dev)
{
        struct  c7000_controller        *ccp = (struct c7000_controller *)dev->priv;
        struct  c7000_unit              *cup;
        __u32                           saveflags;
        __u32                           parm;
        __u8                            flags = 0x00;
        struct  c7000_buffer            *buf, *pbuf;
        int                             rc;
 
        CPrintk(1, "c7000: c7000_xmit: entered for base unit 0x%lx\n", dev->base_addr);
 
        /*
                When the skb pointer is NULL return.
        */
 
        if (skb == NULL) {
                CPrintk(0, "c7000: c7000_xmit: skb pointer is null for base unit 0x%lx\n", dev->base_addr);
                ccp->stats.tx_dropped++;
                return(-EIO);
        }
 
        cup = &ccp->cunits[C7000_WR];
 
        /*
                Lock the irq.
        */
 
        s390irq_spin_lock_irqsave(cup->irq, saveflags);
 
        /*
                When the device transmission busy flag is on , no data
                can be sent.  Unlock the irq and return EBUSY.
        */
 
        if (c7000_check_busy(dev)) {
                CPrintk(1, "c7000: c7000_xmit: c7000_check_busy returns true for base unit 0x%lx\n", dev->base_addr);
                s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                return(-EBUSY);
        }
 
        /*
                Set the device transmission busy flag on atomically.
        */
 
        if (c7000_ts_busy(TB_TX, dev)) {
                CPrintk(1, "c7000: c7000_xmit: c7000_ts_busy returns true for base unit 0x%lx\n", dev->base_addr);
                s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                return(-EBUSY);
        }
 
        CPrintk(1, "c7000: c7000_xmit: set TB_TX for unit 0x%x\n", cup->devno);
 
        /*
                Obtain a free buffer.  If none are free then mark tbusy
                with TB_NOBUFFER and return EBUSY.
        */
 
        if ((buf = c7000_get_buffer(cup)) == NULL) {
                CPrintk(1, "c7000: c7000_xmit: setting TB_NOBUFFER for base unit 0x%lx\n", dev->base_addr);
                c7000_setbit_busy(TB_NOBUFFER, dev);
                c7000_clearbit_busy(TB_TX, dev);
                s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                return(-EBUSY);
        }
 
        CPrintk(1, "c7000: c7000_xmit: Got buffer for unit 0x%x\n", cup->devno);
 
        /*
                Save the length of the skb data and then copy it to the
                buffer.  Queue the buffer on the processing list.
        */
 
        buf->len = skb->len;
        memcpy(buf->data, skb->data, skb->len);
        memset(buf->data + C7000_DATAL + C7000_READHDRL, '\0', C7000_READFFL);
        pbuf = cup->proc_tail;
        c7000_queue_buffer(cup, buf);
 
        /*
                Chain the buffer to the running channel program.
        */
 
        if (test_bit(0, (void *)&cup->IO_active) && pbuf != NULL) {
                c7000_bld_wrt_chpgm(cup, buf);
                pbuf->ccws[2].cda = (__u32)virt_to_phys(&buf->ccws[0]);
        }
 
        /*
                Free the socket buffer.
        */
 
        dev_kfree_skb(skb);
 
        /*
                If the unit is not currently doing IO, build a channel
                program and start the IO for the buffers on the processing
                chain.
        */
 
        if (test_and_set_bit(0, (void *)&cup->IO_active) == 0) {
                CPrintk(1, "c7000: c7000_xmit: start IO for unit 0x%x\n", cup->devno);
                c7000_bld_wrt_chain(cup);
                parm = (__u32) cup;
                cup->state = C7000_WRITE;
 
                if ((rc = do_IO(cup->irq, &cup->proc_head->ccws[0], parm, 0xff, flags)) != 0) {
                        CPrintk(0, "c7000: c7000_xmit: do_IO failed with return code %d for unit 0x%x\n", rc, cup->devno);
                        c7000_error(cup->cntlp);
                        c7000_clearbit_busy(TB_TX, dev);
                        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
                        return(-EIO);
                }
 
                dev->trans_start = jiffies;
                CPrintk(1, "c7000: c7000_xmit: do_IO succeeds for unit 0x%x\n", cup->devno);
        }
 
        /*
                If the free chain is now NULL, set the TB_NOBUFFER flag.
        */
 
        if (cup->free == NULL) {
                CPrintk(1, "c7000: c7000_xmit: setting TB_NOBUFFER for base unit 0x%lx\n", dev->base_addr);
                c7000_setbit_busy(TB_NOBUFFER, dev);
        }
 
        c7000_clearbit_busy(TB_TX, dev);
        s390irq_spin_unlock_irqrestore(cup->irq, saveflags);
        CPrintk(1, "c7000: c7000_xmit: exits for unit 0x%x\n", cup->devno);
        return(0);
}
 
/*
        Handle an ioctl from a user process.
*/
 
static int
c7000_ioctl(STRUCT_NET_DEVICE *dev, struct ifreq *ifr, int cmd)
{
        CPrintk(1, "c7000: c7000_ioctl: entered for base unit 0x%lx with cmd %d\n", dev->base_addr, cmd);
        return(0);
}
 
/*
        Analyze the interrupt status and return a value
        that identifies the type.
*/
 
static enum c7000_rupt
c7000_check_csw(devstat_t *devstat)
{
 
        /*
                Check for channel detected conditions (except PCI).
        */
 
        if ((devstat->cstat & ~SCHN_STAT_PCI) != 0) {
                CPrintk(0, "c7000: c7000_check_csw: channel status 0x%x for unit 0x%x\n", devstat->cstat, devstat->devno);
                return(C7000_CHANERR);
        }
 
        /*
                Fast path the normal cases.
        */
 
        if (devstat->dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
                return(C7000_NORMAL);
 
        if (devstat->cstat == SCHN_STAT_PCI)
                return(C7000_NORMAL);
 
        /*
                Check for exceptions.
        */
 
        if (devstat->dstat & DEV_STAT_UNIT_CHECK) {
                CPrintk(0, "c7000: c7000_check_csw: unit check for unit 0x%x, sense byte0 0x%2.2x\n", devstat->devno, devstat->ii.sense.data[0]);
 
                if (devstat->ii.sense.data[0] == C7000_BOX_RESET)
                        return(C7000_UCK_RESET);
                else
                        return(C7000_UCK);
 
        } else if (devstat->dstat & DEV_STAT_UNIT_EXCEP) {
                CPrintk(0, "c7000: c7000_check_csw: unit exception for unit 0x%x\n", devstat->devno);
                return(C7000_UE);
 
        } else if (devstat->dstat & DEV_STAT_ATTENTION) {
                CPrintk(0, "c7000: c7000_check_csw: attention for unit 0x%x\n", devstat->devno);
                return(C7000_ATTN);
 
        } else if (devstat->dstat & DEV_STAT_BUSY) {
                CPrintk(0, "c7000: c7000_check_csw: busy for unit 0x%x\n", devstat->devno);
                return(C7000_BUSY);
 
        } else {
                CPrintk(0, "c7000: c7000_check_csw: channel status 0x%2.2x , device status 0x%2.2x, devstat flags 0x%8.8x for unit 0x%x\n",
                        devstat->cstat, devstat->dstat, devstat->flag, devstat->devno);
                return(C7000_OTHER);
        }
 
        /* NOT REACHED */
 
}
 
/*
        Retry the last CCW chain to the unit.
*/
 
static void
c7000_retry_io(struct c7000_unit *cup)
{
        int     rc;
        __u32   parm;
        __u8    flags = 0x00;
        ccw1_t  *ccwp;
 
        if (++cup->retries > C7000_MAX_RETRIES) {
                c7000_error(cup->cntlp);
                CPrintk(0, "c7000: c7000_retry_io: retry IO for unit 0x%x exceeds maximum retry count\n", cup->devno);
                return;
        }
 
        set_bit(0, (void *)&cup->IO_active);
        parm = (__u32)cup;
 
        if (cup->state == C7000_READ || cup->state == C7000_WRITE)
                ccwp = &cup->proc_head->ccws[0];
        else
                ccwp = &cup->ccws[0];
 
        if ((rc = do_IO(cup->irq, ccwp, parm, 0xff, flags)) != 0) {
                CPrintk(0, "c7000: c7000_retry_io: can not retry IO for unit 0x%x, return code %d\n", cup->devno, rc);
                clear_bit(0, (void *)&cup->IO_active);
                c7000_error(cup->cntlp);
        }
 
        CPrintk(1, "c7000: c7000_retry_io: retry IO for unit 0x%x, retry count %d\n", cup->devno, cup->retries);
        return;
}
 
/*
        Process a read interrupt by scanning the list of buffers
        for ones that have completed and queue them for the bottom
        half to process.
*/
 
static void
c7000_proc_rintr(struct c7000_unit *cup)
{
        struct  c7000_buffer    *buf;
        struct  c7000_rd_header *head;
        int                     num_read = 0;
 
        while (cup->proc_head != NULL) {
                head = (struct c7000_rd_header *)(cup->proc_head->data + C7000_DATAL);
 
                /*
                        The flag byte in the read header will be set to
                        FLAG_FF when the buffer has been read.
                */
 
                if (head->flag != FLAG_FF)
                        break;
 
                /*
                        Dequeue the buffer from the proc chain
                        and enqueue it on the bh chain for
                        the bh routine to process.
                */
 
                buf = c7000_dequeue_buffer(cup);
                c7000_queue_bh_buffer(cup, buf);
                num_read++;
        }
 
        CPrintk(1, "c7000: c7000_proc_rintr: %d buffers read for unit 0x%x\n", num_read, cup->devno);
        return;
}
 
/*
        Process all completed buffers on the proc chain.
        A buffer is completed if it's READFF flag is FLAG_FF.
*/
 
static int
c7000_proc_wintr(struct c7000_unit *cup)
{
        struct  c7000_controller        *ccp = cup->cntlp;
        struct  c7000_buffer            *buf;
        int                             num_write = 0;
 
        if (cup->proc_head == NULL) {
                CPrintk(0, "c7000: c7000_proc_wintr: unexpected NULL processing chain pointer for unit 0x%x\n", cup->devno);
                return(num_write);
        }
 
        while (cup->proc_head != NULL) {
 
                /*
                        Check if the buffer has completed.
                */
 
                if (*(cup->proc_head->data + C7000_DATAL + C7000_READHDRL) != FLAG_FF)
                        break;
 
                /*
                        Remove buffer from top of processing chain.
                        Place it on free list.
                */
 
                buf = c7000_dequeue_buffer(cup);
                c7000_release_buffer(cup, buf);
                num_write++;
 
                /*
                        Update transmitted packets statistic.
                */
 
                ccp->stats.tx_packets++;
        }
 
        CPrintk(1, "c7000: c7000_proc_wintr: %d buffers written for unit 0x%x\n", num_write, cup->devno);
        return(num_write);
}
 
/*
        Interrupt handler.
*/
 
static void
c7000_intr(int irq, void *initparm, struct pt_regs *regs)
{
        devstat_t                       *devstat = ((devstat_t *) initparm);
        struct  c7000_unit              *cup = NULL;
        struct  c7000_controller        *ccp = NULL;
        STRUCT_NET_DEVICE               *dev = NULL;
        __u32                           parm;
        __u8                            flags = 0x00;
        int                             rc;
 
        /*
                Discard unsolicited interrupts
        */
 
        if (devstat->intparm == 0) {
                CPrintk(0, "c7000: c7000_intr: unsolicited interrupt for device 0x%x, cstat = 0x%2.2x, dstat = 0x%2.2x, flag = 0x%8.8x\n",
                        devstat->devno, devstat->cstat, devstat->dstat, devstat->flag);
                return;
        }
 
        /*
                Obtain the c7000_unit structure pointer.
        */
 
        cup = (struct c7000_unit *)(devstat->intparm);
 
        /*
                Obtain the c7000_controller structure and device structure
                pointers.
        */
 
        if (cup == NULL) {
                CPrintk(0, "c7000: c7000_intr: c7000_unit pointer is NULL in devstat\n");
                return;
        }
 
        ccp = cup->cntlp;
 
        if (ccp == NULL) {
                CPrintk(0, "c7000: c7000_intr: c7000_cntlp pointer is NULL in c7000_unit structure 0x%x for unit 0x%x\n", (int)cup, cup->devno);
                return;
        }
 
        dev = ccp->dev;
 
        if (dev == NULL) {
                CPrintk(0, "c7000: c7000_intr: device pointer is NULL in c7000_controller structure 0x%x for unit 0x%x\n", (int)ccp, cup->devno);
                return;
        }
 
        /*
                Finite state machine (fsm) handling.
        */
 
        CPrintk(1, "c7000: c7000_intr: entered with state %d flag 0x%8.8x for unit 0x%x\n", cup->state, devstat->flag, cup->devno);
 
        switch(cup->state) {
 
                /*
                        Not expected to be here when in INIT state.
                */
 
                case C7000_INIT:
 
                        break;
 
                /*
                        Enter state C7000_SID and wakeup the sleeping
                        process in c7000_open.
                */
 
                case C7000_HALT:
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        cup->state = C7000_SID;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        Enter state C7000_SYSVAL and wakeup the sleeping
                        process in c7000_open.
                */
 
                case C7000_SID:
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        if (c7000_check_csw(devstat) != 0) {
                                c7000_retry_io(cup);
 
                                if (cup->state == C7000_ERROR)
                                        wake_up(&cup->wait);
 
                                break;
                        }
 
                        cup->retries = 0;
                        cup->state = C7000_SYSVAL;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        Wakeup the sleeping process in c7000_open.
                */
 
                case C7000_SYSVAL:
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        if (c7000_check_csw(devstat) != 0) {
                                c7000_retry_io(cup);
 
                                if (cup->state == C7000_ERROR)
                                        wake_up(&cup->wait);
 
                                break;
                        }
 
                        cup->retries = 0;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        Wakeup the sleeping process in c7000_open.
                */
 
                case C7000_CONNECT:
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        if (c7000_check_csw(devstat) != 0) {
                                c7000_retry_io(cup);
 
                                if (cup->state == C7000_ERROR)
                                        wake_up(&cup->wait);
 
                                break;
                        }
 
                        cup->retries = 0;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        Not expected to be entered here.
                */
 
                case C7000_READY:
                        break;
 
                /*
                        Process the data that was just read.
                */
 
                case C7000_READ:
 
                        if ((devstat->flag & (DEVSTAT_PCI | DEVSTAT_FINAL_STATUS)) == 0)
                                break;
 
                        CPrintk(1, "c7000: c7000_intr: process read interrupt for unit 0x%x , devstat flag = 0x%8.8x\n", cup->devno, devstat->flag);
 
                        /*
                                Check for serious errors.
                        */
 
                        if (c7000_check_csw(devstat) != 0) {
                                ccp->stats.rx_errors++;
                                c7000_error(cup->cntlp);
                                break;
                        }
 
                        /*
                                Build the bottom half buffer list.
                        */
 
                        c7000_proc_rintr(cup);
 
                        /*
                                When final status is received clear
                                the IO active bit.
                        */
 
                        if (devstat->flag & DEVSTAT_FINAL_STATUS) {
                                clear_bit(0, (void *)&cup->IO_active);
                        }
 
                        /*
                                If there are free buffers redrive the IO.
                        */
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) &&
                            (cup->free != NULL)) {
                                c7000_bld_read_chain(cup);
                                parm = (__u32)cup;
                                set_bit(0, (void *)&cup->IO_active);
 
                                if ((rc = do_IO(cup->irq, &cup->proc_head->ccws[0], parm, 0xff, flags)) != 0) {
                                        clear_bit(0, (void *)&cup->IO_active);
                                        CPrintk(0, "c7000: c7000_intr: do_IO failed with return code %d for unit 0x%x\n", rc, cup->devno);
                                        c7000_error(cup->cntlp);
                                        break;
                                }
 
                                CPrintk(1, "c7000: c7000_intr: started read io for unit 0x%x\n", cup->devno);
                        }
 
                        /*
                                Initiate bottom half routine to process
                                data that was read.
                        */
 
                        if (test_and_set_bit(C7000_BH_ACTIVE, (void *)&cup->flag_a) == 0) {
                                queue_task(&cup->tq, &tq_immediate);
                                mark_bh(IMMEDIATE_BH);
                        }
 
                        break;
 
                /*
                        Free the transmitted buffers and restart the channel
                        process (if necessary).
                */
 
                case C7000_WRITE:
 
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        if (c7000_check_csw(devstat) != 0) {
                                ccp->stats.tx_errors++;
                                c7000_error(cup->cntlp);
                                break;
                        }
 
                        /*
                                If at least one buffer was freed, clear
                                the NOBUFFER indication.
                        */
 
                        if (c7000_proc_wintr(cup) != 0) {
                                c7000_clearbit_busy(TB_NOBUFFER, dev);
                        }
 
                        /*
                                Restart the channel program if there are more
                                buffers on the processing chain.
                        */
 
                        if (cup->proc_head != NULL) {
                                c7000_bld_wrt_chain(cup);
                                parm = (__u32)cup;
                                set_bit(0, (void *)&cup->IO_active);
 
                                if ((rc = do_IO(cup->irq, &cup->proc_head->ccws[0], parm, 0xff, flags)) != 0) {
                                        CPrintk(0, "c7000: c7000_intr: do_IO failed with return code %d for unit 0x%x\n", rc, cup->devno);
                                        clear_bit(0, (void *)&cup->IO_active);
                                        c7000_error(cup->cntlp);
                                        break;
                                }
 
                                dev->trans_start = jiffies;
                        } else {
                                clear_bit(0, (void *)&cup->IO_active);
                                cup->state = C7000_READY;
                        }
 
                        break;
 
                /*
                        Disconnect message completed.  Wakeup the
                        sleeping process in c7000_stop.
                */
 
                case C7000_DISC:
                        if ((devstat->flag & DEVSTAT_FINAL_STATUS) == 0)
                                break;
 
                        if (c7000_check_csw(devstat) != 0) {
                                c7000_retry_io(cup);
 
                                if (cup->state == C7000_ERROR)
                                        wake_up(&cup->wait);
 
                                break;
                        }
 
                        cup->retries = 0;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        Subchannel is now halted.  Wakeup the sleeping
                        process in c7000_stop.  Set the state to C7000_STOPPED.
                */
 
                case C7000_STOP:
 
                        cup->state = C7000_STOPPED;
                        wake_up(&cup->wait);
                        break;
 
                /*
                        When in error state, stay there until the
                        interface is recycled.
                */
 
                case C7000_ERROR:
 
                        break;
 
                /*
                        Should not reach here
                */
 
                default:
                        CPrintk(0, "c7000: c7000_intr: entered default case for unit 0x%x, state %d\n", cup->devno, cup->state);
                        break;
 
        }
 
        CPrintk(1, "c7000: c7000_intr: exited with state %d for unit 0x%x\n", cup->state, cup->devno);
        return;
}
 
/*
        Fill in system validation name padding it with blanks.
*/
 
static void
c7000_fill_name(char *dst, char *src)
{
        char    *tmp = dst;
        int     i;
 
        for (i = 0; i < NAMLEN; i++, tmp++)
                *tmp = ' ';
 
        for (i = 0; i < NAMLEN && *src != '\0'; i++)
                *dst++ = *src++;
 
        return;
}
 
/*
        Initialization routine called when the device is registered.
*/
 
static int
c7000_init(STRUCT_NET_DEVICE *dev)
{
        struct  c7000_controller        *ccp;
        int                             i;
        int                             unitaddr;
        int                             irq;
 
        /*
                Find the position of base_addr in the bases array.
        */
 
        for (i = 0; i < MAX_C7000; i++)
                if (bases[i] == dev->base_addr)
                        break;
 
        if (i == MAX_C7000)
                return(-ENODEV);
 
        /*
                Make sure it is a C7000 type of device.
        */
 
        if (c7000_check_devices(dev->base_addr) != 0) {
                CPrintk(0, "c7000: c7000_init: base unit 0x%lx is not the right type\n", dev->base_addr);
                return(-ENODEV);
        }
 
        /*
                Initialize the device structure functions.
                Note that ARP is not done on the CLAW interface.
                There is no ethernet header.
        */
 
        dev->mtu = C7000_DATAL;
        dev->hard_header_len = 0;
        dev->addr_len = 0;
        dev->type = ARPHRD_SLIP;
        dev->tx_queue_len = C7000_TXQUEUE_LEN;
        dev->flags = IFF_NOARP;
        dev->open = c7000_open;
        dev->stop = c7000_stop;
        dev->set_config = c7000_config;
        dev->hard_start_xmit = c7000_xmit;
        dev->do_ioctl = c7000_ioctl;
        dev->get_stats = c7000_stats;
 
        /*
                Allocate space for a private data structure.
        */
 
        if ((ccp = dev->priv = kmalloc(sizeof(struct c7000_controller), GFP_KERNEL)) == NULL) {
                CPrintk(0, "c7000: c7000_init: base unit 0x%lx can not be initialized\n", dev->base_addr);
                return(-ENOMEM);
        }
 
        CPrintk(1, "c7000: c7000_init: allocated a c7000_controller structure at address 0x%x\n", (int)ccp);
        memset(ccp, '\0', sizeof(struct c7000_controller));
        ccp->dev = dev;
        ccp->base_addr = dev->base_addr;
 
        /*
                Populate the system validation name with default values.
        */
 
        c7000_fill_name(ccp->lappl, C7000_DFLT_LAPPL);
        c7000_fill_name(ccp->lhost, C7000_DFLT_LHOST);
        c7000_fill_name(ccp->uappl, C7000_DFLT_UAPPL);
        c7000_fill_name(ccp->uhost, C7000_DFLT_UHOST);
 
        /*
                When values have been supplied, replace the prior defaults.
        */
 
        if (i == 0) {
 
                if (lappl0 != NULL)
                        c7000_fill_name(ccp->lappl, lappl0);
 
                if (lhost0 != NULL)
                        c7000_fill_name(ccp->lhost, lhost0);
 
                if (uappl0 != NULL)
                        c7000_fill_name(ccp->uappl, uappl0);
 
                if (uhost0 != NULL)
                        c7000_fill_name(ccp->uhost, uhost0);
 
        } else if (i == 1) {
 
                if (lappl1 != NULL)
                        c7000_fill_name(ccp->lappl, lappl1);
 
                if (lhost1 != NULL)
                        c7000_fill_name(ccp->lhost, lhost1);
 
                if (uappl1 != NULL)
                        c7000_fill_name(ccp->uappl, uappl1);
 
                if (uhost1 != NULL)
                        c7000_fill_name(ccp->uhost, uhost1);
 
        } else if (i == 2) {
 
                if (lappl2 != NULL)
                        c7000_fill_name(ccp->lappl, lappl2);
 
                if (lhost2 != NULL)
                        c7000_fill_name(ccp->lhost, lhost2);
 
                if (uappl2 != NULL)
                        c7000_fill_name(ccp->uappl, uappl2);
 
                if (uhost2 != NULL)
                        c7000_fill_name(ccp->uhost, uhost2);
 
        } else {
 
                if (lappl3 != NULL)
                        c7000_fill_name(ccp->lappl, lappl3);
 
                if (lhost3 != NULL)
                        c7000_fill_name(ccp->lhost, lhost3);
 
                if (uappl3 != NULL)
                        c7000_fill_name(ccp->uappl, uappl3);
 
                if (uhost3 != NULL)
                        c7000_fill_name(ccp->uhost, uhost3);
 
        }
 
        CPrintk(1, "c7000: c7000_init: lappl = %8.8s lhost = %8.8s uappl = %8.8s uhost = %8.8s for base unit 0x%x\n", ccp->lappl, ccp->lhost, ccp->uappl, ccp->uhost, ccp->base_addr);
        ccp->version = 2;
        ccp->linkid = 0;
 
        /*
                Initialize the fields in the embedded cunits
                array.  This type of controller occupies a range
                of three contiguous device numbers.
        */
 
        for (i = 0; i < NUNITS; i++) {
                unitaddr = dev->base_addr + i;
 
                /*
                        Get the subchannel number.
                */
 
                if ((irq = ccp->cunits[i].irq = get_irq_by_devno(unitaddr)) == -1) {
                        CPrintk(0, "c7000: c7000_init: can not get subchannel for unit 0x%x\n", unitaddr);
                        return(-ENODEV);
                }
 
                /*
                        Get control of the subchannel.
                */
 
                if (request_irq(irq, c7000_intr, SA_INTERRUPT, dev->name, &ccp->cunits[i].devstat) != 0) {
                        CPrintk(0, "c7000: c7000_init: can not get control of subchannel 0x%x for unit 0x%x\n", irq, unitaddr);
                        return(-EBUSY);
                }
 
                CPrintk(1, "c7000: c7000_init: obtained control of subchannel 0x%x for unit 0x%x\n", irq, unitaddr);
                ccp->cunits[i].devno = unitaddr;
                ccp->cunits[i].IO_active = 0;
                ccp->cunits[i].state = C7000_INIT;
                ccp->cunits[i].cntlp = ccp;
                CPrintk(1, "c7000: c7000_init: initialized unit 0x%x on subchannel 0x%x\n", unitaddr, irq);
        }
 
        return(0);
}
 
/*
        Probe for the Cisco 7000 unit base addresses.
*/
 
static void
c7000_probe(void)
{
        s390_dev_info_t d;
        int             i;
        int             j;
        int             idx;
 
        /*
                Probe for up to MAX_C7000 devices.
                Get the first irq into variable idx.
        */
 
        idx = get_irq_first();
 
        for (j = 0; j < MAX_C7000; j++) {
 
                if (idx < 0)
                        break;
 
                /*
                        Continue scanning the irq's.  Variable idx
                        maintains the location from the prior scan.
                */
 
                for (i = idx; i >= 0; i = get_irq_next(i)) {
 
                        /*
                                Ignore invalid irq's.
                        */
 
                        if (get_dev_info_by_irq(i, &d) < 0)
                                continue;
 
                        /*
                                A Cisco 7000 is defined as a 3088 model
                                type 0x61.
                        */
 
                        if (d.sid_data.cu_type == C7000_CU_TYPE &&
                            d.sid_data.cu_model == C7000_CU_MODEL) {
                                CPrintk(0, "c7000_probe: unit probe found 0x%x\n", d.devno);
                                bases[j] = d.devno;
 
                                /*
                                        Skip the write irq and setup idx
                                        to probe for the next box.
                                */
 
                                idx = get_irq_next(i + 1);
                                break;
                        }
 
                }
 
        }
 
        return;
}
 
/*
        Module loading.  Register each C7000 interface found via probing
        or insmod command parameters.
*/
 
int
init_module(void)
{
        int             result;
        int             i;
 
        for (i = 0 ; i < MAX_C7000; i++)
                bases[i] = -1;
 
        /*
                Perform automatic detection provided it has not been disabled
                by the noauto parameter.
        */
 
        if (noauto == 0)
                c7000_probe();
 
        /*
                Populate bases array from the module basex parameters replacing
                what probing found above.
        */
 
        if (base0 != -1)
                bases[0] = base0;
 
        if (base1 != -1)
                bases[1] = base1;
 
        if (base2 != -1)
                bases[2] = base2;
 
        if (base3 != -1)
                bases[3] = base3;
 
        for (i = 0; i < MAX_C7000; i++) {
 
                if (bases[i] == -1)
                        continue;
 
                /*
                        Initialize the device structure.
                */
 
                memset(&c7000_devices[i], '\0', sizeof(STRUCT_NET_DEVICE));
#ifdef NEWSTUFF
                strcpy(c7000_devices[i].name, ifnames[i]);
#else
                c7000_devices[i].name = &ifnames[i][0];
#endif
                c7000_devices[i].base_addr = bases[i];
                c7000_devices[i].init = c7000_init;
 
                /*
                        Register the device.  This creates the interface
                        such as ci0.
                */
 
                if ((result = register_netdev(&c7000_devices[i])) != 0)  {
                        CPrintk(0, "c7000: init_module: error %d registering base unit 0x%x\n",
                                result, bases[i]);
                        c7000_devices[i].base_addr = -1;
                } else {
                        CPrintk(1, "c7000: init_module: registered base unit 0x%x on interface %s\n", bases[i], ifnames[i]);
                }
 
        }
 
        CPrintk(0, "c7000: init_module: module loaded\n");
        return(0);
}
 
/*
        Module unloading.  Unregister the interface and free kernel
        allocated memory.
*/
 
void
cleanup_module(void)
{
        int                             i;
        int                             j;
        struct  c7000_controller        *ccp;
 
        for (i = 0; i < MAX_C7000; i++) {
 
                if (bases[i] == -1)
                        continue;
 
                /*
                        If the device was registered, it must be unregistered
                        prior to unloading the module.
                */
 
                if (c7000_devices[i].base_addr != -1) {
 
                        ccp = (struct c7000_controller *) c7000_devices[i].priv;
 
                        if (ccp != NULL) {
 
                                for (j = 0; j < NUNITS ; j++) {
                                        CPrintk(1, "c7000: clean_module: free subchannel 0x%x for unit 0x%x\n", ccp->cunits[j].irq, ccp->cunits[j].devno);
                                        free_irq(ccp->cunits[j].irq, &ccp->cunits[j].devstat);
                                }
 
                                CPrintk(1, "c7000: clean_module: free a c7000_controller structure at address 0x%x\n", (int)ccp);
                                kfree(ccp);
                        }
 
                        unregister_netdev(&c7000_devices[i]);
                }
 
                bases[i] = -1;
        }
 
        CPrintk(0, "c7000: clean_module: module unloaded\n");
        return;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [s390/] [net/] [c7000.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`Cisco/7000 driver -- Copyright (C) 2000 UTS Global LLC.`
3			`Author: Bob Scardapane (UTS Global LLC).`
4			`Version: 3.`
5
6			`To use this driver, run the LINUX command:`
7
8			`insmod c7000 base0=0xYYYY lhost0=s1 uhost0=s2 lappl0=s3 uappl0=s4 dbg=x`
9
10			`base0=0xYYYY defines the base unit address of the interface.`
11			`lhost0=s1 defines the local host name.`
12			`uhost0=s2 defines the unit host name.`
13			`lappl0=s3 defines the local application name.`
14			`uappl0=s4 defines the unit application name.`
15			`dbg=x defines the message level. Higher values will result in`
16			`additional diagnostic messages.`
17
18			`Additional interfaces are defined on insmod by using the variable`
19			`name groups "base1,lhost1,lappl1,uhost1,uappl1", etc... up to three`
20			`additional groups.`
21
22			`In addition, the module will automatically detect the unit base`
23			`addresses by scanning all active irq's for a control unit type`
24			`of 0x3088 and a model of 0x61 (CLAW mode). The noauto parameter`
25			`can be used to suppress automatic detection.`
26
27			`The values of lhostx, lapplx, uhostx and uapplx default to:`
28
29			`lapplx - TCPIP`
30			`lhostx - UTS`
31			`uapplx - TCPIP`
32			`uhostx - C7011`
33
34			`Note that the values passed in the insmod command will always`
35			`override the automatic detection of the unit base addreeses and`
36			`the default values of lapplx, lhostx, uapplx and uhostx.`
37
38			`The parameter noauto can be used to disable automatic detection of`
39			`devices:`
40