Subversion Repositories or1k

/*

**

**  RCpci45.c

**

**

**

**  ---------------------------------------------------------------------

**  ---     Copyright (c) 1998, 1999, RedCreek Communications Inc.    ---

**  ---                   All rights reserved.                        ---

**  ---------------------------------------------------------------------

**

** Written by Pete Popov and Brian Moyle.

**

** Known Problems

**

** None known at this time.

**

**  TODO:

**      -Get rid of the wait loops in the API and replace them

**       with system independent delays ...something like

**       "delayms(2)".  However, under normal circumstances, the

**       delays are very short so they're not a problem.

**

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

**  it under the terms of the GNU General Public License as published by

**  the Free Software Foundation; either version 2 of the License, or

**  (at your option) any later version.

**  This program is distributed in the hope that it will be useful,

**  but WITHOUT ANY WARRANTY; without even the implied warranty of

**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

**  GNU General Public License for more details.

**  You should have received a copy of the GNU General Public License

**  along with this program; if not, write to the Free Software

**  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

**

**

**  Pete Popov, January 11,99: Fixed a couple of 2.1.x problems

**  (virt_to_bus() not called), tested it under 2.2pre5 (as a module), and

**  added a #define(s) to enable the use of the same file for both, the 2.0.x

**  kernels as well as the 2.1.x.

**

**  Ported to 2.1.x by Alan Cox 1998/12/9.

**

**  Sometime in mid 1998, written by Pete Popov and Brian Moyle.

**

***************************************************************************/

static char *version =

"RedCreek Communications PCI linux driver version 2.02\n";

#include <linux/module.h>

#include <linux/version.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/string.h>

#include <linux/ptrace.h>

#include <linux/errno.h>

#include <linux/in.h>

#include <linux/ioport.h>

#include <linux/malloc.h>

#include <linux/interrupt.h>

#include <linux/pci.h>

#include <linux/bios32.h>

#include <linux/timer.h>

#include <asm/irq.h>            /* For NR_IRQS only. */

#include <asm/bitops.h>

#include <asm/io.h>

#if LINUX_VERSION_CODE >= 0x020100

#define LINUX_2_1

#endif

#ifdef LINUX_2_1

#include <asm/uaccess.h>

#endif

#include <linux/if_ether.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/skbuff.h>

#define RC_LINUX_MODULE

#include "rclanmtl.h"

#include "rcif.h"

#define RUN_AT(x) (jiffies + (x))

#define NEW_MULTICAST

#include <linux/delay.h>

#ifndef LINUX_2_1

#define ioremap vremap

#define iounmap vfree

#endif

/* PCI/45 Configuration space values */

#define RC_PCI45_VENDOR_ID  0x4916

#define RC_PCI45_DEVICE_ID  0x1960

#define MAX_ETHER_SIZE        1520  

#define MAX_NMBR_RCV_BUFFERS    96

#define RC_POSTED_BUFFERS_LOW_MARK MAX_NMBR_RCV_BUFFERS-16

#define BD_SIZE 3           /* Bucket Descriptor size */

#define BD_LEN_OFFSET 2     /* Bucket Descriptor offset to length field */

/* RedCreek LAN device Target ID */

#define RC_LAN_TARGET_ID  0x10 

/* RedCreek's OSM default LAN receive Initiator */

#define DEFAULT_RECV_INIT_CONTEXT  0xA17  

static U32 DriverControlWord =  0;

static void rc_timer(unsigned long);

/*

 * Driver Private Area, DPA.

 */

typedef struct

{

    /*

     *    pointer to the device structure which is part

     * of the interface to the Linux kernel.

     */

    struct device *dev;

    char devname[8];                /* "ethN" string */

    U8     id;                        /* the AdapterID */

    U32    pci_addr;               /* the pci address of the adapter */

    U32    bus;

    U32    function;

    struct timer_list timer;        /*  timer */

    struct enet_statistics  stats; /* the statistics structure */

    struct device *next;            /* points to the next RC adapter */

    unsigned long numOutRcvBuffers;/* number of outstanding receive buffers*/

    unsigned char shutdown;

    unsigned char reboot;

    unsigned char nexus;

    PU8    PLanApiPA;             /* Pointer to Lan Api Private Area */

}

DPA, *PDPA;

#define MAX_ADAPTERS 32

static PDPA  PCIAdapters[MAX_ADAPTERS] =

{

    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,

    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL

};

static int RCinit(struct device *dev);

