Subversion Repositories or1k

/*

 *    Disk Array driver for HP SA 5xxx and 6xxx Controllers, SCSI Tape module

 *    Copyright 2001, 2002 Hewlett-Packard Development Company, L.P.

 *

 *    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 Cciss-discuss@lists.sourceforge.net

 *

 *    Author: Stephen M. Cameron

 */

#ifdef CONFIG_CISS_SCSI_TAPE

/* Here we have code to present the driver as a scsi driver

   as it is simultaneously presented as a block driver.  The

   reason for doing this is to allow access to SCSI tape drives

   through the array controller.  Note in particular, neither

   physical nor logical disks are presented through the scsi layer. */

#include "../scsi/scsi.h"

#include "../scsi/hosts.h"

#include <asm/atomic.h>

#include <linux/timer.h>

#include "cciss_scsi.h"

/* some prototypes... */

static int sendcmd(

        __u8    cmd,

        int     ctlr,

        void    *buff,

        size_t  size,

        unsigned int use_unit_num, /* 0: address the controller,

                                      1: address logical volume log_unit,

                                      2: address is in scsi3addr */

        unsigned int log_unit,

        __u8    page_code,

        unsigned char *scsi3addr );

int __init cciss_scsi_detect(Scsi_Host_Template *tpnt);

int cciss_scsi_release(struct Scsi_Host *sh);

const char *cciss_scsi_info(struct Scsi_Host *sa);

int cciss_scsi_proc_info(

                char *buffer, /* data buffer */

                char **start,      /* where data in buffer starts */

                off_t offset,      /* offset from start of imaginary file */

                int length,        /* length of data in buffer */

                int hostnum,       /* which host adapter (always zero for me) */

                int func);         /* 0 == read, 1 == write */

int cciss_scsi_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *));

#if 0

int cciss_scsi_abort(Scsi_Cmnd *cmd);

#if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS

int cciss_scsi_reset(Scsi_Cmnd *cmd, unsigned int reset_flags);

#else

int cciss_scsi_reset(Scsi_Cmnd *cmd);

#endif

#endif

static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR];

/* We need one Scsi_Host_Template *per controller* instead of

   the usual one Scsi_Host_Template per controller *type*. This

   is so PCI hot plug could have a remote possibility of still

   working even with the SCSI system.  It's so

   scsi_unregister_module will differentiate the controllers.

   When register_scsi_module is called, each host template is

   customized (name change) in cciss_register_scsi()

   (that's called from cciss.c:cciss_init_one()) */

static

Scsi_Host_Template driver_template[MAX_CTLR];

#pragma pack(1)

struct cciss_scsi_cmd_stack_elem_t {

        CommandList_struct cmd;

        ErrorInfo_struct Err;

        __u32 busaddr; // 32 bits always, must fit through cmd register.

};

#pragma pack()

#define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \

                CCISS_MAX_SCSI_DEVS_PER_HBA + 2)

                        // plus two for init time usage

#pragma pack(1)

struct cciss_scsi_cmd_stack_t {

        struct cciss_scsi_cmd_stack_elem_t *pool;

        struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];

        dma_addr_t cmd_pool_handle;

        int top;

};

#pragma pack()

struct cciss_scsi_adapter_data_t {

        struct Scsi_Host *scsi_host;

        struct cciss_scsi_cmd_stack_t cmd_stack;

        int registered;

        spinlock_t lock; // to protect ccissscsi[ctlr];

};

#if 1

#define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \

        &(((struct cciss_scsi_adapter_data_t *) \

        hba[ctlr]->scsi_ctlr)->lock), flags);

#define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \

        &(((struct cciss_scsi_adapter_data_t *) \

        hba[ctlr]->scsi_ctlr)->lock), flags);

#else

#define CPQ_TAPE_LOCK(x,y)

#define CPQ_TAPE_UNLOCK(x,y)

#endif

static CommandList_struct *

scsi_cmd_alloc(ctlr_info_t *h)

