Subversion Repositories or1k

/*

 *    Disk Array driver for Compaq SMART2 Controllers

 *    Copyright 1998 Compaq Computer Corporation

 *

 *    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, GOOD TITLE or

 *    NON INFRINGEMENT.  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.

 *

 *    Questions/Comments/Bugfixes to arrays@compaq.com

 *

 *    If you want to make changes, improve or add functionality to this

 *    driver, you'll probably need the Compaq Array Controller Interface

 *    Specificiation (Document number ECG086/1198)

 */

#include <linux/config.h>

#include <linux/types.h>

#include <linux/bios32.h>

#include <linux/pci.h>

#include <linux/kernel.h>

#include <linux/malloc.h>

#include <linux/delay.h>

#include <linux/major.h>

#include <linux/fs.h>

#include <linux/timer.h>

#include <linux/proc_fs.h>

#include <linux/hdreg.h>

#include <asm/io.h>

#include <asm/bitops.h>

#ifdef MODULE

#include <linux/module.h>

#include <linux/version.h>

#else

#define MOD_INC_USE_COUNT

#define MOD_DEC_USE_COUNT

#endif

#define DRIVER_NAME "Compaq SMART2 Driver (v 1.0)"

#define MAJOR_NR COMPAQ_SMART2_MAJOR

#include <linux/blk.h>

#include <linux/blkdev.h>

#include <linux/genhd.h>

#include "cpqarray.h"

#include "ida_cmd.h"

#include "ida_ioctl.h"

#define READ_AHEAD      128

#define NR_CMDS 128 /* This can probably go as high as ~400 */

#define MAX_CTLR        8

#define CTLR_SHIFT      8

static int nr_ctlr = 0;

static ctlr_info_t *hba[MAX_CTLR] = { 0, 0, 0, 0, 0, 0, 0, 0 };

#ifdef CONFIG_BLK_CPQ_DA_EISA

#ifndef MODULE

static

#endif

int eisa[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

#endif

static char *product_names[] = {

        "Unknown",

        "SMART-2/E",

        "SMART-2/P", /* or SMART-2DH */

        "SMART-2SL",

        "SMART-3200",

        "SMART-3100ES",

        "SMART-221",

};

static struct hd_struct * ida;

static int * ida_sizes;

static int * ida_blocksizes;

static int * ida_hardsizes;

static int * ida_maxsectors;

static int * ida_maxsegments;

static struct gendisk ida_gendisk[MAX_CTLR];

/* Debug... */

#define DBG(s)  s

/* Debug (general info)... */

#define DBGINFO(s)

/* Debug Paranoid... */

#define DBGP(s) s

/* Debug Extra Paranoid... */

#define DBGPX(s)

void cpqarray_init(void);

#ifdef CONFIG_BLK_CPQ_DA_PCI

static int cpqarray_pci_detect(void);

static void cpqarray_pci_init(ctlr_info_t *c, unchar bus, unchar device_fn);

static ulong remap_pci_mem(ulong base, ulong size);

#endif

#ifdef CONFIG_BLK_CPQ_DA_EISA

static int cpqarray_eisa_detect(void);

#endif

static void flushcomplete(int ctlr);

static int pollcomplete(int ctlr);

static void getgeometry(int ctlr);

static cmdlist_t * cmd_alloc(ctlr_info_t *h);

static void cmd_free(ctlr_info_t *h, cmdlist_t *c);

static int sendcmd(

        __u8    cmd,

        int     ctlr,

        void    *buff,

        size_t  size,

        unsigned int blk,

        unsigned int blkcnt,

        unsigned int log_unit );

static int ida_open(struct inode *inode, struct file *filep);

static void ida_release(struct inode *inode, struct file *filep);

static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd, unsigned long arg);

static int ida_ctlr_ioctl(int ctlr, int dsk, ida_ioctl_t *io);

static void do_ida_request(int i);

/*

 * This is a hack.  This driver eats a major number for each controller, and

 * sets blkdev[xxx].request_fn to each one of these so the real request

 * function knows what controller its working with.

 */

#define DO_IDA_REQUEST(x) { \

        int flags; save_flags(flags); cli(); \

        do_ida_request(x); restore_flags(flags); }

static void do_ida_request0(void) DO_IDA_REQUEST(0);

static void do_ida_request1(void) DO_IDA_REQUEST(1);

static void do_ida_request2(void) DO_IDA_REQUEST(2);

static void do_ida_request3(void) DO_IDA_REQUEST(3);

static void do_ida_request4(void) DO_IDA_REQUEST(4);