static int RCscan(struct device *dev);

static int RCfound_device(struct device *, int, int, int, int, int, int);

static int RCopen(struct device *);

static int RC_xmit_packet(struct sk_buff *, struct device *);

static void RCinterrupt(int, void *, struct pt_regs *);

static int RCclose(struct device *dev);

static struct enet_statistics *RCget_stats(struct device *);

static int RCioctl(struct device *, struct ifreq *, int);

static int RCconfig(struct device *, struct ifmap *);

static void RCxmit_callback(U32, U16, PU32, U16);

static void RCrecv_callback(U32, U8, U32, PU32, U16);

static void RCreset_callback(U32, U32, U32, U16);

static void RCreboot_callback(U32, U32, U32, U16);

static int RC_allocate_and_post_buffers(struct device *, int);

/* A list of all installed RC devices, for removing the driver module. */

static struct device *root_RCdev = NULL;

#ifdef MODULE

int init_module(void)

#else

int rcpci_probe(struct device *dev)

#endif

{

    int cards_found;

#ifdef MODULE

    cards_found = RCscan(NULL);

#else

    cards_found = RCscan(dev);

#endif

    if (cards_found)

        printk(version);

    return cards_found ? 0 : -ENODEV;

}

static int RCscan(struct device *dev)

{

    int cards_found = 0;

    static int pci_index = 0;

    if (!pcibios_present())

        return cards_found;

    for (;pci_index < 0x8; pci_index++)

    {

        unsigned char pci_bus, pci_device_fn;

        int scan_status;

        int board_index = 0;

        unsigned char pci_irq_line;

        unsigned short pci_command, vendor, device, class;

        unsigned int pci_ioaddr;

        scan_status =

            (pcibios_find_device (RC_PCI45_VENDOR_ID,

                                  RC_PCI45_DEVICE_ID,

                                  pci_index,

                                  &pci_bus,

                                  &pci_device_fn));

#ifdef RCDEBUG

        printk("rc scan_status = 0x%X\n", scan_status);

#endif

        if (scan_status != PCIBIOS_SUCCESSFUL)

            break;

        pcibios_read_config_word(pci_bus,

                                 pci_device_fn,

                                 PCI_VENDOR_ID, &vendor);

        pcibios_read_config_word(pci_bus,

                                 pci_device_fn,

                                 PCI_DEVICE_ID, &device);

        pcibios_read_config_byte(pci_bus,

                                 pci_device_fn,

                                 PCI_INTERRUPT_LINE, &pci_irq_line);

        pcibios_read_config_dword(pci_bus,

                                  pci_device_fn,

                                  PCI_BASE_ADDRESS_0, &pci_ioaddr);

        pcibios_read_config_word(pci_bus,

                                 pci_device_fn,

                                 PCI_CLASS_DEVICE, &class);

        pci_ioaddr &= ~0xf;

#ifdef RCDEBUG

        printk("rc: Found RedCreek PCI adapter\n");

        printk("rc: pci class = 0x%x  0x%x \n", class, class>>8);

        printk("rc: pci_bus = %d,  pci_device_fn = %d\n", pci_bus, pci_device_fn);

        printk("rc: pci_irq_line = 0x%x \n", pci_irq_line);

        printk("rc: pci_ioaddr = 0x%x\n", pci_ioaddr);

#endif

        if (check_region(pci_ioaddr, 2*32768))

        {

            printk("rc: check_region failed\n");

            continue;

        }

#ifdef RCDEBUG

        else

        {

            printk("rc: check_region passed\n");

        }

#endif

        /*

         * Get and check the bus-master and latency values.

         * Some PCI BIOSes fail to set the master-enable bit.

         */

        pcibios_read_config_word(pci_bus,

                                 pci_device_fn,

                                 PCI_COMMAND,

                                 &pci_command);

        if ( ! (pci_command & PCI_COMMAND_MASTER)) {

            printk("rc: PCI Master Bit has not been set!\n");

            pci_command |= PCI_COMMAND_MASTER;

            pcibios_write_config_word(pci_bus,

                                      pci_device_fn,

                                      PCI_COMMAND,

                                      pci_command);

        }

        if ( ! (pci_command & PCI_COMMAND_MEMORY)) {

            /*

             * If the BIOS did not set the memory enable bit, what else

             * did it not initialize?  Skip this adapter.

             */

            printk("rc: Adapter %d, PCI Memory Bit has not been set!\n",

                   cards_found);

            printk("rc: Bios problem? \n");

            continue;

        }

        if (!RCfound_device(dev, pci_ioaddr, pci_irq_line,

                          pci_bus, pci_device_fn,

                          board_index++, cards_found))

        {

            dev = 0;

            cards_found++;

        }

    }

#ifdef RCDEBUG

    printk("rc: found %d cards \n", cards_found);

#endif

    return cards_found;

}