{

        /* assume only one process in here at a time, locking done by caller. */

        /* take the top memory chunk off the stack and return it, if any. */

        struct cciss_scsi_cmd_stack_elem_t *c;

        struct cciss_scsi_adapter_data_t *sa;

        struct cciss_scsi_cmd_stack_t *stk;

        u64bit temp64;

        sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;

        stk = &sa->cmd_stack;

        if (stk->top < 0)

                return NULL;

        c = stk->elem[stk->top];

        memset(&c->cmd, 0, sizeof(c->cmd));

        memset(&c->Err, 0, sizeof(c->Err));

        /* set physical addr of cmd and addr of scsi parameters */

        c->cmd.busaddr = c->busaddr;

        temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));

        stk->top--;

        c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;

        c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;

        c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);

        c->cmd.ctlr = h->ctlr;

        c->cmd.err_info = &c->Err;

        return (CommandList_struct *) c;

}

static void

scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)

{

        /* assume only one process in here at a time, locking done by caller. */

        /* drop the free memory chunk on top of the stack. */

        struct cciss_scsi_adapter_data_t *sa;

        struct cciss_scsi_cmd_stack_t *stk;

        sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;

        stk = &sa->cmd_stack;

        if (stk->top >= CMD_STACK_SIZE) {

                printk("cciss: scsi_cmd_free called too many times.\n");

                BUG();

        }

        stk->top++;

        stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;

}

static int

scsi_cmd_stack_setup(int ctlr)

{

        int i;

        struct cciss_scsi_adapter_data_t *sa;

        struct cciss_scsi_cmd_stack_t *stk;

        size_t size;

        sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;

        stk = &sa->cmd_stack;

        size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;

        stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)

                pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);

        if (stk->pool == NULL) {

                printk("stk->pool is null\n");

                return -1;

        }

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

                stk->elem[i] = &stk->pool[i];

                stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +

                        (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));

        }

        stk->top = CMD_STACK_SIZE-1;

        return 0;

}

static void

scsi_cmd_stack_free(int ctlr)

{

        struct cciss_scsi_adapter_data_t *sa;

        struct cciss_scsi_cmd_stack_t *stk;

        size_t size;

        sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;

        stk = &sa->cmd_stack;

        if (stk->top != CMD_STACK_SIZE-1) {

                printk( "cciss: %d scsi commands are still outstanding.\n",

                        CMD_STACK_SIZE - stk->top);

                // BUG();

                printk("WE HAVE A BUG HERE!!! stk=0x%08x\n",

                        (unsigned int) stk);

        }

        size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;

        pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);

        stk->pool = NULL;

}

/* scsi_device_types comes from scsi.h */

#define DEVICETYPE(n) (n<0 || n>MAX_SCSI_DEVICE_CODE) ? \

        "Unknown" : scsi_device_types[n]

#if 0

static int xmargin=8;

static int amargin=60;

static void

print_bytes (unsigned char *c, int len, int hex, int ascii)

{

        int i;

        unsigned char *x;

        if (hex)

        {

                x = c;

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

                {

                        if ((i % xmargin) == 0 && i>0) printk("\n");

                        if ((i % xmargin) == 0) printk("0x%04x:", i);

                        printk(" %02x", *x);

                        x++;

                }

                printk("\n");

        }

        if (ascii)

        {

                x = c;

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

                {

                        if ((i % amargin) == 0 && i>0) printk("\n");

                        if ((i % amargin) == 0) printk("0x%04x:", i);

                        if (*x > 26 && *x < 128) printk("%c", *x);

                        else printk(".");

                        x++;

                }

                printk("\n");

        }

}

static void

print_cmd(CommandList_struct *cp)