static void do_ida_request5(void) DO_IDA_REQUEST(5);

static void do_ida_request6(void) DO_IDA_REQUEST(6);

static void do_ida_request7(void) DO_IDA_REQUEST(7);

static void start_io(ctlr_info_t *h);

static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c);

static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c);

static inline void complete_buffers(struct buffer_head *bh, int ok);

static inline void complete_command(cmdlist_t *cmd, int timeout);

static void do_ida_intr(int irq, void *dev_id, struct pt_regs * regs);

static void ida_timer(unsigned long tdata);

static int frevalidate_logvol(kdev_t dev);

static int revalidate_logvol(kdev_t dev, int maxusage);

static int revalidate_allvol(kdev_t dev);

static void ida_procinit(int i);

static int ida_proc_get_info(char *buffer, char **start, off_t offset, int length, int dp);

/*

 * These macros control what happens when the driver tries to write to or

 * read from a card.  If the driver is configured for EISA only or PCI only,

 * the macros expand to inl/outl or readl/writel.  If the drive is configured

 * for both EISA and PCI, the macro expands to a conditional which uses

 * memory mapped IO if the card has it (PCI) or io ports if it doesn't (EISA).

 */

#ifdef CONFIG_BLK_CPQ_DA_PCI

#       ifdef CONFIG_BLK_CPQ_DA_EISA

#               define smart2_read(h, offset)  ( ((h)->vaddr) ? readl((h)->vaddr+(offset)) : inl((h)->ioaddr+(offset)) )

#               define smart2_write(p, h, offset) ( ((h)->vaddr) ? writel((p), (h)->vaddr+(offset)) : outl((p), (h)->ioaddr+(offset)) )

#       else

#               define smart2_read(h, offset)  readl((h)->vaddr+(offset))

#               define smart2_write(p, h, offset) writel((p), (h)->vaddr+(offset))

#       endif

#else

#       ifdef CONFIG_BLK_CPQ_DA_EISA

#               define smart2_read(h, offset)  inl((h)->vaddr+(offset))

#               define smart2_write(p, h, offset) outl((p), (h)->vaddr+(offset))

#       else

#               error "You must enable either SMART2 PCI support or SMART2 EISA support or both!"

#       endif

#endif

void ida_geninit(struct gendisk *g)

{

        int ctlr = g-ida_gendisk;

        int i,j;

        drv_info_t *drv;

        for(i=0; i<NWD; i++) {

                drv = &hba[ctlr]->drv[i];

                if (!drv->nr_blks)

                        continue;

                ida[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)].nr_sects =

                ida_sizes[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)] =

                                drv->nr_blks;

                for(j=0; j<16; j++) {

                        ida_blocksizes[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)+j] =

                                1024;

                        ida_hardsizes[(ctlr<<CTLR_SHIFT) + (i<<NWD_SHIFT)+j] =

                                drv->blk_size;

                }

                ida_gendisk[ctlr].nr_real++;

        }

}

struct file_operations ida_fops  = {

        NULL,                        /* lseek - default */

        block_read,                  /* read - general block-dev read */

        block_write,                 /* write - general block-dev write */

        NULL,                        /* readdir - bad */

        NULL,                        /* select */

        ida_ioctl,                  /* ioctl */

        NULL,                        /* mmap */

        ida_open,                     /* open code */

        ida_release,                  /* release */

        block_fsync,                  /* fsync */

        NULL,                        /* fasync */

        NULL,                   /* Disk change */

        frevalidate_logvol,     /* revalidate */

};

/*

 * Get us a file in /proc that says something about each controller.  Right

 * now, we add entries to /proc, but in the future we should probably get

 * our own subdir in /proc (/proc/array/ida) and put our stuff in there.

 */

extern struct inode_operations proc_diskarray_inode_operations;

struct proc_dir_entry *proc_array = NULL;

static void ida_procinit(int i)

{

        struct proc_dir_entry *pd;

        if (proc_array == NULL) {

                proc_array = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL);

                if (!proc_array) return;

                memset(proc_array, 0, sizeof(struct proc_dir_entry));

                proc_array->namelen = 5;

                proc_array->name = "array";

                proc_array->mode = S_IFDIR | S_IRUGO | S_IXUGO;

                proc_array->nlink = 2;

                proc_array->uid = 0;

                proc_array->gid = 0;

                proc_array->size = 0;

                proc_array->ops = &proc_dir_inode_operations;

                proc_register_dynamic(&proc_root, proc_array);

        }

        pd = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL);

        if (!pd) return;

        memset(pd, 0, sizeof(struct proc_dir_entry));

        pd->namelen = 4;

        pd->name = hba[i]->devname;

        pd->mode = S_IFREG | S_IRUGO;

        pd->nlink = 1;

        pd->uid = 0;

        pd->gid = 0;

        pd->size = 0;

        pd->ops = &proc_diskarray_inode_operations;

        pd->get_info = ida_proc_get_info;

        hba[i]->proc = (int)pd;

        proc_register_dynamic(proc_array, pd);

}