static int RCinit(struct device *dev)

{

    dev->open = &RCopen;

    dev->hard_start_xmit = &RC_xmit_packet;

    dev->stop = &RCclose;

    dev->get_stats = &RCget_stats;

    dev->do_ioctl = &RCioctl;

    dev->set_config = &RCconfig;

    return 0;

}

static int

RCfound_device(struct device *dev, int memaddr, int irq,

               int bus, int function, int product_index, int card_idx)

{

    int dev_size = 32768;

    unsigned long *vaddr=0;

    PDPA pDpa;

    int init_status;

    /*

     * Allocate and fill new device structure.

     * We need enough for struct device plus DPA plus the LAN API private

     * area, which requires a minimum of 16KB.  The top of the allocated

     * area will be assigned to struct device; the next chunk will be

     * assigned to DPA; and finally, the rest will be assigned to the

     * the LAN API layer.

     */

#ifdef MODULE

    dev = (struct device *) kmalloc(dev_size, GFP_DMA | GFP_KERNEL |GFP_ATOMIC);

    if (!dev)

    {

        printk("rc: unable to kmalloc dev\n");

        return 1;

    }

    memset(dev, 0, dev_size);

    /*

     * dev->priv will point to the start of DPA.

     */

    dev->priv = (void *)(((long)dev + sizeof(struct device) + 15) & ~15);

#else

    dev->priv = 0;

    dev->priv = (struct device *) kmalloc(dev_size, GFP_DMA | GFP_KERNEL |GFP_ATOMIC);

    if (!dev->priv)

    {

        printk("rc: unable to kmalloc private area\n");

        return 1;

    }

    memset(dev->priv, 0, dev_size);

#endif

#ifdef RCDEBUG

    printk("rc: dev = 0x%x, dev->priv = 0x%x\n", (uint)dev, (uint)dev->priv);

#endif

    pDpa = dev->priv;

    if (!dev->name)

        dev->name = pDpa->devname;

    pDpa->dev = dev;            /* this is just for easy reference */

    pDpa->function = function;

    pDpa->bus = bus;

    pDpa->id = card_idx;        /* the device number */

    pDpa->pci_addr = memaddr;

    PCIAdapters[card_idx] = pDpa;

#ifdef RCDEBUG

    printk("rc: pDpa = 0x%x, id = %d \n", (uint)pDpa, (uint)pDpa->id);

#endif

    /*

     * Save the starting address of the LAN API private area.  We'll

     * pass that to RCInitI2OMsgLayer().

     */

    pDpa->PLanApiPA = (void *)(((long)pDpa + sizeof(DPA) + 0xff) & ~0xff);

#ifdef RCDEBUG

    printk("rc: pDpa->PLanApiPA = 0x%x\n", (uint)pDpa->PLanApiPA);

#endif

    /* The adapter is accessable through memory-access read/write, not

     * I/O read/write.  Thus, we need to map it to some virtual address

     * area in order to access the registers are normal memory.

     */

    vaddr = (ulong *) ioremap (memaddr, 2*32768);

#ifdef RCDEBUG

    printk("rc: RCfound_device: 0x%x, priv = 0x%x, vaddr = 0x%x\n",

           (uint)dev, (uint)dev->priv, (uint)vaddr);

#endif

    dev->base_addr = (unsigned long)vaddr;

    dev->irq = irq;

    dev->interrupt = 0;

    /*

     * Request a shared interrupt line.

     */

    if ( request_irq(dev->irq, (void *)RCinterrupt,

                     SA_INTERRUPT|SA_SHIRQ, "RedCreek VPN Adapter", dev) )

    {

        printk( "RC PCI 45: %s: unable to get IRQ %d\n", (PU8)dev->name, (uint)dev->irq );

        iounmap(vaddr);

        kfree(dev);

        return 1;

    }

    init_status = RCInitI2OMsgLayer(pDpa->id, dev->base_addr,

                  pDpa->PLanApiPA, (PU8)virt_to_bus((void *)pDpa->PLanApiPA),

                  (PFNTXCALLBACK)RCxmit_callback,

                  (PFNRXCALLBACK)RCrecv_callback,

                  (PFNCALLBACK)RCreboot_callback);

    if (init_status)

    {

        printk("rc: Unable to initialize msg layer\n");

        free_irq(dev->irq, dev);

        iounmap(vaddr);

        kfree(dev);

        return 1;

    }

    if (RCGetMAC(pDpa->id, dev->dev_addr, NULL))

    {

        printk("rc: Unable to get adapter MAC\n");

        free_irq(dev->irq, dev);

        iounmap(vaddr);

        kfree(dev);

        return 1;

    }

    DriverControlWord |= WARM_REBOOT_CAPABLE;

    RCReportDriverCapability(pDpa->id, DriverControlWord);

    dev->init = &RCinit;

    ether_setup(dev);            /* linux kernel interface */

    pDpa->next = root_RCdev;

    root_RCdev = dev;

#ifdef MODULE

    if (register_netdev(dev) != 0) /* linux kernel interface */

    {

        printk("rc: unable to register device \n");

        free_irq(dev->irq, dev);

        iounmap(vaddr);

        kfree(dev);

        return 1;

    }

#else

    RCinit(dev);

#endif

    printk("%s: RedCreek Communications IPSEC VPN adapter\n",

        dev->name);

    return 0; /* success */

}