{

        printk("queue:%d\n", cp->Header.ReplyQueue);

        printk("sglist:%d\n", cp->Header.SGList);

        printk("sgtot:%d\n", cp->Header.SGTotal);

        printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,

                        cp->Header.Tag.lower);

        printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",

                cp->Header.LUN.LunAddrBytes[0],

                cp->Header.LUN.LunAddrBytes[1],

                cp->Header.LUN.LunAddrBytes[2],

                cp->Header.LUN.LunAddrBytes[3],

                cp->Header.LUN.LunAddrBytes[4],

                cp->Header.LUN.LunAddrBytes[5],

                cp->Header.LUN.LunAddrBytes[6],

                cp->Header.LUN.LunAddrBytes[7]);

        printk("CDBLen:%d\n", cp->Request.CDBLen);

        printk("Type:%d\n",cp->Request.Type.Type);

        printk("Attr:%d\n",cp->Request.Type.Attribute);

        printk(" Dir:%d\n",cp->Request.Type.Direction);

        printk("Timeout:%d\n",cp->Request.Timeout);

        printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"

                " %02x %02x %02x %02x %02x %02x %02x %02x\n",

                cp->Request.CDB[0], cp->Request.CDB[1],

                cp->Request.CDB[2], cp->Request.CDB[3],

                cp->Request.CDB[4], cp->Request.CDB[5],

                cp->Request.CDB[6], cp->Request.CDB[7],

                cp->Request.CDB[8], cp->Request.CDB[9],

                cp->Request.CDB[10], cp->Request.CDB[11],

                cp->Request.CDB[12], cp->Request.CDB[13],

                cp->Request.CDB[14], cp->Request.CDB[15]),

        printk("edesc.Addr: 0x%08x/0%08x, Len  = %d\n",

                cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,

                        cp->ErrDesc.Len);

        printk("sgs..........Errorinfo:\n");

        printk("scsistatus:%d\n", cp->err_info->ScsiStatus);

        printk("senselen:%d\n", cp->err_info->SenseLen);

        printk("cmd status:%d\n", cp->err_info->CommandStatus);

        printk("resid cnt:%d\n", cp->err_info->ResidualCnt);

        printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);

        printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);

        printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);

}

#endif

static int

find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)

{

        /* finds an unused bus, target, lun for a new device */

        /* assumes hba[ctlr]->scsi_ctlr->lock is held */

        int i, found=0;

        unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];

        memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);

#       if SELF_SCSI_ID >= 0

                target_taken[SELF_SCSI_ID] = 1;

#       endif

        for (i=0;i<ccissscsi[ctlr].ndevices;i++)

                target_taken[ccissscsi[ctlr].dev[i].target] = 1;

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

                if (!target_taken[i]) {

                        *bus = 0; *target=i; *lun = 0; found=1;

                        break;

                }

        }

        return (!found);

}

static int

cciss_scsi_add_entry(int ctlr, int hostno,

                unsigned char *scsi3addr, int devtype)

{

        /* assumes hba[ctlr]->scsi_ctlr->lock is held */

        int n = ccissscsi[ctlr].ndevices;

        struct cciss_scsi_dev_t *sd;

        if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {

                printk("cciss%d: Too many devices, "

                        "some will be inaccessible.\n", ctlr);

                return -1;

        }

        sd = &ccissscsi[ctlr].dev[n];

        if (find_bus_target_lun(ctlr, &sd->bus, &sd->target, &sd->lun) != 0)

                return -1;

        memcpy(&sd->scsi3addr[0], scsi3addr, 8);

        sd->devtype = devtype;

        ccissscsi[ctlr].ndevices++;

        /* initially, (before registering with scsi layer) we don't

           know our hostno and we don't want to print anything first

           time anyway (the scsi layer's inquiries will show that info) */

        if (hostno != -1)

                printk("cciss%d: %s device c%db%dt%dl%d added.\n",

                        ctlr, DEVICETYPE(sd->devtype), hostno,

                        sd->bus, sd->target, sd->lun);

        return 0;

}

static void

cciss_scsi_remove_entry(int ctlr, int hostno, int entry)

{

        /* assumes hba[ctlr]->scsi_ctlr->lock is held */

        int i;

        struct cciss_scsi_dev_t sd;

        if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;

        sd = ccissscsi[ctlr].dev[entry];

        for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)

                ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];

        ccissscsi[ctlr].ndevices--;

        printk("cciss%d: %s device c%db%dt%dl%d removed.\n",

                ctlr, DEVICETYPE(sd.devtype), hostno,

                        sd.bus, sd.target, sd.lun);

}