/*

 * Report information about this controller.

 */

static int ida_proc_get_info(char *buffer, char **start, off_t offset, int length, int pd)

{

        off_t pos = 0;

        off_t len = 0;

        int size, i, ctlr;

        ctlr_info_t *h;

        drv_info_t *drv;

#ifdef CPQ_PROC_PRINT_QUEUES

        cmdlist_t *c;

#endif

        for(ctlr=0; ctlr<nr_ctlr; ctlr++)

                if (hba[ctlr] && hba[ctlr]->proc == pd) break;

        if ((h = hba[ctlr]) == NULL)

                return 0;

        size = sprintf(buffer, "%s:  Compaq %s Disk Array Controller\n"

                "       Board ID: %08lx\n"

                "       Firmware Revision: %c%c%c%c\n"

                "       Controller Sig: %08lx\n"

                "       Memory Address: %08lx\n"

                "       I/O Port: %04x\n"

                "       IRQ: %x\n"

                "       Logical drives: %d\n"

                "       Physical drives: %d\n\n"

                "       Current Q depth: %d\n"

                "       Max Q depth since init: %d\n\n",

                h->devname,

                product_names[h->product],

                (unsigned long)h->board_id,

                h->firm_rev[0], h->firm_rev[1], h->firm_rev[2], h->firm_rev[3],

                (unsigned long)h->ctlr_sig, (unsigned long)h->vaddr,

                (unsigned int) h->ioaddr, (unsigned int)h->intr,

                h->log_drives, h->phys_drives,

                h->Qdepth, h->maxQsinceinit);

        pos += size; len += size;

        size = sprintf(buffer+len, "Logical Drive Info:\n");

        pos += size; len += size;

        for(i=0; i<h->log_drives; i++) {

                drv = &h->drv[i];

                size = sprintf(buffer+len, "ida/c%dd%d: blksz=%d nr_blks=%d\n",

                                ctlr, i, drv->blk_size, drv->nr_blks);

                pos += size; len += size;

        }

#ifdef CPQ_PROC_PRINT_QUEUES

        size = sprintf(buffer+len, "\nCurrent Queues:\n");

        pos += size; len += size;

        c = h->reqQ;

        size = sprintf(buffer+len, "reqQ = %p", c); pos += size; len += size;

        if (c) c=c->next;

        while(c && c != h->reqQ) {

                size = sprintf(buffer+len, "->%p", c);

                pos += size; len += size;

                c=c->next;

        }

        c = h->cmpQ;

        size = sprintf(buffer+len, "\ncmpQ = %p", c); pos += size; len += size;

        if (c) c=c->next;

        while(c && c != h->cmpQ) {

                size = sprintf(buffer+len, "->%p", c);

                pos += size; len += size;

                c=c->next;

        }

        size = sprintf(buffer+len, "\n"); pos += size; len += size;

#endif

        size = sprintf(buffer+len,"nr_allocs = %d\nnr_frees = %d\n",

                        h->nr_allocs, h->nr_frees);

        pos += size; len += size;

        *start = buffer+offset;

        len -= offset;

        if (len>length)

                len = length;

        return len;

}

#ifdef MODULE

/* This is a hack... */

#include "proc_array.c"

int init_module(void)

{

        int i, j;

        cpqarray_init();

        if (nr_ctlr == 0)

                return -EIO;

        for(i=0; i<nr_ctlr; i++) {

                ida_geninit(&ida_gendisk[i]);

                for(j=0; j<NWD; j++)

                        if (ida_sizes[(i<<CTLR_SHIFT) + (j<<NWD_SHIFT)])

                                resetup_one_dev(&ida_gendisk[i], j);

        }

        return 0;

}

void cleanup_module(void)