static int

RCopen(struct device *dev)

{

    int post_buffers = MAX_NMBR_RCV_BUFFERS;

    PDPA pDpa = (PDPA) dev->priv;

    int count = 0;

    int requested = 0;

#ifdef RCDEBUG

    printk("rc: RCopen\n");

#endif

    RCEnableI2OInterrupts(pDpa->id);

    if (pDpa->nexus)

    {

        /* This is not the first time RCopen is called.  Thus,

         * the interface was previously opened and later closed

         * by RCclose().  RCclose() does a Shutdown; to wake up

         * the adapter, a reset is mandatory before we can post

         * receive buffers.  However, if the adapter initiated

         * a reboot while the interface was closed -- and interrupts

         * were turned off -- we need will need to reinitialize

         * the adapter, rather than simply waking it up.

         */

        printk("rc: Waking up adapter...\n");

        RCResetLANCard(pDpa->id,0,0,0);

    }

    else

    {

        pDpa->nexus = 1;

    }

    while(post_buffers)

    {

        if (post_buffers > MAX_NMBR_POST_BUFFERS_PER_MSG)

            requested = MAX_NMBR_POST_BUFFERS_PER_MSG;

        else

            requested = post_buffers;

        count = RC_allocate_and_post_buffers(dev, requested);

        if ( count < requested )

        {

            /*

             * Check to see if we were able to post any buffers at all.

             */

            if (post_buffers == MAX_NMBR_RCV_BUFFERS)

            {

                printk("rc: Error RCopen: not able to allocate any buffers\r\n");

                return(-ENOMEM);

            }

            printk("rc: Warning RCopen: not able to allocate all requested buffers\r\n");

            break;            /* we'll try to post more buffers later */

        }

        else

            post_buffers -= count;

    }

    pDpa->numOutRcvBuffers = MAX_NMBR_RCV_BUFFERS - post_buffers;

    pDpa->shutdown = 0;        /* just in case */

#ifdef RCDEBUG

    printk("rc: RCopen: posted %d buffers\n", (uint)pDpa->numOutRcvBuffers);

#endif

    MOD_INC_USE_COUNT;

    return 0;

}

static int

RC_xmit_packet(struct sk_buff *skb, struct device *dev)