#define SCSI3ADDR_EQ(a,b) ( \

        (a)[7] == (b)[7] && \

        (a)[6] == (b)[6] && \

        (a)[5] == (b)[5] && \

        (a)[4] == (b)[4] && \

        (a)[3] == (b)[3] && \

        (a)[2] == (b)[2] && \

        (a)[1] == (b)[1] && \

        (a)[0] == (b)[0])

static int

adjust_cciss_scsi_table(int ctlr, int hostno,

        struct cciss_scsi_dev_t sd[], int nsds)

{

        /* sd contains scsi3 addresses and devtypes, but

           bus target and lun are not filled in.  This funciton

           takes what's in sd to be the current and adjusts

           ccissscsi[] to be in line with what's in sd. */

        int i,j, found, changes=0;

        struct cciss_scsi_dev_t *csd;

        unsigned long flags;

        CPQ_TAPE_LOCK(ctlr, flags);

        /* find any devices in ccissscsi[] that are not in

           sd[] and remove them from ccissscsi[] */

        i = 0;

        while(i<ccissscsi[ctlr].ndevices) {

                csd = &ccissscsi[ctlr].dev[i];

                found=0;

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

                        if (SCSI3ADDR_EQ(sd[j].scsi3addr,

                                csd->scsi3addr)) {

                                if (sd[j].devtype == csd->devtype)

                                        found=2;

                                else

                                        found=1;

                                break;

                        }

                }

                if (found == 0) { /* device no longer present. */

                        changes++;

                        /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",

                                ctlr, DEVICETYPE(csd->devtype), hostno,

                                        csd->bus, csd->target, csd->lun); */

                        cciss_scsi_remove_entry(ctlr, hostno, i);

                        /* note, i not incremented */

                }

                else if (found == 1) { /* device is different kind */

                        changes++;

                        printk("cciss%d: device c%db%dt%dl%d type changed "

                                "(device type now %s).\n",

                                ctlr, hostno, csd->bus, csd->target, csd->lun,

                                        DEVICETYPE(csd->devtype));

                        csd->devtype = sd[j].devtype;

                        i++;    /* so just move along. */

                } else          /* device is same as it ever was, */

                        i++;    /* so just move along. */

        }

        /* Now, make sure every device listed in sd[] is also

           listed in ccissscsi[], adding them if they aren't found */

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

                found=0;

                for (j=0;j<ccissscsi[ctlr].ndevices;j++) {

                        csd = &ccissscsi[ctlr].dev[j];

                        if (SCSI3ADDR_EQ(sd[i].scsi3addr,

                                csd->scsi3addr)) {

                                if (sd[i].devtype == csd->devtype)

                                        found=2;        /* found device */

                                else

                                        found=1;        /* found a bug. */

                                break;

                        }

                }

                if (!found) {

                        changes++;

                        if (cciss_scsi_add_entry(ctlr, hostno,

                                &sd[i].scsi3addr[0], sd[i].devtype) != 0)

                                break;

                } else if (found == 1) {

                        /* should never happen... */

                        changes++;

                        printk("cciss%d: device unexpectedly changed type\n",

                                ctlr);

                        /* but if it does happen, we just ignore that device */

                }

        }

        CPQ_TAPE_UNLOCK(ctlr, flags);

        if (!changes)

                printk("cciss%d: No device changes detected.\n", ctlr);

        return 0;

}

static int

lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)

{

        int i;

        struct cciss_scsi_dev_t *sd;

        unsigned long flags;

        CPQ_TAPE_LOCK(ctlr, flags);

        for (i=0;i<ccissscsi[ctlr].ndevices;i++) {

                sd = &ccissscsi[ctlr].dev[i];

                if (sd->bus == bus &&

                    sd->target == target &&

                    sd->lun == lun) {

                        memcpy(scsi3addr, &sd->scsi3addr[0], 8);

                        CPQ_TAPE_UNLOCK(ctlr, flags);

                        return 0;

                }

        }

        CPQ_TAPE_UNLOCK(ctlr, flags);

        return -1;

}