{

        int i;

        struct gendisk *g;

        for(i=0; i<nr_ctlr; i++) {

                smart2_write(0, hba[i], INTR_MASK);

                free_irq(hba[i]->intr, hba[i]);

                vfree((void*)hba[i]->vaddr);

                unregister_blkdev(MAJOR_NR+i, hba[i]->devname);

                del_timer(&hba[i]->timer);

                proc_unregister(proc_array,

                        ((struct proc_dir_entry*)hba[i]->proc)->low_ino);

                kfree(hba[i]->cmd_pool);

                kfree(hba[i]->cmd_pool_bits);

                if (gendisk_head == &ida_gendisk[i]) {

                        gendisk_head = ida_gendisk[i].next;

                } else {

                        for(g=gendisk_head; g; g=g->next) {

                                if (g->next == &ida_gendisk[i]) {

                                        g->next = ida_gendisk[i].next;

                                        break;

                                }

                        }

                }

                blk_dev[MAJOR_NR+i].request_fn = NULL;

                blksize_size[MAJOR_NR+i] = NULL;

                hardsect_size[MAJOR_NR+i] = NULL;

                max_sectors[MAJOR_NR+i] = NULL;

                max_segments[MAJOR_NR+i] = NULL;

        }

        proc_unregister(&proc_root, proc_array->low_ino);

        kfree(ida);

        kfree(ida_sizes);

        kfree(ida_hardsizes);

        kfree(ida_blocksizes);

        kfree(ida_maxsectors);

        kfree(ida_maxsegments);

}

#endif /* MODULE */

/*

 *  This is it.  Find all the controllers and register them.  I really hate

 *  stealing all these major device numbers.

 */

void cpqarray_init(void)

{

        void (*request_fns[MAX_CTLR])(void) = {

                do_ida_request0, do_ida_request1,

                do_ida_request2, do_ida_request3,

                do_ida_request4, do_ida_request5,

                do_ida_request6, do_ida_request7,

        };

        int i;

        /* detect controllers */

#ifdef CONFIG_BLK_CPQ_DA_PCI

        cpqarray_pci_detect();

#endif

#ifdef CONFIG_BLK_CPQ_DA_EISA

        cpqarray_eisa_detect();

#endif

        if (nr_ctlr == 0)

                return;

        printk(DRIVER_NAME "\n");

        printk("Found %d controller(s)\n", nr_ctlr);

        /* allocate space for disk structs */

        ida = kmalloc(sizeof(struct hd_struct)*nr_ctlr*NWD*16, GFP_KERNEL);

        ida_sizes =      kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);

        ida_blocksizes = kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);

        ida_hardsizes =  kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);

        ida_maxsegments =  kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);

        ida_maxsectors =  kmalloc(sizeof(int)*nr_ctlr*NWD*16, GFP_KERNEL);

        memset(ida, 0, sizeof(struct hd_struct)*nr_ctlr*NWD*16);

        memset(ida_sizes, 0, sizeof(int)*nr_ctlr*NWD*16);

        memset(ida_blocksizes, 0, sizeof(int)*nr_ctlr*NWD*16);

        memset(ida_hardsizes, 0, sizeof(int)*nr_ctlr*NWD*16);

        memset(ida_maxsegments, 0, sizeof(int)*nr_ctlr*NWD*16);

        memset(ida_maxsectors, 0, sizeof(int)*nr_ctlr*NWD*16);

        memset(ida_gendisk, 0, sizeof(struct gendisk)*MAX_CTLR);

        for(i=0; i<nr_ctlr*NWD*16; i++) {

                ida_maxsegments[i] = SG_MAX;

                ida_maxsectors[i] = 1024;

        }

        /*

         * register block devices

         * Find disks and fill in structs

         * Get an interrupt, set the Q depth and get into /proc

         */

        for(i=0; i< nr_ctlr; i++) {

                smart2_write(0, hba[i], INTR_MASK);  /* No interrupts */

                if (request_irq(hba[i]->intr, do_ida_intr,

                        SA_INTERRUPT | SA_SHIRQ, hba[i]->devname, hba[i])) {

                        printk("Unable to get irq %d for %s\n",

                                hba[i]->intr, hba[i]->devname);

                        continue;

                }

                if (register_blkdev(MAJOR_NR+i, hba[i]->devname, &ida_fops)) {

                        printk("Unable to get major number %d for %s\n",

                                MAJOR_NR+i, hba[i]->devname);

                        continue;

                }

                hba[i]->cmd_pool = (cmdlist_t*)kmalloc(

                                NR_CMDS*sizeof(cmdlist_t), GFP_KERNEL);

                hba[i]->cmd_pool_bits = (__u32*)kmalloc(

                                ((NR_CMDS+31)/32)*sizeof(__u32), GFP_KERNEL);

                memset(hba[i]->cmd_pool, 0, NR_CMDS*sizeof(cmdlist_t));

                memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+31)/32)*sizeof(__u32));

                printk("Finding drives on %s", hba[i]->devname);

                getgeometry(i);

                smart2_write(FIFO_NOT_EMPTY, hba[i], INTR_MASK);

                ida_procinit(i);

                ida_gendisk[i].major = MAJOR_NR + i;

                ida_gendisk[i].major_name = "ida";

                ida_gendisk[i].minor_shift = NWD_SHIFT;

                ida_gendisk[i].max_p = 16;

                ida_gendisk[i].max_nr = 16;

                ida_gendisk[i].init = ida_geninit;

                ida_gendisk[i].part = ida + (i*256);

                ida_gendisk[i].sizes = ida_sizes + (i*256);

                /* ida_gendisk[i].nr_real is handled by getgeometry */

                blk_dev[MAJOR_NR+i].request_fn = request_fns[i];

                blksize_size[MAJOR_NR+i] = ida_blocksizes + (i*256);

                hardsect_size[MAJOR_NR+i] = ida_hardsizes + (i*256);

                read_ahead[MAJOR_NR+i] = READ_AHEAD;

                max_sectors[MAJOR_NR+i] = ida_maxsectors + (i*256);

                max_segments[MAJOR_NR+i] = ida_maxsegments + (i*256);

                /* Get on the disk list */

                ida_gendisk[i].next = gendisk_head;

                gendisk_head = &ida_gendisk[i];

                init_timer(&hba[i]->timer);

                hba[i]->timer.expires = jiffies + IDA_TIMER;

                hba[i]->timer.data = (unsigned long)hba[i];

                hba[i]->timer.function = ida_timer;

                add_timer(&hba[i]->timer);

        }

        /* done ! */

}