{

    PDPA pDpa = (PDPA) dev->priv;

    singleTCB tcb;

    psingleTCB ptcb = &tcb;

    RC_RETURN status = 0;

        if (dev->tbusy || pDpa->shutdown || pDpa->reboot)

        {

#ifdef RCDEBUG

            printk("rc: RC_xmit_packet: tbusy!\n");

#endif

            dev->tbusy = 1;

            return 1;

        }

    if ( skb->len <= 0 )

    {

        printk("RC_xmit_packet: skb->len less than 0!\n");

        return 0;

    }

    /*

     * The user is free to reuse the TCB after RCI2OSendPacket() returns, since

     * the function copies the necessary info into its own private space.  Thus,

     * our TCB can be a local structure.  The skb, on the other hand, will be

     * freed up in our interrupt handler.

     */

    ptcb->bcount = 1;

    /*

     * we'll get the context when the adapter interrupts us to tell us that

     * the transmision is done. At that time, we can free skb.

     */

    ptcb->b.context = (U32)skb;

    ptcb->b.scount = 1;

    ptcb->b.size = skb->len;

    ptcb->b.addr = virt_to_bus((void *)skb->data);

#ifdef RCDEBUG

    printk("rc: RC xmit: skb = 0x%x, pDpa = 0x%x, id = %d, ptcb = 0x%x\n",

           (uint)skb, (uint)pDpa, (uint)pDpa->id, (uint)ptcb);

#endif

    if ( (status = RCI2OSendPacket(pDpa->id, (U32)NULL, (PRCTCB)ptcb))

         != RC_RTN_NO_ERROR)

    {

#ifdef RCDEBUG

        printk("rc: RC send error 0x%x\n", (uint)status);

#endif

        dev->tbusy = 1;

        return 1;

    }

    else

    {

        dev->trans_start = jiffies;

        //       dev->tbusy = 0;

    }

    /*

     * That's it!

     */

    return 0;

}

/*

 * RCxmit_callback()

 *

 * The transmit callback routine. It's called by RCProcI2OMsgQ()

 * because the adapter is done with one or more transmit buffers and

 * it's returning them to us, or we asked the adapter to return the

 * outstanding transmit buffers by calling RCResetLANCard() with

 * RC_RESOURCE_RETURN_PEND_TX_BUFFERS flag.

 * All we need to do is free the buffers.

 */

static void

RCxmit_callback(U32 Status,

                U16 PcktCount,

                PU32 BufferContext,

                U16 AdapterID)

{

    struct sk_buff *skb;

    PDPA pDpa;

    struct device *dev;

        pDpa = PCIAdapters[AdapterID];

        if (!pDpa)

        {

            printk("rc: Fatal error: xmit callback, !pDpa\n");

            return;

        }

        dev = pDpa->dev;

        // printk("xmit_callback: Status = 0x%x\n", (uint)Status);

        if (Status != I2O_REPLY_STATUS_SUCCESS)

        {

            printk("rc: xmit_callback: Status = 0x%x\n", (uint)Status);

        }

#ifdef RCDEBUG

        if (pDpa->shutdown || pDpa->reboot)

            printk("rc: xmit callback: shutdown||reboot\n");

#endif

#ifdef RCDEBUG     

        printk("rc: xmit_callback: PcktCount = %d, BC = 0x%x\n",

               (uint)PcktCount, (uint)BufferContext);

#endif

        while (PcktCount--)

        {

            skb = (struct sk_buff *)(BufferContext[0]);

#ifdef RCDEBUG

            printk("rc: skb = 0x%x\n", (uint)skb);

#endif

            BufferContext++;

#ifdef LINUX_2_1

            dev_kfree_skb (skb);

#else

            dev_kfree_skb (skb, FREE_WRITE);

#endif

        }

        dev->tbusy = 0;

}

static void

RCreset_callback(U32 Status, U32 p1, U32 p2, U16 AdapterID)

{

    PDPA pDpa;

    struct device *dev;

    pDpa = PCIAdapters[AdapterID];

    dev = pDpa->dev;

#ifdef RCDEBUG

    printk("rc: RCreset_callback Status 0x%x\n", (uint)Status);

#endif

    /*

     * Check to see why we were called.

     */

    if (pDpa->shutdown)

    {

        printk("rc: Shutting down interface\n");

        pDpa->shutdown = 0;

        pDpa->reboot = 0;

        MOD_DEC_USE_COUNT;

    }

    else if (pDpa->reboot)

    {

        printk("rc: reboot, shutdown adapter\n");

        /*

         * We don't set any of the flags in RCShutdownLANCard()

         * and we don't pass a callback routine to it.

         * The adapter will have already initiated the reboot by

         * the time the function returns.

         */

        RCDisableI2OInterrupts(pDpa->id);

        RCShutdownLANCard(pDpa->id,0,0,0);

        printk("rc: scheduling timer...\n");

        init_timer(&pDpa->timer);

        pDpa->timer.expires = RUN_AT((40*HZ)/10); /* 4 sec. */

        pDpa->timer.data = (unsigned long)dev;

        pDpa->timer.function = &rc_timer;    /* timer handler */

        add_timer(&pDpa->timer);

    }

}

static void

RCreboot_callback(U32 Status, U32 p1, U32 p2, U16 AdapterID)

{

    PDPA pDpa;