static void

cciss_find_non_disk_devices(int cntl_num)

{

        ReportLunData_struct *ld_buff;

        InquiryData_struct *inq_buff;

        int return_code;

        int i;

        int listlength = 0;

        int num_luns;

        unsigned char scsi3addr[8];

        unsigned long flags;

        int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;

        hba[cntl_num]->scsi_ctlr = (void *)

                kmalloc(sizeof(struct cciss_scsi_adapter_data_t),

                        GFP_KERNEL);

        if (hba[cntl_num]->scsi_ctlr == NULL)

                return;

        ((struct cciss_scsi_adapter_data_t *)

                hba[cntl_num]->scsi_ctlr)->scsi_host = NULL;

        ((struct cciss_scsi_adapter_data_t *)

                hba[cntl_num]->scsi_ctlr)->lock = SPIN_LOCK_UNLOCKED;

        ((struct cciss_scsi_adapter_data_t *)

                hba[cntl_num]->scsi_ctlr)->registered = 0;

        if (scsi_cmd_stack_setup(cntl_num) != 0) {

                printk("Trouble, returned non-zero!\n");

                return;

        }

        ld_buff = kmalloc(reportlunsize, GFP_KERNEL);

        if (ld_buff == NULL) {

                printk(KERN_ERR "cciss: out of memory\n");

                return;

        }

        memset(ld_buff, 0, sizeof(ReportLunData_struct));

        inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);

        if (inq_buff == NULL) {

                printk(KERN_ERR "cciss: out of memory\n");

                kfree(ld_buff);

                return;

        }

        /* Get the physical luns */

        return_code = sendcmd(CISS_REPORT_PHYS, cntl_num, ld_buff,

                        reportlunsize, 0, 0, 0, NULL );

        if( return_code == IO_OK) {

                unsigned char *c = &ld_buff->LUNListLength[0];

                listlength = (c[0] << 24) | (c[1] << 16) | (c[2] << 8) | c[3];

        }

        else {  /* getting report of physical luns failed */

                printk(KERN_WARNING "cciss: report physical luns"

                        " command failed\n");

                listlength = 0;

        }

        CPQ_TAPE_LOCK(cntl_num, flags);

        ccissscsi[cntl_num].ndevices = 0;

        num_luns = listlength / 8; // 8 bytes pre entry

        /* printk("Found %d LUNs\n", num_luns); */

        if (num_luns > CISS_MAX_PHYS_LUN)

        {

                printk(KERN_WARNING

                        "cciss: Maximum physical LUNs (%d) exceeded.  "

                        "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,

                        num_luns - CISS_MAX_PHYS_LUN);

                num_luns = CISS_MAX_PHYS_LUN;

        }

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

                /* Execute an inquiry to figure the device type */

                /* Skip over masked devices */

                if (ld_buff->LUN[i][3] & 0xC0) continue;

                memset(inq_buff, 0, sizeof(InquiryData_struct));

                memcpy(scsi3addr, ld_buff->LUN[i], 8); /* ugly... */

                return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,

                        sizeof(InquiryData_struct), 2, 0 ,0, scsi3addr );

                if (return_code == IO_OK) {

                        if(inq_buff->data_byte[8] == 0xFF)

                        {

                           printk(KERN_WARNING "cciss: inquiry failed\n");

                        } else {

                           int devtype;

                           /* printk("Inquiry...\n");

                           print_bytes((unsigned char *) inq_buff, 36, 1, 1); */

                           devtype = (inq_buff->data_byte[0] & 0x1f);

                           switch (devtype)

                           {

                            case 0x01: /* sequential access, (tape) */

                            case 0x08: /* medium changer */

                                          /* this is the only kind of dev */

                                          /* we want to expose here. */

                                if (cciss_scsi_add_entry(cntl_num, -1,

                                        (unsigned char *) ld_buff->LUN[i],