#ifdef CONFIG_BLK_CPQ_DA_PCI

/*

 * Find the controller and initialize it

 */

static int cpqarray_pci_detect(void)

{

        int index;

        unchar bus=0, dev_fn=0;

        for(index=0; ; index++) {

                if (pcibios_find_device(PCI_VENDOR_ID_COMPAQ,

                        PCI_DEVICE_ID_COMPAQ_SMART2P, index, &bus, &dev_fn))

                        break;

                if (index == 1000000) break;

                if (nr_ctlr == 8) {

                        printk("This driver supports a maximum of "

                                "8 controllers.\n");

                        break;

                }

                hba[nr_ctlr] = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);

                memset(hba[nr_ctlr], 0, sizeof(ctlr_info_t));

                cpqarray_pci_init(hba[nr_ctlr], bus, dev_fn);

                sprintf(hba[nr_ctlr]->devname, "ida%d", nr_ctlr);

                hba[nr_ctlr]->ctlr = nr_ctlr;

                nr_ctlr++;

        }

        return nr_ctlr;

}

/*

 * Find the IO address of the controller, its IRQ and so forth.  Fill

 * in some basic stuff into the ctlr_info_t structure.

 */

static void cpqarray_pci_init(ctlr_info_t *c, unchar bus, unchar device_fn)

{

        ushort vendor_id, device_id, command;

        unchar cache_line_size, latency_timer;

        unchar irq, revision;

        uint addr[6];

        int i;

        (void) pcibios_read_config_word(bus, device_fn,

                                        PCI_VENDOR_ID, &vendor_id);

        (void) pcibios_read_config_word(bus, device_fn,

                                        PCI_DEVICE_ID, &device_id);

        (void) pcibios_read_config_word(bus, device_fn,

                                        PCI_COMMAND, &command);

        for(i=0; i<6; i++)

                (void) pcibios_read_config_dword(bus, device_fn,

                                PCI_BASE_ADDRESS_0 + i*4, addr+i);

        (void) pcibios_read_config_byte(bus, device_fn,

                                        PCI_CLASS_REVISION,&revision);

        (void) pcibios_read_config_byte(bus, device_fn,

                                        PCI_INTERRUPT_LINE, &irq);

        (void) pcibios_read_config_byte(bus, device_fn,

                                        PCI_CACHE_LINE_SIZE, &cache_line_size);

        (void) pcibios_read_config_byte(bus, device_fn,

                                        PCI_LATENCY_TIMER, &latency_timer);

DBGINFO(

        printk("vendor_id = %x\n", vendor_id);

        printk("device_id = %x\n", device_id);

        printk("command = %x\n", command);

        for(i=0; i<6; i++)

                printk("addr[%d] = %x\n", i, addr[i]);

        printk("revision = %x\n", revision);