drivers/block/cciss.c

   1 /*
   2  *    Disk Array driver for HP Smart Array controllers.
   3  *    (C) Copyright 2000, 2007 Hewlett-Packard Development Company, L.P.
   4  *
   5  *    This program is free software; you can redistribute it and/or modify
   6  *    it under the terms of the GNU General Public License as published by
   7  *    the Free Software Foundation; version 2 of the License.
   8  *
   9  *    This program is distributed in the hope that it will be useful,
  10  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  *    General Public License for more details.
  13  *
  14  *    You should have received a copy of the GNU General Public License
  15  *    along with this program; if not, write to the Free Software
  16  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17  *    02111-1307, USA.
  18  *
  19  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
  20  *
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/types.h>
  26 #include <linux/pci.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/delay.h>
  30 #include <linux/major.h>
  31 #include <linux/fs.h>
  32 #include <linux/bio.h>
  33 #include <linux/blkpg.h>
  34 #include <linux/timer.h>
  35 #include <linux/proc_fs.h>
  36 #include <linux/init.h>
  37 #include <linux/hdreg.h>
  38 #include <linux/spinlock.h>
  39 #include <linux/compat.h>
  40 #include <linux/blktrace_api.h>
  41 #include <asm/uaccess.h>
  42 #include <asm/io.h>
  43
  44 #include <linux/dma-mapping.h>
  45 #include <linux/blkdev.h>
  46 #include <linux/genhd.h>
  47 #include <linux/completion.h>
  48 #include <scsi/scsi.h>
  49 #include <scsi/sg.h>
  50 #include <scsi/scsi_ioctl.h>
  51 #include <linux/cdrom.h>
  52
  53 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
  54 #define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
  55 #define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14)
  56
  57 /* Embedded module documentation macros - see modules.h */
  58 MODULE_AUTHOR("Hewlett-Packard Company");
  59 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14");
  60 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
  61                         " SA6i P600 P800 P400 P400i E200 E200i E500");
  62 MODULE_VERSION("3.6.14");
  63 MODULE_LICENSE("GPL");
  64
  65 #include "cciss_cmd.h"
  66 #include "cciss.h"
  67 #include <linux/cciss_ioctl.h>
  68
  69 /* define the PCI info for the cards we can control */
  70 static const struct pci_device_id cciss_pci_device_id[] = {
  71         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
  72         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
  73         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
  74         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
  75         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
  76         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
  77         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
  78         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
  79         {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
  80         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
  81         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
  82         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
  83         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
  84         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
  85         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
  86         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
  87         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
  88         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},
  89         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3237},
  90         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x323D},
  91         {PCI_VENDOR_ID_HP,     PCI_ANY_ID,      PCI_ANY_ID, PCI_ANY_ID,
  92                 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
  93         {0,}
  94 };
  95
  96 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
  97
  98 /*  board_id = Subsystem Device ID & Vendor ID
  99  *  product = Marketing Name for the board
 100  *  access = Address of the struct of function pointers
 101  *  nr_cmds = Number of commands supported by controller
 102  */
 103 static struct board_type products[] = {
 104         {0x40700E11, "Smart Array 5300", &SA5_access, 512},
 105         {0x40800E11, "Smart Array 5i", &SA5B_access, 512},
 106         {0x40820E11, "Smart Array 532", &SA5B_access, 512},
 107         {0x40830E11, "Smart Array 5312", &SA5B_access, 512},
 108         {0x409A0E11, "Smart Array 641", &SA5_access, 512},
 109         {0x409B0E11, "Smart Array 642", &SA5_access, 512},
 110         {0x409C0E11, "Smart Array 6400", &SA5_access, 512},
 111         {0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512},
 112         {0x40910E11, "Smart Array 6i", &SA5_access, 512},
 113         {0x3225103C, "Smart Array P600", &SA5_access, 512},
 114         {0x3223103C, "Smart Array P800", &SA5_access, 512},
 115         {0x3234103C, "Smart Array P400", &SA5_access, 512},
 116         {0x3235103C, "Smart Array P400i", &SA5_access, 512},
 117         {0x3211103C, "Smart Array E200i", &SA5_access, 120},
 118         {0x3212103C, "Smart Array E200", &SA5_access, 120},
 119         {0x3213103C, "Smart Array E200i", &SA5_access, 120},
 120         {0x3214103C, "Smart Array E200i", &SA5_access, 120},
 121         {0x3215103C, "Smart Array E200i", &SA5_access, 120},
 122         {0x3237103C, "Smart Array E500", &SA5_access, 512},
 123         {0x323D103C, "Smart Array P700m", &SA5_access, 512},
 124         {0xFFFF103C, "Unknown Smart Array", &SA5_access, 120},
 125 };
 126
 127 /* How long to wait (in milliseconds) for board to go into simple mode */
 128 #define MAX_CONFIG_WAIT 30000
 129 #define MAX_IOCTL_CONFIG_WAIT 1000
 130
 131 /*define how many times we will try a command because of bus resets */
 132 #define MAX_CMD_RETRIES 3
 133
 134 #define READ_AHEAD       1024
 135 #define MAX_CTLR        32
 136
 137 /* Originally cciss driver only supports 8 major numbers */
 138 #define MAX_CTLR_ORIG   8
 139
 140 static ctlr_info_t *hba[MAX_CTLR];
 141
 142 static void do_cciss_request(struct request_queue *q);
 143 static irqreturn_t do_cciss_intr(int irq, void *dev_id);
 144 static int cciss_open(struct inode *inode, struct file *filep);
 145 static int cciss_release(struct inode *inode, struct file *filep);
 146 static int cciss_ioctl(struct inode *inode, struct file *filep,
 147                        unsigned int cmd, unsigned long arg);
 148 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 149
 150 static int cciss_revalidate(struct gendisk *disk);
 151 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
 152 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
 153                            int clear_all);
 154
 155 static void cciss_read_capacity(int ctlr, int logvol, int withirq,
 156                         sector_t *total_size, unsigned int *block_size);
 157 static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
 158                         sector_t *total_size, unsigned int *block_size);
 159 static void cciss_geometry_inquiry(int ctlr, int logvol,
 160                         int withirq, sector_t total_size,
 161                         unsigned int block_size, InquiryData_struct *inq_buff,
 162                                    drive_info_struct *drv);
 163 static void cciss_getgeometry(int cntl_num);
 164 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
 165                                            __u32);
 166 static void start_io(ctlr_info_t *h);
 167 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
 168                    unsigned int use_unit_num, unsigned int log_unit,
 169                    __u8 page_code, unsigned char *scsi3addr, int cmd_type);
 170 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
 171                            unsigned int use_unit_num, unsigned int log_unit,
 172                            __u8 page_code, int cmd_type);
 173
 174 static void fail_all_cmds(unsigned long ctlr);
 175
 176 #ifdef CONFIG_PROC_FS
 177 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 178                                int length, int *eof, void *data);
 179 static void cciss_procinit(int i);
 180 #else
 181 static void cciss_procinit(int i)
 182 {
 183 }
 184 #endif                          /* CONFIG_PROC_FS */
 185
 186 #ifdef CONFIG_COMPAT
 187 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 188 #endif
 189
 190 static struct block_device_operations cciss_fops = {
 191         .owner = THIS_MODULE,
 192         .open = cciss_open,
 193         .release = cciss_release,
 194         .ioctl = cciss_ioctl,
 195         .getgeo = cciss_getgeo,
 196 #ifdef CONFIG_COMPAT
 197         .compat_ioctl = cciss_compat_ioctl,
 198 #endif
 199         .revalidate_disk = cciss_revalidate,
 200 };
 201
 202 /*
 203  * Enqueuing and dequeuing functions for cmdlists.
 204  */
 205 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
 206 {
 207         if (*Qptr == NULL) {
 208                 *Qptr = c;
 209                 c->next = c->prev = c;
 210         } else {
 211                 c->prev = (*Qptr)->prev;
 212                 c->next = (*Qptr);
 213                 (*Qptr)->prev->next = c;
 214                 (*Qptr)->prev = c;
 215         }
 216 }
 217
 218 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
 219                                           CommandList_struct *c)
 220 {
 221         if (c && c->next != c) {
 222                 if (*Qptr == c)
 223                         *Qptr = c->next;
 224                 c->prev->next = c->next;
 225                 c->next->prev = c->prev;
 226         } else {
 227                 *Qptr = NULL;
 228         }
 229         return c;
 230 }
 231
 232 #include "cciss_scsi.c"         /* For SCSI tape support */
 233
 234 #define RAID_UNKNOWN 6
 235
 236 #ifdef CONFIG_PROC_FS
 237
 238 /*
 239  * Report information about this controller.
 240  */
 241 #define ENG_GIG 1000000000
 242 #define ENG_GIG_FACTOR (ENG_GIG/512)
 243 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
 244         "UNKNOWN"
 245 };
 246
 247 static struct proc_dir_entry *proc_cciss;
 248
 249 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 250                                int length, int *eof, void *data)
 251 {
 252         off_t pos = 0;
 253         off_t len = 0;
 254         int size, i, ctlr;
 255         ctlr_info_t *h = (ctlr_info_t *) data;
 256         drive_info_struct *drv;
 257         unsigned long flags;
 258         sector_t vol_sz, vol_sz_frac;
 259
 260         ctlr = h->ctlr;
 261
 262         /* prevent displaying bogus info during configuration
 263          * or deconfiguration of a logical volume
 264          */
 265         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 266         if (h->busy_configuring) {
 267                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 268                 return -EBUSY;
 269         }
 270         h->busy_configuring = 1;
 271         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 272
 273         size = sprintf(buffer, "%s: HP %s Controller\n"
 274                        "Board ID: 0x%08lx\n"
 275                        "Firmware Version: %c%c%c%c\n"
 276                        "IRQ: %d\n"
 277                        "Logical drives: %d\n"
 278                        "Max sectors: %d\n"
 279                        "Current Q depth: %d\n"
 280                        "Current # commands on controller: %d\n"
 281                        "Max Q depth since init: %d\n"
 282                        "Max # commands on controller since init: %d\n"
 283                        "Max SG entries since init: %d\n\n",
 284                        h->devname,
 285                        h->product_name,
 286                        (unsigned long)h->board_id,
 287                        h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
 288                        h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
 289                        h->num_luns,
 290                        h->cciss_max_sectors,
 291                        h->Qdepth, h->commands_outstanding,
 292                        h->maxQsinceinit, h->max_outstanding, h->maxSG);
 293
 294         pos += size;
 295         len += size;
 296         cciss_proc_tape_report(ctlr, buffer, &pos, &len);
 297         for (i = 0; i <= h->highest_lun; i++) {
 298
 299                 drv = &h->drv[i];
 300                 if (drv->heads == 0)
 301                         continue;
 302
 303                 vol_sz = drv->nr_blocks;
 304                 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
 305                 vol_sz_frac *= 100;
 306                 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
 307
 308                 if (drv->raid_level > 5)
 309                         drv->raid_level = RAID_UNKNOWN;
 310                 size = sprintf(buffer + len, "cciss/c%dd%d:"
 311                                "\t%4u.%02uGB\tRAID %s\n",
 312                                ctlr, i, (int)vol_sz, (int)vol_sz_frac,
 313                                raid_label[drv->raid_level]);
 314                 pos += size;
 315                 len += size;
 316         }
 317
 318         *eof = 1;
 319         *start = buffer + offset;
 320         len -= offset;
 321         if (len > length)
 322                 len = length;
 323         h->busy_configuring = 0;
 324         return len;
 325 }
 326
 327 static int
 328 cciss_proc_write(struct file *file, const char __user *buffer,
 329                  unsigned long count, void *data)
 330 {
 331         unsigned char cmd[80];
 332         int len;
 333 #ifdef CONFIG_CISS_SCSI_TAPE
 334         ctlr_info_t *h = (ctlr_info_t *) data;
 335         int rc;
 336 #endif
 337
 338         if (count > sizeof(cmd) - 1)
 339                 return -EINVAL;
 340         if (copy_from_user(cmd, buffer, count))
 341                 return -EFAULT;
 342         cmd[count] = '\0';
 343         len = strlen(cmd);      // above 3 lines ensure safety
 344         if (len && cmd[len - 1] == '\n')
 345                 cmd[--len] = '\0';
 346 #       ifdef CONFIG_CISS_SCSI_TAPE
 347         if (strcmp("engage scsi", cmd) == 0) {
 348                 rc = cciss_engage_scsi(h->ctlr);
 349                 if (rc != 0)
 350                         return -rc;
 351                 return count;
 352         }
 353         /* might be nice to have "disengage" too, but it's not
 354            safely possible. (only 1 module use count, lock issues.) */
 355 #       endif
 356         return -EINVAL;
 357 }
 358
 359 /*
 360  * Get us a file in /proc/cciss that says something about each controller.
 361  * Create /proc/cciss if it doesn't exist yet.
 362  */
 363 static void __devinit cciss_procinit(int i)
 364 {
 365         struct proc_dir_entry *pde;
 366
 367         if (proc_cciss == NULL) {
 368                 proc_cciss = proc_mkdir("cciss", proc_root_driver);
 369                 if (!proc_cciss)
 370                         return;
 371         }
 372
 373         pde = create_proc_read_entry(hba[i]->devname,
 374                                      S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
 375                                      proc_cciss, cciss_proc_get_info, hba[i]);
 376         pde->write_proc = cciss_proc_write;
 377 }
 378 #endif                          /* CONFIG_PROC_FS */
 379
 380 /*
 381  * For operations that cannot sleep, a command block is allocated at init,
 382  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
 383  * which ones are free or in use.  For operations that can wait for kmalloc
 384  * to possible sleep, this routine can be called with get_from_pool set to 0.
 385  * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
 386  */
 387 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
 388 {
 389         CommandList_struct *c;
 390         int i;
 391         u64bit temp64;
 392         dma_addr_t cmd_dma_handle, err_dma_handle;
 393
 394         if (!get_from_pool) {
 395                 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
 396                         sizeof(CommandList_struct), &cmd_dma_handle);
 397                 if (c == NULL)
 398                         return NULL;
 399                 memset(c, 0, sizeof(CommandList_struct));
 400
 401                 c->cmdindex = -1;
 402
 403                 c->err_info = (ErrorInfo_struct *)
 404                     pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
 405                             &err_dma_handle);
 406
 407                 if (c->err_info == NULL) {
 408                         pci_free_consistent(h->pdev,
 409                                 sizeof(CommandList_struct), c, cmd_dma_handle);
 410                         return NULL;
 411                 }
 412                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 413         } else {                /* get it out of the controllers pool */
 414
 415                 do {
 416                         i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
 417                         if (i == h->nr_cmds)
 418                                 return NULL;
 419                 } while (test_and_set_bit
 420                          (i & (BITS_PER_LONG - 1),
 421                           h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
 422 #ifdef CCISS_DEBUG
 423                 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
 424 #endif
 425                 c = h->cmd_pool + i;
 426                 memset(c, 0, sizeof(CommandList_struct));
 427                 cmd_dma_handle = h->cmd_pool_dhandle
 428                     + i * sizeof(CommandList_struct);
 429                 c->err_info = h->errinfo_pool + i;
 430                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 431                 err_dma_handle = h->errinfo_pool_dhandle
 432                     + i * sizeof(ErrorInfo_struct);
 433                 h->nr_allocs++;
 434
 435                 c->cmdindex = i;
 436         }
 437
 438         c->busaddr = (__u32) cmd_dma_handle;
 439         temp64.val = (__u64) err_dma_handle;
 440         c->ErrDesc.Addr.lower = temp64.val32.lower;
 441         c->ErrDesc.Addr.upper = temp64.val32.upper;
 442         c->ErrDesc.Len = sizeof(ErrorInfo_struct);
 443
 444         c->ctlr = h->ctlr;
 445         return c;
 446 }
 447
 448 /*
 449  * Frees a command block that was previously allocated with cmd_alloc().
 450  */
 451 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
 452 {
 453         int i;
 454         u64bit temp64;
 455
 456         if (!got_from_pool) {
 457                 temp64.val32.lower = c->ErrDesc.Addr.lower;
 458                 temp64.val32.upper = c->ErrDesc.Addr.upper;
 459                 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
 460                                     c->err_info, (dma_addr_t) temp64.val);
 461                 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
 462                                     c, (dma_addr_t) c->busaddr);
 463         } else {
 464                 i = c - h->cmd_pool;
 465                 clear_bit(i & (BITS_PER_LONG - 1),
 466                           h->cmd_pool_bits + (i / BITS_PER_LONG));
 467                 h->nr_frees++;
 468         }
 469 }
 470
 471 static inline ctlr_info_t *get_host(struct gendisk *disk)
 472 {
 473         return disk->queue->queuedata;
 474 }
 475
 476 static inline drive_info_struct *get_drv(struct gendisk *disk)
 477 {
 478         return disk->private_data;
 479 }
 480
 481 /*
 482  * Open.  Make sure the device is really there.
 483  */
 484 static int cciss_open(struct inode *inode, struct file *filep)
 485 {
 486         ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
 487         drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 488
 489 #ifdef CCISS_DEBUG
 490         printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
 491 #endif                          /* CCISS_DEBUG */
 492
 493         if (host->busy_initializing || drv->busy_configuring)
 494                 return -EBUSY;
 495         /*
 496          * Root is allowed to open raw volume zero even if it's not configured
 497          * so array config can still work. Root is also allowed to open any
 498          * volume that has a LUN ID, so it can issue IOCTL to reread the
 499          * disk information.  I don't think I really like this
 500          * but I'm already using way to many device nodes to claim another one
 501          * for "raw controller".
 502          */
 503         if (drv->heads == 0) {
 504                 if (iminor(inode) != 0) {       /* not node 0? */
 505                         /* if not node 0 make sure it is a partition = 0 */
 506                         if (iminor(inode) & 0x0f) {
 507                                 return -ENXIO;
 508                                 /* if it is, make sure we have a LUN ID */
 509                         } else if (drv->LunID == 0) {
 510                                 return -ENXIO;
 511                         }
 512                 }
 513                 if (!capable(CAP_SYS_ADMIN))
 514                         return -EPERM;
 515         }
 516         drv->usage_count++;
 517         host->usage_count++;
 518         return 0;
 519 }
 520
 521 /*
 522  * Close.  Sync first.
 523  */
 524 static int cciss_release(struct inode *inode, struct file *filep)
 525 {
 526         ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
 527         drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 528
 529 #ifdef CCISS_DEBUG
 530         printk(KERN_DEBUG "cciss_release %s\n",
 531                inode->i_bdev->bd_disk->disk_name);
 532 #endif                          /* CCISS_DEBUG */
 533
 534         drv->usage_count--;
 535         host->usage_count--;
 536         return 0;
 537 }
 538
 539 #ifdef CONFIG_COMPAT
 540
 541 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 542 {
 543         int ret;
 544         lock_kernel();
 545         ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
 546         unlock_kernel();
 547         return ret;
 548 }
 549
 550 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
 551                                   unsigned long arg);
 552 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
 553                                       unsigned long arg);
 554
 555 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 556 {
 557         switch (cmd) {
 558         case CCISS_GETPCIINFO:
 559         case CCISS_GETINTINFO:
 560         case CCISS_SETINTINFO:
 561         case CCISS_GETNODENAME:
 562         case CCISS_SETNODENAME:
 563         case CCISS_GETHEARTBEAT:
 564         case CCISS_GETBUSTYPES:
 565         case CCISS_GETFIRMVER:
 566         case CCISS_GETDRIVVER:
 567         case CCISS_REVALIDVOLS:
 568         case CCISS_DEREGDISK:
 569         case CCISS_REGNEWDISK:
 570         case CCISS_REGNEWD:
 571         case CCISS_RESCANDISK:
 572         case CCISS_GETLUNINFO:
 573                 return do_ioctl(f, cmd, arg);
 574
 575         case CCISS_PASSTHRU32:
 576                 return cciss_ioctl32_passthru(f, cmd, arg);
 577         case CCISS_BIG_PASSTHRU32:
 578                 return cciss_ioctl32_big_passthru(f, cmd, arg);
 579
 580         default:
 581                 return -ENOIOCTLCMD;
 582         }
 583 }
 584
 585 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
 586                                   unsigned long arg)
 587 {
 588         IOCTL32_Command_struct __user *arg32 =
 589             (IOCTL32_Command_struct __user *) arg;
 590         IOCTL_Command_struct arg64;
 591         IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
 592         int err;
 593         u32 cp;
 594
 595         err = 0;
 596         err |=
 597             copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
 598                            sizeof(arg64.LUN_info));
 599         err |=
 600             copy_from_user(&arg64.Request, &arg32->Request,
 601                            sizeof(arg64.Request));
 602         err |=
 603             copy_from_user(&arg64.error_info, &arg32->error_info,
 604                            sizeof(arg64.error_info));
 605         err |= get_user(arg64.buf_size, &arg32->buf_size);
 606         err |= get_user(cp, &arg32->buf);
 607         arg64.buf = compat_ptr(cp);
 608         err |= copy_to_user(p, &arg64, sizeof(arg64));
 609
 610         if (err)
 611                 return -EFAULT;
 612
 613         err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
 614         if (err)
 615                 return err;
 616         err |=
 617             copy_in_user(&arg32->error_info, &p->error_info,
 618                          sizeof(arg32->error_info));
 619         if (err)
 620                 return -EFAULT;
 621         return err;
 622 }
 623
 624 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
 625                                       unsigned long arg)
 626 {
 627         BIG_IOCTL32_Command_struct __user *arg32 =
 628             (BIG_IOCTL32_Command_struct __user *) arg;
 629         BIG_IOCTL_Command_struct arg64;
 630         BIG_IOCTL_Command_struct __user *p =
 631             compat_alloc_user_space(sizeof(arg64));
 632         int err;
 633         u32 cp;
 634
 635         err = 0;
 636         err |=
 637             copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
 638                            sizeof(arg64.LUN_info));
 639         err |=
 640             copy_from_user(&arg64.Request, &arg32->Request,
 641                            sizeof(arg64.Request));
 642         err |=
 643             copy_from_user(&arg64.error_info, &arg32->error_info,
 644                            sizeof(arg64.error_info));
 645         err |= get_user(arg64.buf_size, &arg32->buf_size);
 646         err |= get_user(arg64.malloc_size, &arg32->malloc_size);
 647         err |= get_user(cp, &arg32->buf);
 648         arg64.buf = compat_ptr(cp);
 649         err |= copy_to_user(p, &arg64, sizeof(arg64));
 650
 651         if (err)
 652                 return -EFAULT;
 653
 654         err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
 655         if (err)
 656                 return err;
 657         err |=
 658             copy_in_user(&arg32->error_info, &p->error_info,
 659                          sizeof(arg32->error_info));
 660         if (err)
 661                 return -EFAULT;
 662         return err;
 663 }
 664 #endif
 665
 666 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 667 {
 668         drive_info_struct *drv = get_drv(bdev->bd_disk);
 669
 670         if (!drv->cylinders)
 671                 return -ENXIO;
 672
 673         geo->heads = drv->heads;
 674         geo->sectors = drv->sectors;
 675         geo->cylinders = drv->cylinders;
 676         return 0;
 677 }
 678
 679 /*
 680  * ioctl
 681  */
 682 static int cciss_ioctl(struct inode *inode, struct file *filep,
 683                        unsigned int cmd, unsigned long arg)
 684 {
 685         struct block_device *bdev = inode->i_bdev;
 686         struct gendisk *disk = bdev->bd_disk;
 687         ctlr_info_t *host = get_host(disk);
 688         drive_info_struct *drv = get_drv(disk);
 689         int ctlr = host->ctlr;
 690         void __user *argp = (void __user *)arg;
 691
 692 #ifdef CCISS_DEBUG
 693         printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
 694 #endif                          /* CCISS_DEBUG */
 695
 696         switch (cmd) {
 697         case CCISS_GETPCIINFO:
 698                 {
 699                         cciss_pci_info_struct pciinfo;
 700
 701                         if (!arg)
 702                                 return -EINVAL;
 703                         pciinfo.domain = pci_domain_nr(host->pdev->bus);
 704                         pciinfo.bus = host->pdev->bus->number;
 705                         pciinfo.dev_fn = host->pdev->devfn;
 706                         pciinfo.board_id = host->board_id;
 707                         if (copy_to_user
 708                             (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
 709                                 return -EFAULT;
 710                         return 0;
 711                 }
 712         case CCISS_GETINTINFO:
 713                 {
 714                         cciss_coalint_struct intinfo;
 715                         if (!arg)
 716                                 return -EINVAL;
 717                         intinfo.delay =
 718                             readl(&host->cfgtable->HostWrite.CoalIntDelay);
 719                         intinfo.count =
 720                             readl(&host->cfgtable->HostWrite.CoalIntCount);
 721                         if (copy_to_user
 722                             (argp, &intinfo, sizeof(cciss_coalint_struct)))
 723                                 return -EFAULT;
 724                         return 0;
 725                 }
 726         case CCISS_SETINTINFO:
 727                 {
 728                         cciss_coalint_struct intinfo;
 729                         unsigned long flags;
 730                         int i;
 731
 732                         if (!arg)
 733                                 return -EINVAL;
 734                         if (!capable(CAP_SYS_ADMIN))
 735                                 return -EPERM;
 736                         if (copy_from_user
 737                             (&intinfo, argp, sizeof(cciss_coalint_struct)))
 738                                 return -EFAULT;
 739                         if ((intinfo.delay == 0) && (intinfo.count == 0))
 740                         {
 741 //                      printk("cciss_ioctl: delay and count cannot be 0\n");
 742                                 return -EINVAL;
 743                         }
 744                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 745                         /* Update the field, and then ring the doorbell */
 746                         writel(intinfo.delay,
 747                                &(host->cfgtable->HostWrite.CoalIntDelay));
 748                         writel(intinfo.count,
 749                                &(host->cfgtable->HostWrite.CoalIntCount));
 750                         writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
 751
 752                         for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
 753                                 if (!(readl(host->vaddr + SA5_DOORBELL)
 754                                       & CFGTBL_ChangeReq))
 755                                         break;
 756                                 /* delay and try again */
 757                                 udelay(1000);
 758                         }
 759                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 760                         if (i >= MAX_IOCTL_CONFIG_WAIT)
 761                                 return -EAGAIN;
 762                         return 0;
 763                 }
 764         case CCISS_GETNODENAME:
 765                 {
 766                         NodeName_type NodeName;
 767                         int i;
 768
 769                         if (!arg)
 770                                 return -EINVAL;
 771                         for (i = 0; i < 16; i++)
 772                                 NodeName[i] =
 773                                     readb(&host->cfgtable->ServerName[i]);
 774                         if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
 775                                 return -EFAULT;
 776                         return 0;
 777                 }
 778         case CCISS_SETNODENAME:
 779                 {
 780                         NodeName_type NodeName;
 781                         unsigned long flags;
 782                         int i;
 783
 784                         if (!arg)
 785                                 return -EINVAL;
 786                         if (!capable(CAP_SYS_ADMIN))
 787                                 return -EPERM;
 788
 789                         if (copy_from_user
 790                             (NodeName, argp, sizeof(NodeName_type)))
 791                                 return -EFAULT;
 792
 793                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 794
 795                         /* Update the field, and then ring the doorbell */
 796                         for (i = 0; i < 16; i++)
 797                                 writeb(NodeName[i],
 798                                        &host->cfgtable->ServerName[i]);
 799
 800                         writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
 801
 802                         for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
 803                                 if (!(readl(host->vaddr + SA5_DOORBELL)
 804                                       & CFGTBL_ChangeReq))
 805                                         break;
 806                                 /* delay and try again */
 807                                 udelay(1000);
 808                         }
 809                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 810                         if (i >= MAX_IOCTL_CONFIG_WAIT)
 811                                 return -EAGAIN;
 812                         return 0;
 813                 }
 814
 815         case CCISS_GETHEARTBEAT:
 816                 {
 817                         Heartbeat_type heartbeat;
 818
 819                         if (!arg)
 820                                 return -EINVAL;
 821                         heartbeat = readl(&host->cfgtable->HeartBeat);
 822                         if (copy_to_user
 823                             (argp, &heartbeat, sizeof(Heartbeat_type)))
 824                                 return -EFAULT;
 825                         return 0;
 826                 }
 827         case CCISS_GETBUSTYPES:
 828                 {
 829                         BusTypes_type BusTypes;
 830
 831                         if (!arg)
 832                                 return -EINVAL;
 833                         BusTypes = readl(&host->cfgtable->BusTypes);
 834                         if (copy_to_user
 835                             (argp, &BusTypes, sizeof(BusTypes_type)))
 836                                 return -EFAULT;
 837                         return 0;
 838                 }
 839         case CCISS_GETFIRMVER:
 840                 {
 841                         FirmwareVer_type firmware;
 842
 843                         if (!arg)
 844                                 return -EINVAL;
 845                         memcpy(firmware, host->firm_ver, 4);
 846
 847                         if (copy_to_user
 848                             (argp, firmware, sizeof(FirmwareVer_type)))
 849                                 return -EFAULT;
 850                         return 0;
 851                 }
 852         case CCISS_GETDRIVVER:
 853                 {
 854                         DriverVer_type DriverVer = DRIVER_VERSION;
 855
 856                         if (!arg)
 857                                 return -EINVAL;
 858
 859                         if (copy_to_user
 860                             (argp, &DriverVer, sizeof(DriverVer_type)))
 861                                 return -EFAULT;
 862                         return 0;
 863                 }
 864
 865         case CCISS_REVALIDVOLS:
 866                 return rebuild_lun_table(host, NULL);
 867
 868         case CCISS_GETLUNINFO:{
 869                         LogvolInfo_struct luninfo;
 870
 871                         luninfo.LunID = drv->LunID;
 872                         luninfo.num_opens = drv->usage_count;
 873                         luninfo.num_parts = 0;
 874                         if (copy_to_user(argp, &luninfo,
 875                                          sizeof(LogvolInfo_struct)))
 876                                 return -EFAULT;
 877                         return 0;
 878                 }
 879         case CCISS_DEREGDISK:
 880                 return rebuild_lun_table(host, disk);
 881
 882         case CCISS_REGNEWD:
 883                 return rebuild_lun_table(host, NULL);
 884
 885         case CCISS_PASSTHRU:
 886                 {
 887                         IOCTL_Command_struct iocommand;
 888                         CommandList_struct *c;
 889                         char *buff = NULL;
 890                         u64bit temp64;
 891                         unsigned long flags;
 892                         DECLARE_COMPLETION_ONSTACK(wait);
 893
 894                         if (!arg)
 895                                 return -EINVAL;
 896
 897                         if (!capable(CAP_SYS_RAWIO))
 898                                 return -EPERM;
 899
 900                         if (copy_from_user
 901                             (&iocommand, argp, sizeof(IOCTL_Command_struct)))
 902                                 return -EFAULT;
 903                         if ((iocommand.buf_size < 1) &&
 904                             (iocommand.Request.Type.Direction != XFER_NONE)) {
 905                                 return -EINVAL;
 906                         }
 907 #if 0                           /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
 908                         /* Check kmalloc limits */
 909                         if (iocommand.buf_size > 128000)
 910                                 return -EINVAL;
 911 #endif
 912                         if (iocommand.buf_size > 0) {
 913                                 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
 914                                 if (buff == NULL)
 915                                         return -EFAULT;
 916                         }
 917                         if (iocommand.Request.Type.Direction == XFER_WRITE) {
 918                                 /* Copy the data into the buffer we created */
 919                                 if (copy_from_user
 920                                     (buff, iocommand.buf, iocommand.buf_size)) {
 921                                         kfree(buff);
 922                                         return -EFAULT;
 923                                 }
 924                         } else {
 925                                 memset(buff, 0, iocommand.buf_size);
 926                         }
 927                         if ((c = cmd_alloc(host, 0)) == NULL) {
 928                                 kfree(buff);
 929                                 return -ENOMEM;
 930                         }
 931                         // Fill in the command type
 932                         c->cmd_type = CMD_IOCTL_PEND;
 933                         // Fill in Command Header
 934                         c->Header.ReplyQueue = 0;       // unused in simple mode
 935                         if (iocommand.buf_size > 0)     // buffer to fill
 936                         {
 937                                 c->Header.SGList = 1;
 938                                 c->Header.SGTotal = 1;
 939                         } else  // no buffers to fill
 940                         {
 941                                 c->Header.SGList = 0;
 942                                 c->Header.SGTotal = 0;
 943                         }
 944                         c->Header.LUN = iocommand.LUN_info;
 945                         c->Header.Tag.lower = c->busaddr;       // use the kernel address the cmd block for tag
 946
 947                         // Fill in Request block
 948                         c->Request = iocommand.Request;
 949
 950                         // Fill in the scatter gather information
 951                         if (iocommand.buf_size > 0) {
 952                                 temp64.val = pci_map_single(host->pdev, buff,
 953                                         iocommand.buf_size,
 954                                         PCI_DMA_BIDIRECTIONAL);
 955                                 c->SG[0].Addr.lower = temp64.val32.lower;
 956                                 c->SG[0].Addr.upper = temp64.val32.upper;
 957                                 c->SG[0].Len = iocommand.buf_size;
 958                                 c->SG[0].Ext = 0;       // we are not chaining
 959                         }
 960                         c->waiting = &wait;
 961
 962                         /* Put the request on the tail of the request queue */
 963                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 964                         addQ(&host->reqQ, c);
 965                         host->Qdepth++;
 966                         start_io(host);
 967                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 968
 969                         wait_for_completion(&wait);
 970
 971                         /* unlock the buffers from DMA */
 972                         temp64.val32.lower = c->SG[0].Addr.lower;
 973                         temp64.val32.upper = c->SG[0].Addr.upper;
 974                         pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
 975                                          iocommand.buf_size,
 976                                          PCI_DMA_BIDIRECTIONAL);
 977
 978                         /* Copy the error information out */
 979                         iocommand.error_info = *(c->err_info);
 980                         if (copy_to_user
 981                             (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
 982                                 kfree(buff);
 983                                 cmd_free(host, c, 0);
 984                                 return -EFAULT;
 985                         }
 986
 987                         if (iocommand.Request.Type.Direction == XFER_READ) {
 988                                 /* Copy the data out of the buffer we created */
 989                                 if (copy_to_user
 990                                     (iocommand.buf, buff, iocommand.buf_size)) {
 991                                         kfree(buff);
 992                                         cmd_free(host, c, 0);
 993                                         return -EFAULT;
 994                                 }
 995                         }
 996                         kfree(buff);
 997                         cmd_free(host, c, 0);
 998                         return 0;
 999                 }
1000         case CCISS_BIG_PASSTHRU:{
1001                         BIG_IOCTL_Command_struct *ioc;
1002                         CommandList_struct *c;
1003                         unsigned char **buff = NULL;
1004                         int *buff_size = NULL;
1005                         u64bit temp64;
1006                         unsigned long flags;
1007                         BYTE sg_used = 0;
1008                         int status = 0;
1009                         int i;
1010                         DECLARE_COMPLETION_ONSTACK(wait);
1011                         __u32 left;
1012                         __u32 sz;
1013                         BYTE __user *data_ptr;
1014
1015                         if (!arg)
1016                                 return -EINVAL;
1017                         if (!capable(CAP_SYS_RAWIO))
1018                                 return -EPERM;
1019                         ioc = (BIG_IOCTL_Command_struct *)
1020                             kmalloc(sizeof(*ioc), GFP_KERNEL);
1021                         if (!ioc) {
1022                                 status = -ENOMEM;
1023                                 goto cleanup1;
1024                         }
1025                         if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1026                                 status = -EFAULT;
1027                                 goto cleanup1;
1028                         }
1029                         if ((ioc->buf_size < 1) &&
1030                             (ioc->Request.Type.Direction != XFER_NONE)) {
1031                                 status = -EINVAL;
1032                                 goto cleanup1;
1033                         }
1034                         /* Check kmalloc limits  using all SGs */
1035                         if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1036                                 status = -EINVAL;
1037                                 goto cleanup1;
1038                         }
1039                         if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1040                                 status = -EINVAL;
1041                                 goto cleanup1;
1042                         }
1043                         buff =
1044                             kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1045                         if (!buff) {
1046                                 status = -ENOMEM;
1047                                 goto cleanup1;
1048                         }
1049                         buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
1050                                                    GFP_KERNEL);
1051                         if (!buff_size) {
1052                                 status = -ENOMEM;
1053                                 goto cleanup1;
1054                         }
1055                         left = ioc->buf_size;
1056                         data_ptr = ioc->buf;
1057                         while (left) {
1058                                 sz = (left >
1059                                       ioc->malloc_size) ? ioc->
1060                                     malloc_size : left;
1061                                 buff_size[sg_used] = sz;
1062                                 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1063                                 if (buff[sg_used] == NULL) {
1064                                         status = -ENOMEM;
1065                                         goto cleanup1;
1066                                 }
1067                                 if (ioc->Request.Type.Direction == XFER_WRITE) {
1068                                         if (copy_from_user
1069                                             (buff[sg_used], data_ptr, sz)) {
1070                                                 status = -ENOMEM;
1071                                                 goto cleanup1;
1072                                         }
1073                                 } else {
1074                                         memset(buff[sg_used], 0, sz);
1075                                 }
1076                                 left -= sz;
1077                                 data_ptr += sz;
1078                                 sg_used++;
1079                         }
1080                         if ((c = cmd_alloc(host, 0)) == NULL) {
1081                                 status = -ENOMEM;
1082                                 goto cleanup1;
1083                         }
1084                         c->cmd_type = CMD_IOCTL_PEND;
1085                         c->Header.ReplyQueue = 0;
1086
1087                         if (ioc->buf_size > 0) {
1088                                 c->Header.SGList = sg_used;
1089                                 c->Header.SGTotal = sg_used;
1090                         } else {
1091                                 c->Header.SGList = 0;
1092                                 c->Header.SGTotal = 0;
1093                         }
1094                         c->Header.LUN = ioc->LUN_info;
1095                         c->Header.Tag.lower = c->busaddr;
1096
1097                         c->Request = ioc->Request;
1098                         if (ioc->buf_size > 0) {
1099                                 int i;
1100                                 for (i = 0; i < sg_used; i++) {
1101                                         temp64.val =
1102                                             pci_map_single(host->pdev, buff[i],
1103                                                     buff_size[i],
1104                                                     PCI_DMA_BIDIRECTIONAL);
1105                                         c->SG[i].Addr.lower =
1106                                             temp64.val32.lower;
1107                                         c->SG[i].Addr.upper =
1108                                             temp64.val32.upper;
1109                                         c->SG[i].Len = buff_size[i];
1110                                         c->SG[i].Ext = 0;       /* we are not chaining */
1111                                 }
1112                         }
1113                         c->waiting = &wait;
1114                         /* Put the request on the tail of the request queue */
1115                         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1116                         addQ(&host->reqQ, c);
1117                         host->Qdepth++;
1118                         start_io(host);
1119                         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1120                         wait_for_completion(&wait);
1121                         /* unlock the buffers from DMA */
1122                         for (i = 0; i < sg_used; i++) {
1123                                 temp64.val32.lower = c->SG[i].Addr.lower;
1124                                 temp64.val32.upper = c->SG[i].Addr.upper;
1125                                 pci_unmap_single(host->pdev,
1126                                         (dma_addr_t) temp64.val, buff_size[i],
1127                                         PCI_DMA_BIDIRECTIONAL);
1128                         }
1129                         /* Copy the error information out */
1130                         ioc->error_info = *(c->err_info);
1131                         if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1132                                 cmd_free(host, c, 0);
1133                                 status = -EFAULT;
1134                                 goto cleanup1;
1135                         }
1136                         if (ioc->Request.Type.Direction == XFER_READ) {
1137                                 /* Copy the data out of the buffer we created */
1138                                 BYTE __user *ptr = ioc->buf;
1139                                 for (i = 0; i < sg_used; i++) {
1140                                         if (copy_to_user
1141                                             (ptr, buff[i], buff_size[i])) {
1142                                                 cmd_free(host, c, 0);
1143                                                 status = -EFAULT;
1144                                                 goto cleanup1;
1145                                         }
1146                                         ptr += buff_size[i];
1147                                 }
1148                         }
1149                         cmd_free(host, c, 0);
1150                         status = 0;
1151                       cleanup1:
1152                         if (buff) {
1153                                 for (i = 0; i < sg_used; i++)
1154                                         kfree(buff[i]);
1155                                 kfree(buff);
1156                         }
1157                         kfree(buff_size);
1158                         kfree(ioc);
1159                         return status;
1160                 }
1161
1162         /* scsi_cmd_ioctl handles these, below, though some are not */
1163         /* very meaningful for cciss.  SG_IO is the main one people want. */
1164
1165         case SG_GET_VERSION_NUM:
1166         case SG_SET_TIMEOUT:
1167         case SG_GET_TIMEOUT:
1168         case SG_GET_RESERVED_SIZE:
1169         case SG_SET_RESERVED_SIZE:
1170         case SG_EMULATED_HOST:
1171         case SG_IO:
1172         case SCSI_IOCTL_SEND_COMMAND:
1173                 return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp);
1174
1175         /* scsi_cmd_ioctl would normally handle these, below, but */
1176         /* they aren't a good fit for cciss, as CD-ROMs are */
1177         /* not supported, and we don't have any bus/target/lun */
1178         /* which we present to the kernel. */
1179
1180         case CDROM_SEND_PACKET:
1181         case CDROMCLOSETRAY:
1182         case CDROMEJECT:
1183         case SCSI_IOCTL_GET_IDLUN:
1184         case SCSI_IOCTL_GET_BUS_NUMBER:
1185         default:
1186                 return -ENOTTY;
1187         }
1188 }
1189
1190 static void cciss_check_queues(ctlr_info_t *h)
1191 {
1192         int start_queue = h->next_to_run;
1193         int i;
1194
1195         /* check to see if we have maxed out the number of commands that can
1196          * be placed on the queue.  If so then exit.  We do this check here
1197          * in case the interrupt we serviced was from an ioctl and did not
1198          * free any new commands.
1199          */
1200         if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
1201                 return;
1202
1203         /* We have room on the queue for more commands.  Now we need to queue
1204          * them up.  We will also keep track of the next queue to run so
1205          * that every queue gets a chance to be started first.
1206          */
1207         for (i = 0; i < h->highest_lun + 1; i++) {
1208                 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1209                 /* make sure the disk has been added and the drive is real
1210                  * because this can be called from the middle of init_one.
1211                  */
1212                 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1213                         continue;
1214                 blk_start_queue(h->gendisk[curr_queue]->queue);
1215
1216                 /* check to see if we have maxed out the number of commands
1217                  * that can be placed on the queue.
1218                  */
1219                 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
1220                         if (curr_queue == start_queue) {
1221                                 h->next_to_run =
1222                                     (start_queue + 1) % (h->highest_lun + 1);
1223                                 break;
1224                         } else {
1225                                 h->next_to_run = curr_queue;
1226                                 break;
1227                         }
1228                 } else {
1229                         curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
1230                 }
1231         }
1232 }
1233
1234 static void cciss_softirq_done(struct request *rq)
1235 {
1236         CommandList_struct *cmd = rq->completion_data;
1237         ctlr_info_t *h = hba[cmd->ctlr];
1238         unsigned long flags;
1239         u64bit temp64;
1240         int i, ddir;
1241
1242         if (cmd->Request.Type.Direction == XFER_READ)
1243                 ddir = PCI_DMA_FROMDEVICE;
1244         else
1245                 ddir = PCI_DMA_TODEVICE;
1246
1247         /* command did not need to be retried */
1248         /* unmap the DMA mapping for all the scatter gather elements */
1249         for (i = 0; i < cmd->Header.SGList; i++) {
1250                 temp64.val32.lower = cmd->SG[i].Addr.lower;
1251                 temp64.val32.upper = cmd->SG[i].Addr.upper;
1252                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1253         }
1254
1255 #ifdef CCISS_DEBUG
1256         printk("Done with %p\n", rq);
1257 #endif                          /* CCISS_DEBUG */
1258
1259         if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, blk_rq_bytes(rq)))
1260                 BUG();
1261
1262         spin_lock_irqsave(&h->lock, flags);
1263         cmd_free(h, cmd, 1);
1264         cciss_check_queues(h);
1265         spin_unlock_irqrestore(&h->lock, flags);
1266 }
1267
1268 /* This function will check the usage_count of the drive to be updated/added.
1269  * If the usage_count is zero then the drive information will be updated and
1270  * the disk will be re-registered with the kernel.  If not then it will be
1271  * left alone for the next reboot.  The exception to this is disk 0 which
1272  * will always be left registered with the kernel since it is also the
1273  * controller node.  Any changes to disk 0 will show up on the next
1274  * reboot.
1275  */
1276 static void cciss_update_drive_info(int ctlr, int drv_index)
1277 {
1278         ctlr_info_t *h = hba[ctlr];
1279         struct gendisk *disk;
1280         InquiryData_struct *inq_buff = NULL;
1281         unsigned int block_size;
1282         sector_t total_size;
1283         unsigned long flags = 0;
1284         int ret = 0;
1285
1286         /* if the disk already exists then deregister it before proceeding */
1287         if (h->drv[drv_index].raid_level != -1) {
1288                 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1289                 h->drv[drv_index].busy_configuring = 1;
1290                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1291                 ret = deregister_disk(h->gendisk[drv_index],
1292                                       &h->drv[drv_index], 0);
1293                 h->drv[drv_index].busy_configuring = 0;
1294         }
1295
1296         /* If the disk is in use return */
1297         if (ret)
1298                 return;
1299
1300         /* Get information about the disk and modify the driver structure */
1301         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1302         if (inq_buff == NULL)
1303                 goto mem_msg;
1304
1305         /* testing to see if 16-byte CDBs are already being used */
1306         if (h->cciss_read == CCISS_READ_16) {
1307                 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1308                         &total_size, &block_size);
1309                 goto geo_inq;
1310         }
1311
1312         cciss_read_capacity(ctlr, drv_index, 1,
1313                             &total_size, &block_size);
1314
1315         /* if read_capacity returns all F's this volume is >2TB in size */
1316         /* so we switch to 16-byte CDB's for all read/write ops */
1317         if (total_size == 0xFFFFFFFFULL) {
1318                 cciss_read_capacity_16(ctlr, drv_index, 1,
1319                 &total_size, &block_size);
1320                 h->cciss_read = CCISS_READ_16;
1321                 h->cciss_write = CCISS_WRITE_16;
1322         } else {
1323                 h->cciss_read = CCISS_READ_10;
1324                 h->cciss_write = CCISS_WRITE_10;
1325         }
1326 geo_inq:
1327         cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1328                                inq_buff, &h->drv[drv_index]);
1329
1330         ++h->num_luns;
1331         disk = h->gendisk[drv_index];
1332         set_capacity(disk, h->drv[drv_index].nr_blocks);
1333
1334         /* if it's the controller it's already added */
1335         if (drv_index) {
1336                 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1337                 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1338                 disk->major = h->major;
1339                 disk->first_minor = drv_index << NWD_SHIFT;
1340                 disk->fops = &cciss_fops;
1341                 disk->private_data = &h->drv[drv_index];
1342
1343                 /* Set up queue information */
1344                 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1345                 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1346
1347                 /* This is a hardware imposed limit. */
1348                 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1349
1350                 /* This is a limit in the driver and could be eliminated. */
1351                 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1352
1353                 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1354
1355                 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1356
1357                 disk->queue->queuedata = hba[ctlr];
1358
1359                 blk_queue_hardsect_size(disk->queue,
1360                                         hba[ctlr]->drv[drv_index].block_size);
1361
1362                 h->drv[drv_index].queue = disk->queue;
1363                 add_disk(disk);
1364         }
1365
1366       freeret:
1367         kfree(inq_buff);
1368         return;
1369       mem_msg:
1370         printk(KERN_ERR "cciss: out of memory\n");
1371         goto freeret;
1372 }
1373
1374 /* This function will find the first index of the controllers drive array
1375  * that has a -1 for the raid_level and will return that index.  This is
1376  * where new drives will be added.  If the index to be returned is greater
1377  * than the highest_lun index for the controller then highest_lun is set
1378  * to this new index.  If there are no available indexes then -1 is returned.
1379  */
1380 static int cciss_find_free_drive_index(int ctlr)
1381 {
1382         int i;
1383
1384         for (i = 0; i < CISS_MAX_LUN; i++) {
1385                 if (hba[ctlr]->drv[i].raid_level == -1) {
1386                         if (i > hba[ctlr]->highest_lun)
1387                                 hba[ctlr]->highest_lun = i;
1388                         return i;
1389                 }
1390         }
1391         return -1;
1392 }
1393
1394 /* This function will add and remove logical drives from the Logical
1395  * drive array of the controller and maintain persistency of ordering
1396  * so that mount points are preserved until the next reboot.  This allows
1397  * for the removal of logical drives in the middle of the drive array
1398  * without a re-ordering of those drives.
1399  * INPUT
1400  * h            = The controller to perform the operations on
1401  * del_disk     = The disk to remove if specified.  If the value given
1402  *                is NULL then no disk is removed.
1403  */
1404 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1405 {
1406         int ctlr = h->ctlr;
1407         int num_luns;
1408         ReportLunData_struct *ld_buff = NULL;
1409         drive_info_struct *drv = NULL;
1410         int return_code;
1411         int listlength = 0;
1412         int i;
1413         int drv_found;
1414         int drv_index = 0;
1415         __u32 lunid = 0;
1416         unsigned long flags;
1417
1418         /* Set busy_configuring flag for this operation */
1419         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1420         if (h->busy_configuring) {
1421                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1422                 return -EBUSY;
1423         }
1424         h->busy_configuring = 1;
1425
1426         /* if del_disk is NULL then we are being called to add a new disk
1427          * and update the logical drive table.  If it is not NULL then
1428          * we will check if the disk is in use or not.
1429          */
1430         if (del_disk != NULL) {
1431                 drv = get_drv(del_disk);
1432                 drv->busy_configuring = 1;
1433                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1434                 return_code = deregister_disk(del_disk, drv, 1);
1435                 drv->busy_configuring = 0;
1436                 h->busy_configuring = 0;
1437                 return return_code;
1438         } else {
1439                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1440                 if (!capable(CAP_SYS_RAWIO))
1441                         return -EPERM;
1442
1443                 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1444                 if (ld_buff == NULL)
1445                         goto mem_msg;
1446
1447                 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1448                                               sizeof(ReportLunData_struct), 0,
1449                                               0, 0, TYPE_CMD);
1450
1451                 if (return_code == IO_OK) {
1452                         listlength =
1453                                 be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
1454                 } else {        /* reading number of logical volumes failed */
1455                         printk(KERN_WARNING "cciss: report logical volume"
1456                                " command failed\n");
1457                         listlength = 0;
1458                         goto freeret;
1459                 }
1460
1461                 num_luns = listlength / 8;      /* 8 bytes per entry */
1462                 if (num_luns > CISS_MAX_LUN) {
1463                         num_luns = CISS_MAX_LUN;
1464                         printk(KERN_WARNING "cciss: more luns configured"
1465                                " on controller than can be handled by"
1466                                " this driver.\n");
1467                 }
1468
1469                 /* Compare controller drive array to drivers drive array.
1470                  * Check for updates in the drive information and any new drives
1471                  * on the controller.
1472                  */
1473                 for (i = 0; i < num_luns; i++) {
1474                         int j;
1475
1476                         drv_found = 0;
1477
1478                         lunid = (0xff &
1479                                  (unsigned int)(ld_buff->LUN[i][3])) << 24;
1480                         lunid |= (0xff &
1481                                   (unsigned int)(ld_buff->LUN[i][2])) << 16;
1482                         lunid |= (0xff &
1483                                   (unsigned int)(ld_buff->LUN[i][1])) << 8;
1484                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
1485
1486                         /* Find if the LUN is already in the drive array
1487                          * of the controller.  If so then update its info
1488                          * if not is use.  If it does not exist then find
1489                          * the first free index and add it.
1490                          */
1491                         for (j = 0; j <= h->highest_lun; j++) {
1492                                 if (h->drv[j].LunID == lunid) {
1493                                         drv_index = j;
1494                                         drv_found = 1;
1495                                 }
1496                         }
1497
1498                         /* check if the drive was found already in the array */
1499                         if (!drv_found) {
1500                                 drv_index = cciss_find_free_drive_index(ctlr);
1501                                 if (drv_index == -1)
1502                                         goto freeret;
1503
1504                                 /*Check if the gendisk needs to be allocated */
1505                                 if (!h->gendisk[drv_index]){
1506                                         h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
1507                                         if (!h->gendisk[drv_index]){
1508                                                 printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
1509                                                 goto mem_msg;
1510                                         }
1511                                 }
1512                         }
1513                         h->drv[drv_index].LunID = lunid;
1514                         cciss_update_drive_info(ctlr, drv_index);
1515                 }               /* end for */
1516         }                       /* end else */
1517
1518       freeret:
1519         kfree(ld_buff);
1520         h->busy_configuring = 0;
1521         /* We return -1 here to tell the ACU that we have registered/updated
1522          * all of the drives that we can and to keep it from calling us
1523          * additional times.
1524          */
1525         return -1;
1526       mem_msg:
1527         printk(KERN_ERR "cciss: out of memory\n");
1528         goto freeret;
1529 }
1530
1531 /* This function will deregister the disk and it's queue from the
1532  * kernel.  It must be called with the controller lock held and the
1533  * drv structures busy_configuring flag set.  It's parameters are:
1534  *
1535  * disk = This is the disk to be deregistered
1536  * drv  = This is the drive_info_struct associated with the disk to be
1537  *        deregistered.  It contains information about the disk used
1538  *        by the driver.
1539  * clear_all = This flag determines whether or not the disk information
1540  *             is going to be completely cleared out and the highest_lun
1541  *             reset.  Sometimes we want to clear out information about
1542  *             the disk in preparation for re-adding it.  In this case
1543  *             the highest_lun should be left unchanged and the LunID
1544  *             should not be cleared.
1545 */
1546 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1547                            int clear_all)
1548 {
1549         int i;
1550         ctlr_info_t *h = get_host(disk);
1551
1552         if (!capable(CAP_SYS_RAWIO))
1553                 return -EPERM;
1554
1555         /* make sure logical volume is NOT is use */
1556         if (clear_all || (h->gendisk[0] == disk)) {
1557                 if (drv->usage_count > 1)
1558                         return -EBUSY;
1559         } else if (drv->usage_count > 0)
1560                 return -EBUSY;
1561
1562         /* invalidate the devices and deregister the disk.  If it is disk
1563          * zero do not deregister it but just zero out it's values.  This
1564          * allows us to delete disk zero but keep the controller registered.
1565          */
1566         if (h->gendisk[0] != disk) {
1567                 struct request_queue *q = disk->queue;
1568                 if (disk->flags & GENHD_FL_UP)
1569                         del_gendisk(disk);
1570                 if (q) {
1571                         blk_cleanup_queue(q);
1572                         /* Set drv->queue to NULL so that we do not try
1573                          * to call blk_start_queue on this queue in the
1574                          * interrupt handler
1575                          */
1576                         drv->queue = NULL;
1577                 }
1578                 /* If clear_all is set then we are deleting the logical
1579                  * drive, not just refreshing its info.  For drives
1580                  * other than disk 0 we will call put_disk.  We do not
1581                  * do this for disk 0 as we need it to be able to
1582                  * configure the controller.
1583                 */
1584                 if (clear_all){
1585                         /* This isn't pretty, but we need to find the
1586                          * disk in our array and NULL our the pointer.
1587                          * This is so that we will call alloc_disk if
1588                          * this index is used again later.
1589                         */
1590                         for (i=0; i < CISS_MAX_LUN; i++){
1591                                 if(h->gendisk[i] == disk){
1592                                         h->gendisk[i] = NULL;
1593                                         break;
1594                                 }
1595                         }
1596                         put_disk(disk);
1597                 }
1598         } else {
1599                 set_capacity(disk, 0);
1600         }
1601
1602         --h->num_luns;
1603         /* zero out the disk size info */
1604         drv->nr_blocks = 0;
1605         drv->block_size = 0;
1606         drv->heads = 0;
1607         drv->sectors = 0;
1608         drv->cylinders = 0;
1609         drv->raid_level = -1;   /* This can be used as a flag variable to
1610                                  * indicate that this element of the drive
1611                                  * array is free.
1612                                  */
1613
1614         if (clear_all) {
1615                 /* check to see if it was the last disk */
1616                 if (drv == h->drv + h->highest_lun) {
1617                         /* if so, find the new hightest lun */
1618                         int i, newhighest = -1;
1619                         for (i = 0; i < h->highest_lun; i++) {
1620                                 /* if the disk has size > 0, it is available */
1621                                 if (h->drv[i].heads)
1622                                         newhighest = i;
1623                         }
1624                         h->highest_lun = newhighest;
1625                 }
1626
1627                 drv->LunID = 0;
1628         }
1629         return 0;
1630 }
1631
1632 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
1633                                                                                                                            1: address logical volume log_unit,
1634                                                                                                                            2: periph device address is scsi3addr */
1635                     unsigned int log_unit, __u8 page_code,
1636                     unsigned char *scsi3addr, int cmd_type)
1637 {
1638         ctlr_info_t *h = hba[ctlr];
1639         u64bit buff_dma_handle;
1640         int status = IO_OK;
1641
1642         c->cmd_type = CMD_IOCTL_PEND;
1643         c->Header.ReplyQueue = 0;
1644         if (buff != NULL) {
1645                 c->Header.SGList = 1;
1646                 c->Header.SGTotal = 1;
1647         } else {
1648                 c->Header.SGList = 0;
1649                 c->Header.SGTotal = 0;
1650         }
1651         c->Header.Tag.lower = c->busaddr;
1652
1653         c->Request.Type.Type = cmd_type;
1654         if (cmd_type == TYPE_CMD) {
1655                 switch (cmd) {
1656                 case CISS_INQUIRY:
1657                         /* If the logical unit number is 0 then, this is going
1658                            to controller so It's a physical command
1659                            mode = 0 target = 0.  So we have nothing to write.
1660                            otherwise, if use_unit_num == 1,
1661                            mode = 1(volume set addressing) target = LUNID
1662                            otherwise, if use_unit_num == 2,
1663                            mode = 0(periph dev addr) target = scsi3addr */
1664                         if (use_unit_num == 1) {
1665                                 c->Header.LUN.LogDev.VolId =
1666                                     h->drv[log_unit].LunID;
1667                                 c->Header.LUN.LogDev.Mode = 1;
1668                         } else if (use_unit_num == 2) {
1669                                 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1670                                        8);
1671                                 c->Header.LUN.LogDev.Mode = 0;
1672                         }
1673                         /* are we trying to read a vital product page */
1674                         if (page_code != 0) {
1675                                 c->Request.CDB[1] = 0x01;
1676                                 c->Request.CDB[2] = page_code;
1677                         }
1678                         c->Request.CDBLen = 6;
1679                         c->Request.Type.Attribute = ATTR_SIMPLE;
1680                         c->Request.Type.Direction = XFER_READ;
1681                         c->Request.Timeout = 0;
1682                         c->Request.CDB[0] = CISS_INQUIRY;
1683                         c->Request.CDB[4] = size & 0xFF;
1684                         break;
1685                 case CISS_REPORT_LOG:
1686                 case CISS_REPORT_PHYS:
1687                         /* Talking to controller so It's a physical command
1688                            mode = 00 target = 0.  Nothing to write.
1689                          */
1690                         c->Request.CDBLen = 12;
1691                         c->Request.Type.Attribute = ATTR_SIMPLE;
1692                         c->Request.Type.Direction = XFER_READ;
1693                         c->Request.Timeout = 0;
1694                         c->Request.CDB[0] = cmd;
1695                         c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
1696                         c->Request.CDB[7] = (size >> 16) & 0xFF;
1697                         c->Request.CDB[8] = (size >> 8) & 0xFF;
1698                         c->Request.CDB[9] = size & 0xFF;
1699                         break;
1700
1701                 case CCISS_READ_CAPACITY:
1702                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1703                         c->Header.LUN.LogDev.Mode = 1;
1704                         c->Request.CDBLen = 10;
1705                         c->Request.Type.Attribute = ATTR_SIMPLE;
1706                         c->Request.Type.Direction = XFER_READ;
1707                         c->Request.Timeout = 0;
1708                         c->Request.CDB[0] = cmd;
1709                         break;
1710                 case CCISS_READ_CAPACITY_16:
1711                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1712                         c->Header.LUN.LogDev.Mode = 1;
1713                         c->Request.CDBLen = 16;
1714                         c->Request.Type.Attribute = ATTR_SIMPLE;
1715                         c->Request.Type.Direction = XFER_READ;
1716                         c->Request.Timeout = 0;
1717                         c->Request.CDB[0] = cmd;
1718                         c->Request.CDB[1] = 0x10;
1719                         c->Request.CDB[10] = (size >> 24) & 0xFF;
1720                         c->Request.CDB[11] = (size >> 16) & 0xFF;
1721                         c->Request.CDB[12] = (size >> 8) & 0xFF;
1722                         c->Request.CDB[13] = size & 0xFF;
1723                         c->Request.Timeout = 0;
1724                         c->Request.CDB[0] = cmd;
1725                         break;
1726                 case CCISS_CACHE_FLUSH:
1727                         c->Request.CDBLen = 12;
1728                         c->Request.Type.Attribute = ATTR_SIMPLE;
1729                         c->Request.Type.Direction = XFER_WRITE;
1730                         c->Request.Timeout = 0;
1731                         c->Request.CDB[0] = BMIC_WRITE;
1732                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1733                         break;
1734                 default:
1735                         printk(KERN_WARNING
1736                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
1737                         return IO_ERROR;
1738                 }
1739         } else if (cmd_type == TYPE_MSG) {
1740                 switch (cmd) {
1741                 case 0: /* ABORT message */
1742                         c->Request.CDBLen = 12;
1743                         c->Request.Type.Attribute = ATTR_SIMPLE;
1744                         c->Request.Type.Direction = XFER_WRITE;
1745                         c->Request.Timeout = 0;
1746                         c->Request.CDB[0] = cmd;        /* abort */
1747                         c->Request.CDB[1] = 0;  /* abort a command */
1748                         /* buff contains the tag of the command to abort */
1749                         memcpy(&c->Request.CDB[4], buff, 8);
1750                         break;
1751                 case 1: /* RESET message */
1752                         c->Request.CDBLen = 12;
1753                         c->Request.Type.Attribute = ATTR_SIMPLE;
1754                         c->Request.Type.Direction = XFER_WRITE;
1755                         c->Request.Timeout = 0;
1756                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1757                         c->Request.CDB[0] = cmd;        /* reset */
1758                         c->Request.CDB[1] = 0x04;       /* reset a LUN */
1759                         break;
1760                 case 3: /* No-Op message */
1761                         c->Request.CDBLen = 1;
1762                         c->Request.Type.Attribute = ATTR_SIMPLE;
1763                         c->Request.Type.Direction = XFER_WRITE;
1764                         c->Request.Timeout = 0;
1765                         c->Request.CDB[0] = cmd;
1766                         break;
1767                 default:
1768                         printk(KERN_WARNING
1769                                "cciss%d: unknown message type %d\n", ctlr, cmd);
1770                         return IO_ERROR;
1771                 }
1772         } else {
1773                 printk(KERN_WARNING
1774                        "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1775                 return IO_ERROR;
1776         }
1777         /* Fill in the scatter gather information */
1778         if (size > 0) {
1779                 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1780                                                              buff, size,
1781                                                              PCI_DMA_BIDIRECTIONAL);
1782                 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1783                 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1784                 c->SG[0].Len = size;
1785                 c->SG[0].Ext = 0;       /* we are not chaining */
1786         }
1787         return status;
1788 }
1789
1790 static int sendcmd_withirq(__u8 cmd,
1791                            int ctlr,
1792                            void *buff,
1793                            size_t size,
1794                            unsigned int use_unit_num,
1795                            unsigned int log_unit, __u8 page_code, int cmd_type)
1796 {
1797         ctlr_info_t *h = hba[ctlr];
1798         CommandList_struct *c;
1799         u64bit buff_dma_handle;
1800         unsigned long flags;
1801         int return_status;
1802         DECLARE_COMPLETION_ONSTACK(wait);
1803
1804         if ((c = cmd_alloc(h, 0)) == NULL)
1805                 return -ENOMEM;
1806         return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1807                                  log_unit, page_code, NULL, cmd_type);
1808         if (return_status != IO_OK) {
1809                 cmd_free(h, c, 0);
1810                 return return_status;
1811         }
1812       resend_cmd2:
1813         c->waiting = &wait;
1814
1815         /* Put the request on the tail of the queue and send it */
1816         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1817         addQ(&h->reqQ, c);
1818         h->Qdepth++;
1819         start_io(h);
1820         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1821
1822         wait_for_completion(&wait);
1823
1824         if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
1825                 switch (c->err_info->CommandStatus) {
1826                 case CMD_TARGET_STATUS:
1827                         printk(KERN_WARNING "cciss: cmd %p has "
1828                                " completed with errors\n", c);
1829                         if (c->err_info->ScsiStatus) {
1830                                 printk(KERN_WARNING "cciss: cmd %p "
1831                                        "has SCSI Status = %x\n",
1832                                        c, c->err_info->ScsiStatus);
1833                         }
1834
1835                         break;
1836                 case CMD_DATA_UNDERRUN:
1837                 case CMD_DATA_OVERRUN:
1838                         /* expected for inquire and report lun commands */
1839                         break;
1840                 case CMD_INVALID:
1841                         printk(KERN_WARNING "cciss: Cmd %p is "
1842                                "reported invalid\n", c);
1843                         return_status = IO_ERROR;
1844                         break;
1845                 case CMD_PROTOCOL_ERR:
1846                         printk(KERN_WARNING "cciss: cmd %p has "
1847                                "protocol error \n", c);
1848                         return_status = IO_ERROR;
1849                         break;
1850                 case CMD_HARDWARE_ERR:
1851                         printk(KERN_WARNING "cciss: cmd %p had "
1852                                " hardware error\n", c);
1853                         return_status = IO_ERROR;
1854                         break;
1855                 case CMD_CONNECTION_LOST:
1856                         printk(KERN_WARNING "cciss: cmd %p had "
1857                                "connection lost\n", c);
1858                         return_status = IO_ERROR;
1859                         break;
1860                 case CMD_ABORTED:
1861                         printk(KERN_WARNING "cciss: cmd %p was "
1862                                "aborted\n", c);
1863                         return_status = IO_ERROR;
1864                         break;
1865                 case CMD_ABORT_FAILED:
1866                         printk(KERN_WARNING "cciss: cmd %p reports "
1867                                "abort failed\n", c);
1868                         return_status = IO_ERROR;
1869                         break;
1870                 case CMD_UNSOLICITED_ABORT:
1871                         printk(KERN_WARNING
1872                                "cciss%d: unsolicited abort %p\n", ctlr, c);
1873                         if (c->retry_count < MAX_CMD_RETRIES) {
1874                                 printk(KERN_WARNING
1875                                        "cciss%d: retrying %p\n", ctlr, c);
1876                                 c->retry_count++;
1877                                 /* erase the old error information */
1878                                 memset(c->err_info, 0,
1879                                        sizeof(ErrorInfo_struct));
1880                                 return_status = IO_OK;
1881                                 INIT_COMPLETION(wait);
1882                                 goto resend_cmd2;
1883                         }
1884                         return_status = IO_ERROR;
1885                         break;
1886                 default:
1887                         printk(KERN_WARNING "cciss: cmd %p returned "
1888                                "unknown status %x\n", c,
1889                                c->err_info->CommandStatus);
1890                         return_status = IO_ERROR;
1891                 }
1892         }
1893         /* unlock the buffers from DMA */
1894         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1895         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1896         pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1897                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1898         cmd_free(h, c, 0);
1899         return return_status;
1900 }
1901
1902 static void cciss_geometry_inquiry(int ctlr, int logvol,
1903                                    int withirq, sector_t total_size,
1904                                    unsigned int block_size,
1905                                    InquiryData_struct *inq_buff,
1906                                    drive_info_struct *drv)
1907 {
1908         int return_code;
1909         unsigned long t;
1910
1911         memset(inq_buff, 0, sizeof(InquiryData_struct));
1912         if (withirq)
1913                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1914                                               inq_buff, sizeof(*inq_buff), 1,
1915                                               logvol, 0xC1, TYPE_CMD);
1916         else
1917                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1918                                       sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1919                                       TYPE_CMD);
1920         if (return_code == IO_OK) {
1921                 if (inq_buff->data_byte[8] == 0xFF) {
1922                         printk(KERN_WARNING
1923                                "cciss: reading geometry failed, volume "
1924                                "does not support reading geometry\n");
1925                         drv->heads = 255;
1926                         drv->sectors = 32;      // Sectors per track
1927                         drv->cylinders = total_size + 1;
1928                         drv->raid_level = RAID_UNKNOWN;
1929                 } else {
1930                         drv->heads = inq_buff->data_byte[6];
1931                         drv->sectors = inq_buff->data_byte[7];
1932                         drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1933                         drv->cylinders += inq_buff->data_byte[5];
1934                         drv->raid_level = inq_buff->data_byte[8];
1935                 }
1936                 drv->block_size = block_size;
1937                 drv->nr_blocks = total_size + 1;
1938                 t = drv->heads * drv->sectors;
1939                 if (t > 1) {
1940                         sector_t real_size = total_size + 1;
1941                         unsigned long rem = sector_div(real_size, t);
1942                         if (rem)
1943                                 real_size++;
1944                         drv->cylinders = real_size;
1945                 }
1946         } else {                /* Get geometry failed */
1947                 printk(KERN_WARNING "cciss: reading geometry failed\n");
1948         }
1949         printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
1950                drv->heads, drv->sectors, drv->cylinders);
1951 }
1952
1953 static void
1954 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
1955                     unsigned int *block_size)
1956 {
1957         ReadCapdata_struct *buf;
1958         int return_code;
1959
1960         buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
1961         if (!buf) {
1962                 printk(KERN_WARNING "cciss: out of memory\n");
1963                 return;
1964         }
1965
1966         if (withirq)
1967                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1968                                 ctlr, buf, sizeof(ReadCapdata_struct),
1969                                         1, logvol, 0, TYPE_CMD);
1970         else
1971                 return_code = sendcmd(CCISS_READ_CAPACITY,
1972                                 ctlr, buf, sizeof(ReadCapdata_struct),
1973                                         1, logvol, 0, NULL, TYPE_CMD);
1974         if (return_code == IO_OK) {
1975                 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
1976                 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
1977         } else {                /* read capacity command failed */
1978                 printk(KERN_WARNING "cciss: read capacity failed\n");
1979                 *total_size = 0;
1980                 *block_size = BLOCK_SIZE;
1981         }
1982         if (*total_size != 0)
1983                 printk(KERN_INFO "      blocks= %llu block_size= %d\n",
1984                 (unsigned long long)*total_size+1, *block_size);
1985         kfree(buf);
1986 }
1987
1988 static void
1989 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,                                 unsigned int *block_size)
1990 {
1991         ReadCapdata_struct_16 *buf;
1992         int return_code;
1993
1994         buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
1995         if (!buf) {
1996                 printk(KERN_WARNING "cciss: out of memory\n");
1997                 return;
1998         }
1999
2000         if (withirq) {
2001                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2002                         ctlr, buf, sizeof(ReadCapdata_struct_16),
2003                                 1, logvol, 0, TYPE_CMD);
2004         }
2005         else {
2006                 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2007                         ctlr, buf, sizeof(ReadCapdata_struct_16),
2008                                 1, logvol, 0, NULL, TYPE_CMD);
2009         }
2010         if (return_code == IO_OK) {
2011                 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2012                 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2013         } else {                /* read capacity command failed */
2014                 printk(KERN_WARNING "cciss: read capacity failed\n");
2015                 *total_size = 0;
2016                 *block_size = BLOCK_SIZE;
2017         }
2018         printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2019                (unsigned long long)*total_size+1, *block_size);
2020         kfree(buf);
2021 }
2022
2023 static int cciss_revalidate(struct gendisk *disk)
2024 {
2025         ctlr_info_t *h = get_host(disk);
2026         drive_info_struct *drv = get_drv(disk);
2027         int logvol;
2028         int FOUND = 0;
2029         unsigned int block_size;
2030         sector_t total_size;
2031         InquiryData_struct *inq_buff = NULL;
2032
2033         for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2034                 if (h->drv[logvol].LunID == drv->LunID) {
2035                         FOUND = 1;
2036                         break;
2037                 }
2038         }
2039
2040         if (!FOUND)
2041                 return 1;
2042
2043         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2044         if (inq_buff == NULL) {
2045                 printk(KERN_WARNING "cciss: out of memory\n");
2046                 return 1;
2047         }
2048         if (h->cciss_read == CCISS_READ_10) {
2049                 cciss_read_capacity(h->ctlr, logvol, 1,
2050                                         &total_size, &block_size);
2051         } else {
2052                 cciss_read_capacity_16(h->ctlr, logvol, 1,
2053                                         &total_size, &block_size);
2054         }
2055         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2056                                inq_buff, drv);
2057
2058         blk_queue_hardsect_size(drv->queue, drv->block_size);
2059         set_capacity(disk, drv->nr_blocks);
2060
2061         kfree(inq_buff);
2062         return 0;
2063 }
2064
2065 /*
2066  *   Wait polling for a command to complete.
2067  *   The memory mapped FIFO is polled for the completion.
2068  *   Used only at init time, interrupts from the HBA are disabled.
2069  */
2070 static unsigned long pollcomplete(int ctlr)
2071 {
2072         unsigned long done;
2073         int i;
2074
2075         /* Wait (up to 20 seconds) for a command to complete */
2076
2077         for (i = 20 * HZ; i > 0; i--) {
2078                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2079                 if (done == FIFO_EMPTY)
2080                         schedule_timeout_uninterruptible(1);
2081                 else
2082                         return done;
2083         }
2084         /* Invalid address to tell caller we ran out of time */
2085         return 1;
2086 }
2087
2088 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2089 {
2090         /* We get in here if sendcmd() is polling for completions
2091            and gets some command back that it wasn't expecting --
2092            something other than that which it just sent down.
2093            Ordinarily, that shouldn't happen, but it can happen when
2094            the scsi tape stuff gets into error handling mode, and
2095            starts using sendcmd() to try to abort commands and
2096            reset tape drives.  In that case, sendcmd may pick up
2097            completions of commands that were sent to logical drives
2098            through the block i/o system, or cciss ioctls completing, etc.
2099            In that case, we need to save those completions for later
2100            processing by the interrupt handler.
2101          */
2102
2103 #ifdef CONFIG_CISS_SCSI_TAPE
2104         struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2105
2106         /* If it's not the scsi tape stuff doing error handling, (abort */
2107         /* or reset) then we don't expect anything weird. */
2108         if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2109 #endif
2110                 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2111                        "Invalid command list address returned! (%lx)\n",
2112                        ctlr, complete);
2113                 /* not much we can do. */
2114 #ifdef CONFIG_CISS_SCSI_TAPE
2115                 return 1;
2116         }
2117
2118         /* We've sent down an abort or reset, but something else
2119            has completed */
2120         if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2121                 /* Uh oh.  No room to save it for later... */
2122                 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2123                        "reject list overflow, command lost!\n", ctlr);
2124                 return 1;
2125         }
2126         /* Save it for later */
2127         srl->complete[srl->ncompletions] = complete;
2128         srl->ncompletions++;
2129 #endif
2130         return 0;
2131 }
2132
2133 /*
2134  * Send a command to the controller, and wait for it to complete.
2135  * Only used at init time.
2136  */
2137 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
2138                                                                                                    1: address logical volume log_unit,
2139                                                                                                    2: periph device address is scsi3addr */
2140                    unsigned int log_unit,
2141                    __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2142 {
2143         CommandList_struct *c;
2144         int i;
2145         unsigned long complete;
2146         ctlr_info_t *info_p = hba[ctlr];
2147         u64bit buff_dma_handle;
2148         int status, done = 0;
2149
2150         if ((c = cmd_alloc(info_p, 1)) == NULL) {
2151                 printk(KERN_WARNING "cciss: unable to get memory");
2152                 return IO_ERROR;
2153         }
2154         status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2155                           log_unit, page_code, scsi3addr, cmd_type);
2156         if (status != IO_OK) {
2157                 cmd_free(info_p, c, 1);
2158                 return status;
2159         }
2160       resend_cmd1:
2161         /*
2162          * Disable interrupt
2163          */
2164 #ifdef CCISS_DEBUG
2165         printk(KERN_DEBUG "cciss: turning intr off\n");
2166 #endif                          /* CCISS_DEBUG */
2167         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2168
2169         /* Make sure there is room in the command FIFO */
2170         /* Actually it should be completely empty at this time */
2171         /* unless we are in here doing error handling for the scsi */
2172         /* tape side of the driver. */
2173         for (i = 200000; i > 0; i--) {
2174                 /* if fifo isn't full go */
2175                 if (!(info_p->access.fifo_full(info_p))) {
2176
2177                         break;
2178                 }
2179                 udelay(10);
2180                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2181                        " waiting!\n", ctlr);
2182         }
2183         /*
2184          * Send the cmd
2185          */
2186         info_p->access.submit_command(info_p, c);
2187         done = 0;
2188         do {
2189                 complete = pollcomplete(ctlr);
2190
2191 #ifdef CCISS_DEBUG
2192                 printk(KERN_DEBUG "cciss: command completed\n");
2193 #endif                          /* CCISS_DEBUG */
2194
2195                 if (complete == 1) {
2196                         printk(KERN_WARNING
2197                                "cciss cciss%d: SendCmd Timeout out, "
2198                                "No command list address returned!\n", ctlr);
2199                         status = IO_ERROR;
2200                         done = 1;
2201                         break;
2202                 }
2203
2204                 /* This will need to change for direct lookup completions */
2205                 if ((complete & CISS_ERROR_BIT)
2206                     && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2207                         /* if data overrun or underun on Report command
2208                            ignore it
2209                          */
2210                         if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2211                              (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2212                              (c->Request.CDB[0] == CISS_INQUIRY)) &&
2213                             ((c->err_info->CommandStatus ==
2214                               CMD_DATA_OVERRUN) ||
2215                              (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2216                             )) {
2217                                 complete = c->busaddr;
2218                         } else {
2219                                 if (c->err_info->CommandStatus ==
2220                                     CMD_UNSOLICITED_ABORT) {
2221                                         printk(KERN_WARNING "cciss%d: "
2222                                                "unsolicited abort %p\n",
2223                                                ctlr, c);
2224                                         if (c->retry_count < MAX_CMD_RETRIES) {
2225                                                 printk(KERN_WARNING
2226                                                        "cciss%d: retrying %p\n",
2227                                                        ctlr, c);
2228                                                 c->retry_count++;
2229                                                 /* erase the old error */
2230                                                 /* information */
2231                                                 memset(c->err_info, 0,
2232                                                        sizeof
2233                                                        (ErrorInfo_struct));
2234                                                 goto resend_cmd1;
2235                                         } else {
2236                                                 printk(KERN_WARNING
2237                                                        "cciss%d: retried %p too "
2238                                                        "many times\n", ctlr, c);
2239                                                 status = IO_ERROR;
2240                                                 goto cleanup1;
2241                                         }
2242                                 } else if (c->err_info->CommandStatus ==
2243                                            CMD_UNABORTABLE) {
2244                                         printk(KERN_WARNING
2245                                                "cciss%d: command could not be aborted.\n",
2246                                                ctlr);
2247                                         status = IO_ERROR;
2248                                         goto cleanup1;
2249                                 }
2250                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2251                                        " Error %x \n", ctlr,
2252                                        c->err_info->CommandStatus);
2253                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2254                                        " offensive info\n"
2255                                        "  size %x\n   num %x   value %x\n",
2256                                        ctlr,
2257                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2258                                        offense_size,
2259                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2260                                        offense_num,
2261                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2262                                        offense_value);
2263                                 status = IO_ERROR;
2264                                 goto cleanup1;
2265                         }
2266                 }
2267                 /* This will need changing for direct lookup completions */
2268                 if (complete != c->busaddr) {
2269                         if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2270                                 BUG();  /* we are pretty much hosed if we get here. */
2271                         }
2272                         continue;
2273                 } else
2274                         done = 1;
2275         } while (!done);
2276
2277       cleanup1:
2278         /* unlock the data buffer from DMA */
2279         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2280         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2281         pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2282                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2283 #ifdef CONFIG_CISS_SCSI_TAPE
2284         /* if we saved some commands for later, process them now. */
2285         if (info_p->scsi_rejects.ncompletions > 0)
2286                 do_cciss_intr(0, info_p);
2287 #endif
2288         cmd_free(info_p, c, 1);
2289         return status;
2290 }
2291
2292 /*
2293  * Map (physical) PCI mem into (virtual) kernel space
2294  */
2295 static void __iomem *remap_pci_mem(ulong base, ulong size)
2296 {
2297         ulong page_base = ((ulong) base) & PAGE_MASK;
2298         ulong page_offs = ((ulong) base) - page_base;
2299         void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2300
2301         return page_remapped ? (page_remapped + page_offs) : NULL;
2302 }
2303
2304 /*
2305  * Takes jobs of the Q and sends them to the hardware, then puts it on
2306  * the Q to wait for completion.
2307  */
2308 static void start_io(ctlr_info_t *h)
2309 {
2310         CommandList_struct *c;
2311
2312         while ((c = h->reqQ) != NULL) {
2313                 /* can't do anything if fifo is full */
2314                 if ((h->access.fifo_full(h))) {
2315                         printk(KERN_WARNING "cciss: fifo full\n");
2316                         break;
2317                 }
2318
2319                 /* Get the first entry from the Request Q */
2320                 removeQ(&(h->reqQ), c);
2321                 h->Qdepth--;
2322
2323                 /* Tell the controller execute command */
2324                 h->access.submit_command(h, c);
2325
2326                 /* Put job onto the completed Q */
2327                 addQ(&(h->cmpQ), c);
2328         }
2329 }
2330
2331 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2332 /* Zeros out the error record and then resends the command back */
2333 /* to the controller */
2334 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2335 {
2336         /* erase the old error information */
2337         memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2338
2339         /* add it to software queue and then send it to the controller */
2340         addQ(&(h->reqQ), c);
2341         h->Qdepth++;
2342         if (h->Qdepth > h->maxQsinceinit)
2343                 h->maxQsinceinit = h->Qdepth;
2344
2345         start_io(h);
2346 }
2347
2348 static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
2349         unsigned int msg_byte, unsigned int host_byte,
2350         unsigned int driver_byte)
2351 {
2352         /* inverse of macros in scsi.h */
2353         return (scsi_status_byte & 0xff) |
2354                 ((msg_byte & 0xff) << 8) |
2355                 ((host_byte & 0xff) << 16) |
2356                 ((driver_byte & 0xff) << 24);
2357 }
2358
2359 static inline int evaluate_target_status(CommandList_struct *cmd)
2360 {
2361         unsigned char sense_key;
2362         unsigned char status_byte, msg_byte, host_byte, driver_byte;
2363         int error_value;
2364
2365         /* If we get in here, it means we got "target status", that is, scsi status */
2366         status_byte = cmd->err_info->ScsiStatus;
2367         driver_byte = DRIVER_OK;
2368         msg_byte = cmd->err_info->CommandStatus; /* correct?  seems too device specific */
2369
2370         if (blk_pc_request(cmd->rq))
2371                 host_byte = DID_PASSTHROUGH;
2372         else
2373                 host_byte = DID_OK;
2374
2375         error_value = make_status_bytes(status_byte, msg_byte,
2376                 host_byte, driver_byte);
2377
2378         if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
2379                 if (!blk_pc_request(cmd->rq))
2380                         printk(KERN_WARNING "cciss: cmd %p "
2381                                "has SCSI Status 0x%x\n",
2382                                cmd, cmd->err_info->ScsiStatus);
2383                 return error_value;
2384         }
2385
2386         /* check the sense key */
2387         sense_key = 0xf & cmd->err_info->SenseInfo[2];
2388         /* no status or recovered error */
2389         if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
2390                 error_value = 0;
2391
2392         if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2393                 if (error_value != 0)
2394                         printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2395                                " sense key = 0x%x\n", cmd, sense_key);
2396                 return error_value;
2397         }
2398
2399         /* SG_IO or similar, copy sense data back */
2400         if (cmd->rq->sense) {
2401                 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2402                         cmd->rq->sense_len = cmd->err_info->SenseLen;
2403                 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2404                         cmd->rq->sense_len);
2405         } else
2406                 cmd->rq->sense_len = 0;
2407
2408         return error_value;
2409 }
2410
2411 /* checks the status of the job and calls complete buffers to mark all
2412  * buffers for the completed job. Note that this function does not need
2413  * to hold the hba/queue lock.
2414  */
2415 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2416                                     int timeout)
2417 {
2418         int retry_cmd = 0;
2419         struct request *rq = cmd->rq;
2420
2421         rq->errors = 0;
2422
2423         if (timeout)
2424                 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
2425
2426         if (cmd->err_info->CommandStatus == 0)  /* no error has occurred */
2427                 goto after_error_processing;
2428
2429         switch (cmd->err_info->CommandStatus) {
2430         case CMD_TARGET_STATUS:
2431                 rq->errors = evaluate_target_status(cmd);
2432                 break;
2433         case CMD_DATA_UNDERRUN:
2434                 if (blk_fs_request(cmd->rq)) {
2435                         printk(KERN_WARNING "cciss: cmd %p has"
2436                                " completed with data underrun "
2437                                "reported\n", cmd);
2438                         cmd->rq->data_len = cmd->err_info->ResidualCnt;
2439                 }
2440                 break;
2441         case CMD_DATA_OVERRUN:
2442                 if (blk_fs_request(cmd->rq))
2443                         printk(KERN_WARNING "cciss: cmd %p has"
2444                                " completed with data overrun "
2445                                "reported\n", cmd);
2446                 break;
2447         case CMD_INVALID:
2448                 printk(KERN_WARNING "cciss: cmd %p is "
2449                        "reported invalid\n", cmd);
2450                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2451                         cmd->err_info->CommandStatus, DRIVER_OK,
2452                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2453                 break;
2454         case CMD_PROTOCOL_ERR:
2455                 printk(KERN_WARNING "cciss: cmd %p has "
2456                        "protocol error \n", cmd);
2457                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2458                         cmd->err_info->CommandStatus, DRIVER_OK,
2459                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2460                 break;
2461         case CMD_HARDWARE_ERR:
2462                 printk(KERN_WARNING "cciss: cmd %p had "
2463                        " hardware error\n", cmd);
2464                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2465                         cmd->err_info->CommandStatus, DRIVER_OK,
2466                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2467                 break;
2468         case CMD_CONNECTION_LOST:
2469                 printk(KERN_WARNING "cciss: cmd %p had "
2470                        "connection lost\n", cmd);
2471                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2472                         cmd->err_info->CommandStatus, DRIVER_OK,
2473                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2474                 break;
2475         case CMD_ABORTED:
2476                 printk(KERN_WARNING "cciss: cmd %p was "
2477                        "aborted\n", cmd);
2478                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2479                         cmd->err_info->CommandStatus, DRIVER_OK,
2480                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2481                 break;
2482         case CMD_ABORT_FAILED:
2483                 printk(KERN_WARNING "cciss: cmd %p reports "
2484                        "abort failed\n", cmd);
2485                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2486                         cmd->err_info->CommandStatus, DRIVER_OK,
2487                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2488                 break;
2489         case CMD_UNSOLICITED_ABORT:
2490                 printk(KERN_WARNING "cciss%d: unsolicited "
2491                        "abort %p\n", h->ctlr, cmd);
2492                 if (cmd->retry_count < MAX_CMD_RETRIES) {
2493                         retry_cmd = 1;
2494                         printk(KERN_WARNING
2495                                "cciss%d: retrying %p\n", h->ctlr, cmd);
2496                         cmd->retry_count++;
2497                 } else
2498                         printk(KERN_WARNING
2499                                "cciss%d: %p retried too "
2500                                "many times\n", h->ctlr, cmd);
2501                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2502                         cmd->err_info->CommandStatus, DRIVER_OK,
2503                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2504                 break;
2505         case CMD_TIMEOUT:
2506                 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2507                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2508                         cmd->err_info->CommandStatus, DRIVER_OK,
2509                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2510                 break;
2511         default:
2512                 printk(KERN_WARNING "cciss: cmd %p returned "
2513                        "unknown status %x\n", cmd,
2514                        cmd->err_info->CommandStatus);
2515                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2516                         cmd->err_info->CommandStatus, DRIVER_OK,
2517                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2518         }
2519
2520 after_error_processing:
2521
2522         /* We need to return this command */
2523         if (retry_cmd) {
2524                 resend_cciss_cmd(h, cmd);
2525                 return;
2526         }
2527         cmd->rq->completion_data = cmd;
2528         blk_complete_request(cmd->rq);
2529 }
2530
2531 /*
2532  * Get a request and submit it to the controller.
2533  */
2534 static void do_cciss_request(struct request_queue *q)
2535 {
2536         ctlr_info_t *h = q->queuedata;
2537         CommandList_struct *c;
2538         sector_t start_blk;
2539         int seg;
2540         struct request *creq;
2541         u64bit temp64;
2542         struct scatterlist tmp_sg[MAXSGENTRIES];
2543         drive_info_struct *drv;
2544         int i, dir;
2545
2546         /* We call start_io here in case there is a command waiting on the
2547          * queue that has not been sent.
2548          */
2549         if (blk_queue_plugged(q))
2550                 goto startio;
2551
2552       queue:
2553         creq = elv_next_request(q);
2554         if (!creq)
2555                 goto startio;
2556
2557         BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2558
2559         if ((c = cmd_alloc(h, 1)) == NULL)
2560                 goto full;
2561
2562         blkdev_dequeue_request(creq);
2563
2564         spin_unlock_irq(q->queue_lock);
2565
2566         c->cmd_type = CMD_RWREQ;
2567         c->rq = creq;
2568
2569         /* fill in the request */
2570         drv = creq->rq_disk->private_data;
2571         c->Header.ReplyQueue = 0;       // unused in simple mode
2572         /* got command from pool, so use the command block index instead */
2573         /* for direct lookups. */
2574         /* The first 2 bits are reserved for controller error reporting. */
2575         c->Header.Tag.lower = (c->cmdindex << 3);
2576         c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
2577         c->Header.LUN.LogDev.VolId = drv->LunID;
2578         c->Header.LUN.LogDev.Mode = 1;
2579         c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2580         c->Request.Type.Type = TYPE_CMD;        // It is a command.
2581         c->Request.Type.Attribute = ATTR_SIMPLE;
2582         c->Request.Type.Direction =
2583             (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2584         c->Request.Timeout = 0; // Don't time out
2585         c->Request.CDB[0] =
2586             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2587         start_blk = creq->sector;
2588 #ifdef CCISS_DEBUG
2589         printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2590                (int)creq->nr_sectors);
2591 #endif                          /* CCISS_DEBUG */
2592
2593         sg_init_table(tmp_sg, MAXSGENTRIES);
2594         seg = blk_rq_map_sg(q, creq, tmp_sg);
2595
2596         /* get the DMA records for the setup */
2597         if (c->Request.Type.Direction == XFER_READ)
2598                 dir = PCI_DMA_FROMDEVICE;
2599         else
2600                 dir = PCI_DMA_TODEVICE;
2601
2602         for (i = 0; i < seg; i++) {
2603                 c->SG[i].Len = tmp_sg[i].length;
2604                 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
2605                                                   tmp_sg[i].offset,
2606                                                   tmp_sg[i].length, dir);
2607                 c->SG[i].Addr.lower = temp64.val32.lower;
2608                 c->SG[i].Addr.upper = temp64.val32.upper;
2609                 c->SG[i].Ext = 0;       // we are not chaining
2610         }
2611         /* track how many SG entries we are using */
2612         if (seg > h->maxSG)
2613                 h->maxSG = seg;
2614
2615 #ifdef CCISS_DEBUG
2616         printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2617                creq->nr_sectors, seg);
2618 #endif                          /* CCISS_DEBUG */
2619
2620         c->Header.SGList = c->Header.SGTotal = seg;
2621         if (likely(blk_fs_request(creq))) {
2622                 if(h->cciss_read == CCISS_READ_10) {
2623                         c->Request.CDB[1] = 0;
2624                         c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
2625                         c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2626                         c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2627                         c->Request.CDB[5] = start_blk & 0xff;
2628                         c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
2629                         c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2630                         c->Request.CDB[8] = creq->nr_sectors & 0xff;
2631                         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2632                 } else {
2633                         u32 upper32 = upper_32_bits(start_blk);
2634
2635                         c->Request.CDBLen = 16;
2636                         c->Request.CDB[1]= 0;
2637                         c->Request.CDB[2]= (upper32 >> 24) & 0xff;      //MSB
2638                         c->Request.CDB[3]= (upper32 >> 16) & 0xff;
2639                         c->Request.CDB[4]= (upper32 >>  8) & 0xff;
2640                         c->Request.CDB[5]= upper32 & 0xff;
2641                         c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2642                         c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2643                         c->Request.CDB[8]= (start_blk >>  8) & 0xff;
2644                         c->Request.CDB[9]= start_blk & 0xff;
2645                         c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
2646                         c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
2647                         c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
2648                         c->Request.CDB[13]= creq->nr_sectors & 0xff;
2649                         c->Request.CDB[14] = c->Request.CDB[15] = 0;
2650                 }
2651         } else if (blk_pc_request(creq)) {
2652                 c->Request.CDBLen = creq->cmd_len;
2653                 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
2654         } else {
2655                 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2656                 BUG();
2657         }
2658
2659         spin_lock_irq(q->queue_lock);
2660
2661         addQ(&(h->reqQ), c);
2662         h->Qdepth++;
2663         if (h->Qdepth > h->maxQsinceinit)
2664                 h->maxQsinceinit = h->Qdepth;
2665
2666         goto queue;
2667 full:
2668         blk_stop_queue(q);
2669 startio:
2670         /* We will already have the driver lock here so not need
2671          * to lock it.
2672          */
2673         start_io(h);
2674 }
2675
2676 static inline unsigned long get_next_completion(ctlr_info_t *h)
2677 {
2678 #ifdef CONFIG_CISS_SCSI_TAPE
2679         /* Any rejects from sendcmd() lying around? Process them first */
2680         if (h->scsi_rejects.ncompletions == 0)
2681                 return h->access.command_completed(h);
2682         else {
2683                 struct sendcmd_reject_list *srl;
2684                 int n;
2685                 srl = &h->scsi_rejects;
2686                 n = --srl->ncompletions;
2687                 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2688                 printk("p");
2689                 return srl->complete[n];
2690         }
2691 #else
2692         return h->access.command_completed(h);
2693 #endif
2694 }
2695
2696 static inline int interrupt_pending(ctlr_info_t *h)
2697 {
2698 #ifdef CONFIG_CISS_SCSI_TAPE
2699         return (h->access.intr_pending(h)
2700                 || (h->scsi_rejects.ncompletions > 0));
2701 #else
2702         return h->access.intr_pending(h);
2703 #endif
2704 }
2705
2706 static inline long interrupt_not_for_us(ctlr_info_t *h)
2707 {
2708 #ifdef CONFIG_CISS_SCSI_TAPE
2709         return (((h->access.intr_pending(h) == 0) ||
2710                  (h->interrupts_enabled == 0))
2711                 && (h->scsi_rejects.ncompletions == 0));
2712 #else
2713         return (((h->access.intr_pending(h) == 0) ||
2714                  (h->interrupts_enabled == 0)));
2715 #endif
2716 }
2717
2718 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2719 {
2720         ctlr_info_t *h = dev_id;
2721         CommandList_struct *c;
2722         unsigned long flags;
2723         __u32 a, a1, a2;
2724
2725         if (interrupt_not_for_us(h))
2726                 return IRQ_NONE;
2727         /*
2728          * If there are completed commands in the completion queue,
2729          * we had better do something about it.
2730          */
2731         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2732         while (interrupt_pending(h)) {
2733                 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2734                         a1 = a;
2735                         if ((a & 0x04)) {
2736                                 a2 = (a >> 3);
2737                                 if (a2 >= h->nr_cmds) {
2738                                         printk(KERN_WARNING
2739                                                "cciss: controller cciss%d failed, stopping.\n",
2740                                                h->ctlr);
2741                                         fail_all_cmds(h->ctlr);
2742                                         return IRQ_HANDLED;
2743                                 }
2744
2745                                 c = h->cmd_pool + a2;
2746                                 a = c->busaddr;
2747
2748                         } else {
2749                                 a &= ~3;
2750                                 if ((c = h->cmpQ) == NULL) {
2751                                         printk(KERN_WARNING
2752                                                "cciss: Completion of %08x ignored\n",
2753                                                a1);
2754                                         continue;
2755                                 }
2756                                 while (c->busaddr != a) {
2757                                         c = c->next;
2758                                         if (c == h->cmpQ)
2759                                                 break;
2760                                 }
2761                         }
2762                         /*
2763                          * If we've found the command, take it off the
2764                          * completion Q and free it
2765                          */
2766                         if (c->busaddr == a) {
2767                                 removeQ(&h->cmpQ, c);
2768                                 if (c->cmd_type == CMD_RWREQ) {
2769                                         complete_command(h, c, 0);
2770                                 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2771                                         complete(c->waiting);
2772                                 }
2773 #                               ifdef CONFIG_CISS_SCSI_TAPE
2774                                 else if (c->cmd_type == CMD_SCSI)
2775                                         complete_scsi_command(c, 0, a1);
2776 #                               endif
2777                                 continue;
2778                         }
2779                 }
2780         }
2781
2782         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2783         return IRQ_HANDLED;
2784 }
2785
2786 /*
2787  *  We cannot read the structure directly, for portability we must use
2788  *   the io functions.
2789  *   This is for debug only.
2790  */
2791 #ifdef CCISS_DEBUG
2792 static void print_cfg_table(CfgTable_struct *tb)
2793 {
2794         int i;
2795         char temp_name[17];
2796
2797         printk("Controller Configuration information\n");
2798         printk("------------------------------------\n");
2799         for (i = 0; i < 4; i++)
2800                 temp_name[i] = readb(&(tb->Signature[i]));
2801         temp_name[4] = '\0';
2802         printk("   Signature = %s\n", temp_name);
2803         printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
2804         printk("   Transport methods supported = 0x%x\n",
2805                readl(&(tb->TransportSupport)));
2806         printk("   Transport methods active = 0x%x\n",
2807                readl(&(tb->TransportActive)));
2808         printk("   Requested transport Method = 0x%x\n",
2809                readl(&(tb->HostWrite.TransportRequest)));
2810         printk("   Coalesce Interrupt Delay = 0x%x\n",
2811                readl(&(tb->HostWrite.CoalIntDelay)));
2812         printk("   Coalesce Interrupt Count = 0x%x\n",
2813                readl(&(tb->HostWrite.CoalIntCount)));
2814         printk("   Max outstanding commands = 0x%d\n",
2815                readl(&(tb->CmdsOutMax)));
2816         printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2817         for (i = 0; i < 16; i++)
2818                 temp_name[i] = readb(&(tb->ServerName[i]));
2819         temp_name[16] = '\0';
2820         printk("   Server Name = %s\n", temp_name);
2821         printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2822 }
2823 #endif                          /* CCISS_DEBUG */
2824
2825 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2826 {
2827         int i, offset, mem_type, bar_type;
2828         if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2829                 return 0;
2830         offset = 0;
2831         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2832                 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2833                 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2834                         offset += 4;
2835                 else {
2836                         mem_type = pci_resource_flags(pdev, i) &
2837                             PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2838                         switch (mem_type) {
2839                         case PCI_BASE_ADDRESS_MEM_TYPE_32:
2840                         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2841                                 offset += 4;    /* 32 bit */
2842                                 break;
2843                         case PCI_BASE_ADDRESS_MEM_TYPE_64:
2844                                 offset += 8;
2845                                 break;
2846                         default:        /* reserved in PCI 2.2 */
2847                                 printk(KERN_WARNING
2848                                        "Base address is invalid\n");
2849                                 return -1;
2850                                 break;
2851                         }
2852                 }
2853                 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2854                         return i + 1;
2855         }
2856         return -1;
2857 }
2858
2859 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
2860  * controllers that are capable. If not, we use IO-APIC mode.
2861  */
2862
2863 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2864                                            struct pci_dev *pdev, __u32 board_id)
2865 {
2866 #ifdef CONFIG_PCI_MSI
2867         int err;
2868         struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2869         {0, 2}, {0, 3}
2870         };
2871
2872         /* Some boards advertise MSI but don't really support it */
2873         if ((board_id == 0x40700E11) ||
2874             (board_id == 0x40800E11) ||
2875             (board_id == 0x40820E11) || (board_id == 0x40830E11))
2876                 goto default_int_mode;
2877
2878         if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2879                 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2880                 if (!err) {
2881                         c->intr[0] = cciss_msix_entries[0].vector;
2882                         c->intr[1] = cciss_msix_entries[1].vector;
2883                         c->intr[2] = cciss_msix_entries[2].vector;
2884                         c->intr[3] = cciss_msix_entries[3].vector;
2885                         c->msix_vector = 1;
2886                         return;
2887                 }
2888                 if (err > 0) {
2889                         printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2890                                "available\n", err);
2891                         goto default_int_mode;
2892                 } else {
2893                         printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2894                                err);
2895                         goto default_int_mode;
2896                 }
2897         }
2898         if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2899                 if (!pci_enable_msi(pdev)) {
2900                         c->msi_vector = 1;
2901                 } else {
2902                         printk(KERN_WARNING "cciss: MSI init failed\n");
2903                 }
2904         }
2905 default_int_mode:
2906 #endif                          /* CONFIG_PCI_MSI */
2907         /* if we get here we're going to use the default interrupt mode */
2908         c->intr[SIMPLE_MODE_INT] = pdev->irq;
2909         return;
2910 }
2911
2912 static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2913 {
2914         ushort subsystem_vendor_id, subsystem_device_id, command;
2915         __u32 board_id, scratchpad = 0;
2916         __u64 cfg_offset;
2917         __u32 cfg_base_addr;
2918         __u64 cfg_base_addr_index;
2919         int i, err;
2920
2921         /* check to see if controller has been disabled */
2922         /* BEFORE trying to enable it */
2923         (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2924         if (!(command & 0x02)) {
2925                 printk(KERN_WARNING
2926                        "cciss: controller appears to be disabled\n");
2927                 return -ENODEV;
2928         }
2929
2930         err = pci_enable_device(pdev);
2931         if (err) {
2932                 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2933                 return err;
2934         }
2935
2936         err = pci_request_regions(pdev, "cciss");
2937         if (err) {
2938                 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
2939                        "aborting\n");
2940                 return err;
2941         }
2942
2943         subsystem_vendor_id = pdev->subsystem_vendor;
2944         subsystem_device_id = pdev->subsystem_device;
2945         board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2946                     subsystem_vendor_id);
2947
2948 #ifdef CCISS_DEBUG
2949         printk("command = %x\n", command);
2950         printk("irq = %x\n", pdev->irq);
2951         printk("board_id = %x\n", board_id);
2952 #endif                          /* CCISS_DEBUG */
2953
2954 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2955  * else we use the IO-APIC interrupt assigned to us by system ROM.
2956  */
2957         cciss_interrupt_mode(c, pdev, board_id);
2958
2959         /*
2960          * Memory base addr is first addr , the second points to the config
2961          *   table
2962          */
2963
2964         c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2965 #ifdef CCISS_DEBUG
2966         printk("address 0 = %x\n", c->paddr);
2967 #endif                          /* CCISS_DEBUG */
2968         c->vaddr = remap_pci_mem(c->paddr, 0x250);
2969
2970         /* Wait for the board to become ready.  (PCI hotplug needs this.)
2971          * We poll for up to 120 secs, once per 100ms. */
2972         for (i = 0; i < 1200; i++) {
2973                 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2974                 if (scratchpad == CCISS_FIRMWARE_READY)
2975                         break;
2976                 set_current_state(TASK_INTERRUPTIBLE);
2977                 schedule_timeout(HZ / 10);      /* wait 100ms */
2978         }
2979         if (scratchpad != CCISS_FIRMWARE_READY) {
2980                 printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
2981                 err = -ENODEV;
2982                 goto err_out_free_res;
2983         }
2984
2985         /* get the address index number */
2986         cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2987         cfg_base_addr &= (__u32) 0x0000ffff;
2988 #ifdef CCISS_DEBUG
2989         printk("cfg base address = %x\n", cfg_base_addr);
2990 #endif                          /* CCISS_DEBUG */
2991         cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
2992 #ifdef CCISS_DEBUG
2993         printk("cfg base address index = %x\n", cfg_base_addr_index);
2994 #endif                          /* CCISS_DEBUG */
2995         if (cfg_base_addr_index == -1) {
2996                 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2997                 err = -ENODEV;
2998                 goto err_out_free_res;
2999         }
3000
3001         cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
3002 #ifdef CCISS_DEBUG
3003         printk("cfg offset = %x\n", cfg_offset);
3004 #endif                          /* CCISS_DEBUG */
3005         c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
3006                                                        cfg_base_addr_index) +
3007                                     cfg_offset, sizeof(CfgTable_struct));
3008         c->board_id = board_id;
3009
3010 #ifdef CCISS_DEBUG
3011         print_cfg_table(c->cfgtable);
3012 #endif                          /* CCISS_DEBUG */
3013
3014         for (i = 0; i < ARRAY_SIZE(products); i++) {
3015                 if (board_id == products[i].board_id) {
3016                         c->product_name = products[i].product_name;
3017                         c->access = *(products[i].access);
3018                         c->nr_cmds = products[i].nr_cmds;
3019                         break;
3020                 }
3021         }
3022         if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3023             (readb(&c->cfgtable->Signature[1]) != 'I') ||
3024             (readb(&c->cfgtable->Signature[2]) != 'S') ||
3025             (readb(&c->cfgtable->Signature[3]) != 'S')) {
3026                 printk("Does not appear to be a valid CISS config table\n");
3027                 err = -ENODEV;
3028                 goto err_out_free_res;
3029         }
3030         /* We didn't find the controller in our list. We know the
3031          * signature is valid. If it's an HP device let's try to
3032          * bind to the device and fire it up. Otherwise we bail.
3033          */
3034         if (i == ARRAY_SIZE(products)) {
3035                 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3036                         c->product_name = products[i-1].product_name;
3037                         c->access = *(products[i-1].access);
3038                         c->nr_cmds = products[i-1].nr_cmds;
3039                         printk(KERN_WARNING "cciss: This is an unknown "
3040                                 "Smart Array controller.\n"
3041                                 "cciss: Please update to the latest driver "
3042                                 "available from www.hp.com.\n");
3043                 } else {
3044                         printk(KERN_WARNING "cciss: Sorry, I don't know how"
3045                                 " to access the Smart Array controller %08lx\n"
3046                                         , (unsigned long)board_id);
3047                         err = -ENODEV;
3048                         goto err_out_free_res;
3049                 }
3050         }
3051 #ifdef CONFIG_X86
3052         {
3053                 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3054                 __u32 prefetch;
3055                 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3056                 prefetch |= 0x100;
3057                 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3058         }
3059 #endif
3060
3061         /* Disabling DMA prefetch and refetch for the P600.
3062          * An ASIC bug may result in accesses to invalid memory addresses.
3063          * We've disabled prefetch for some time now. Testing with XEN
3064          * kernels revealed a bug in the refetch if dom0 resides on a P600.
3065          */
3066         if(board_id == 0x3225103C) {
3067                 __u32 dma_prefetch;
3068                 __u32 dma_refetch;
3069                 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3070                 dma_prefetch |= 0x8000;
3071                 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3072                 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
3073                 dma_refetch |= 0x1;
3074                 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
3075         }
3076
3077 #ifdef CCISS_DEBUG
3078         printk("Trying to put board into Simple mode\n");
3079 #endif                          /* CCISS_DEBUG */
3080         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3081         /* Update the field, and then ring the doorbell */
3082         writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3083         writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
3084
3085         /* under certain very rare conditions, this can take awhile.
3086          * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3087          * as we enter this code.) */
3088         for (i = 0; i < MAX_CONFIG_WAIT; i++) {
3089                 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3090                         break;
3091                 /* delay and try again */
3092                 set_current_state(TASK_INTERRUPTIBLE);
3093                 schedule_timeout(10);
3094         }
3095
3096 #ifdef CCISS_DEBUG
3097         printk(KERN_DEBUG "I counter got to %d %x\n", i,
3098                readl(c->vaddr + SA5_DOORBELL));
3099 #endif                          /* CCISS_DEBUG */
3100 #ifdef CCISS_DEBUG
3101         print_cfg_table(c->cfgtable);
3102 #endif                          /* CCISS_DEBUG */
3103
3104         if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3105                 printk(KERN_WARNING "cciss: unable to get board into"
3106                        " simple mode\n");
3107                 err = -ENODEV;
3108                 goto err_out_free_res;
3109         }
3110         return 0;
3111
3112 err_out_free_res:
3113         /*
3114          * Deliberately omit pci_disable_device(): it does something nasty to
3115          * Smart Array controllers that pci_enable_device does not undo
3116          */
3117         pci_release_regions(pdev);
3118         return err;
3119 }
3120
3121 /*
3122  * Gets information about the local volumes attached to the controller.
3123  */
3124 static void cciss_getgeometry(int cntl_num)
3125 {
3126         ReportLunData_struct *ld_buff;
3127         InquiryData_struct *inq_buff;
3128         int return_code;
3129         int i;
3130         int listlength = 0;
3131         __u32 lunid = 0;
3132         unsigned block_size;
3133         sector_t total_size;
3134
3135         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3136         if (ld_buff == NULL) {
3137                 printk(KERN_ERR "cciss: out of memory\n");
3138                 return;
3139         }
3140         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3141         if (inq_buff == NULL) {
3142                 printk(KERN_ERR "cciss: out of memory\n");
3143                 kfree(ld_buff);
3144                 return;
3145         }
3146         /* Get the firmware version */
3147         return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3148                               sizeof(InquiryData_struct), 0, 0, 0, NULL,
3149                               TYPE_CMD);
3150         if (return_code == IO_OK) {
3151                 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3152                 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3153                 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3154                 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3155         } else {                /* send command failed */
3156
3157                 printk(KERN_WARNING "cciss: unable to determine firmware"
3158                        " version of controller\n");
3159         }
3160         /* Get the number of logical volumes */
3161         return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3162                               sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3163                               TYPE_CMD);
3164
3165         if (return_code == IO_OK) {
3166 #ifdef CCISS_DEBUG
3167                 printk("LUN Data\n--------------------------\n");
3168 #endif                          /* CCISS_DEBUG */
3169
3170                 listlength |=
3171                     (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3172                 listlength |=
3173                     (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3174                 listlength |=
3175                     (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3176                 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3177         } else {                /* reading number of logical volumes failed */
3178
3179                 printk(KERN_WARNING "cciss: report logical volume"
3180                        " command failed\n");
3181                 listlength = 0;
3182         }
3183         hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
3184         if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3185                 printk(KERN_ERR
3186                        "ciss:  only %d number of logical volumes supported\n",
3187                        CISS_MAX_LUN);
3188                 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3189         }
3190 #ifdef CCISS_DEBUG
3191         printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3192                ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3193                ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3194                hba[cntl_num]->num_luns);
3195 #endif                          /* CCISS_DEBUG */
3196
3197         hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3198         for (i = 0; i < CISS_MAX_LUN; i++) {
3199                 if (i < hba[cntl_num]->num_luns) {
3200                         lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3201                             << 24;
3202                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3203                             << 16;
3204                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3205                             << 8;
3206                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3207
3208                         hba[cntl_num]->drv[i].LunID = lunid;
3209
3210 #ifdef CCISS_DEBUG
3211                         printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
3212                                ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3213                                ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3214                                hba[cntl_num]->drv[i].LunID);
3215 #endif                          /* CCISS_DEBUG */
3216
3217                 /* testing to see if 16-byte CDBs are already being used */
3218                 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3219                         cciss_read_capacity_16(cntl_num, i, 0,
3220                                             &total_size, &block_size);
3221                         goto geo_inq;
3222                 }
3223                 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3224
3225                 /* If read_capacity returns all F's the logical is >2TB */
3226                 /* so we switch to 16-byte CDBs for all read/write ops */
3227                 if(total_size == 0xFFFFFFFFULL) {
3228                         cciss_read_capacity_16(cntl_num, i, 0,
3229                         &total_size, &block_size);
3230                         hba[cntl_num]->cciss_read = CCISS_READ_16;
3231                         hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3232                 } else {
3233                         hba[cntl_num]->cciss_read = CCISS_READ_10;
3234                         hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3235                 }
3236 geo_inq:
3237                         cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3238                                                block_size, inq_buff,
3239                                                &hba[cntl_num]->drv[i]);
3240                 } else {
3241                         /* initialize raid_level to indicate a free space */
3242                         hba[cntl_num]->drv[i].raid_level = -1;
3243                 }
3244         }
3245         kfree(ld_buff);
3246         kfree(inq_buff);
3247 }
3248
3249 /* Function to find the first free pointer into our hba[] array */
3250 /* Returns -1 if no free entries are left.  */
3251 static int alloc_cciss_hba(void)
3252 {
3253         int i;
3254
3255         for (i = 0; i < MAX_CTLR; i++) {
3256                 if (!hba[i]) {
3257                         ctlr_info_t *p;
3258
3259                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3260                         if (!p)
3261                                 goto Enomem;
3262                         p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
3263                         if (!p->gendisk[0]) {
3264                                 kfree(p);
3265                                 goto Enomem;
3266                         }
3267                         hba[i] = p;
3268                         return i;
3269                 }
3270         }
3271         printk(KERN_WARNING "cciss: This driver supports a maximum"
3272                " of %d controllers.\n", MAX_CTLR);
3273         return -1;
3274 Enomem:
3275         printk(KERN_ERR "cciss: out of memory.\n");
3276         return -1;
3277 }
3278
3279 static void free_hba(int i)
3280 {
3281         ctlr_info_t *p = hba[i];
3282         int n;
3283
3284         hba[i] = NULL;
3285         for (n = 0; n < CISS_MAX_LUN; n++)
3286                 put_disk(p->gendisk[n]);
3287         kfree(p);
3288 }
3289
3290 /*
3291  *  This is it.  Find all the controllers and register them.  I really hate
3292  *  stealing all these major device numbers.
3293  *  returns the number of block devices registered.
3294  */
3295 static int __devinit cciss_init_one(struct pci_dev *pdev,
3296                                     const struct pci_device_id *ent)
3297 {
3298         int i;
3299         int j = 0;
3300         int rc;
3301         int dac;
3302
3303         i = alloc_cciss_hba();
3304         if (i < 0)
3305                 return -1;
3306
3307         hba[i]->busy_initializing = 1;
3308
3309         if (cciss_pci_init(hba[i], pdev) != 0)
3310                 goto clean1;
3311
3312         sprintf(hba[i]->devname, "cciss%d", i);
3313         hba[i]->ctlr = i;
3314         hba[i]->pdev = pdev;
3315
3316         /* configure PCI DMA stuff */
3317         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3318                 dac = 1;
3319         else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3320                 dac = 0;
3321         else {
3322                 printk(KERN_ERR "cciss: no suitable DMA available\n");
3323                 goto clean1;
3324         }
3325
3326         /*
3327          * register with the major number, or get a dynamic major number
3328          * by passing 0 as argument.  This is done for greater than
3329          * 8 controller support.
3330          */
3331         if (i < MAX_CTLR_ORIG)
3332                 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3333         rc = register_blkdev(hba[i]->major, hba[i]->devname);
3334         if (rc == -EBUSY || rc == -EINVAL) {
3335                 printk(KERN_ERR
3336                        "cciss:  Unable to get major number %d for %s "
3337                        "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3338                 goto clean1;
3339         } else {
3340                 if (i >= MAX_CTLR_ORIG)
3341                         hba[i]->major = rc;
3342         }
3343
3344         /* make sure the board interrupts are off */
3345         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3346         if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3347                         IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3348                 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3349                        hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3350                 goto clean2;
3351         }
3352
3353         printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3354                hba[i]->devname, pdev->device, pci_name(pdev),
3355                hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3356
3357         hba[i]->cmd_pool_bits =
3358             kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3359                       1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3360         hba[i]->cmd_pool = (CommandList_struct *)
3361             pci_alloc_consistent(hba[i]->pdev,
3362                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3363                     &(hba[i]->cmd_pool_dhandle));
3364         hba[i]->errinfo_pool = (ErrorInfo_struct *)
3365             pci_alloc_consistent(hba[i]->pdev,
3366                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3367                     &(hba[i]->errinfo_pool_dhandle));
3368         if ((hba[i]->cmd_pool_bits == NULL)
3369             || (hba[i]->cmd_pool == NULL)
3370             || (hba[i]->errinfo_pool == NULL)) {
3371                 printk(KERN_ERR "cciss: out of memory");
3372                 goto clean4;
3373         }
3374 #ifdef CONFIG_CISS_SCSI_TAPE
3375         hba[i]->scsi_rejects.complete =
3376             kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3377                     (hba[i]->nr_cmds + 5), GFP_KERNEL);
3378         if (hba[i]->scsi_rejects.complete == NULL) {
3379                 printk(KERN_ERR "cciss: out of memory");
3380                 goto clean4;
3381         }
3382 #endif
3383         spin_lock_init(&hba[i]->lock);
3384
3385         /* Initialize the pdev driver private data.
3386            have it point to hba[i].  */
3387         pci_set_drvdata(pdev, hba[i]);
3388         /* command and error info recs zeroed out before
3389            they are used */
3390         memset(hba[i]->cmd_pool_bits, 0,
3391                ((hba[i]->nr_cmds + BITS_PER_LONG -
3392                  1) / BITS_PER_LONG) * sizeof(unsigned long));
3393
3394 #ifdef CCISS_DEBUG
3395         printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3396 #endif                          /* CCISS_DEBUG */
3397
3398         cciss_getgeometry(i);
3399
3400         cciss_scsi_setup(i);
3401
3402         /* Turn the interrupts on so we can service requests */
3403         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3404
3405         cciss_procinit(i);
3406
3407         hba[i]->cciss_max_sectors = 2048;
3408
3409         hba[i]->busy_initializing = 0;
3410
3411         do {
3412                 drive_info_struct *drv = &(hba[i]->drv[j]);
3413                 struct gendisk *disk = hba[i]->gendisk[j];
3414                 struct request_queue *q;
3415
3416                 /* Check if the disk was allocated already */
3417                 if (!disk){
3418                         hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3419                         disk = hba[i]->gendisk[j];
3420                 }
3421
3422                 /* Check that the disk was able to be allocated */
3423                 if (!disk) {
3424                         printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3425                         goto clean4;
3426                 }
3427
3428                 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3429                 if (!q) {
3430                         printk(KERN_ERR
3431                                "cciss:  unable to allocate queue for disk %d\n",
3432                                j);
3433                         goto clean4;
3434                 }
3435                 drv->queue = q;
3436
3437                 q->backing_dev_info.ra_pages = READ_AHEAD;
3438                 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3439
3440                 /* This is a hardware imposed limit. */
3441                 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3442
3443                 /* This is a limit in the driver and could be eliminated. */
3444                 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3445
3446                 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
3447
3448                 blk_queue_softirq_done(q, cciss_softirq_done);
3449
3450                 q->queuedata = hba[i];
3451                 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3452                 disk->major = hba[i]->major;
3453                 disk->first_minor = j << NWD_SHIFT;
3454                 disk->fops = &cciss_fops;
3455                 disk->queue = q;
3456                 disk->private_data = drv;
3457                 disk->driverfs_dev = &pdev->dev;
3458                 /* we must register the controller even if no disks exist */
3459                 /* this is for the online array utilities */
3460                 if (!drv->heads && j)
3461                         continue;
3462                 blk_queue_hardsect_size(q, drv->block_size);
3463                 set_capacity(disk, drv->nr_blocks);
3464                 add_disk(disk);
3465                 j++;
3466         } while (j <= hba[i]->highest_lun);
3467
3468         return 1;
3469
3470       clean4:
3471 #ifdef CONFIG_CISS_SCSI_TAPE
3472         kfree(hba[i]->scsi_rejects.complete);
3473 #endif
3474         kfree(hba[i]->cmd_pool_bits);
3475         if (hba[i]->cmd_pool)
3476                 pci_free_consistent(hba[i]->pdev,
3477                                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3478                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3479         if (hba[i]->errinfo_pool)
3480                 pci_free_consistent(hba[i]->pdev,
3481                                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3482                                     hba[i]->errinfo_pool,
3483                                     hba[i]->errinfo_pool_dhandle);
3484         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3485       clean2:
3486         unregister_blkdev(hba[i]->major, hba[i]->devname);
3487       clean1:
3488         hba[i]->busy_initializing = 0;
3489         /* cleanup any queues that may have been initialized */
3490         for (j=0; j <= hba[i]->highest_lun; j++){
3491                 drive_info_struct *drv = &(hba[i]->drv[j]);
3492                 if (drv->queue)
3493                         blk_cleanup_queue(drv->queue);
3494         }
3495         /*
3496          * Deliberately omit pci_disable_device(): it does something nasty to
3497          * Smart Array controllers that pci_enable_device does not undo
3498          */
3499         pci_release_regions(pdev);
3500         pci_set_drvdata(pdev, NULL);
3501         free_hba(i);
3502         return -1;
3503 }
3504
3505 static void cciss_shutdown(struct pci_dev *pdev)
3506 {
3507         ctlr_info_t *tmp_ptr;
3508         int i;
3509         char flush_buf[4];
3510         int return_code;
3511
3512         tmp_ptr = pci_get_drvdata(pdev);
3513         if (tmp_ptr == NULL)
3514                 return;
3515         i = tmp_ptr->ctlr;
3516         if (hba[i] == NULL)
3517                 return;
3518
3519         /* Turn board interrupts off  and send the flush cache command */
3520         /* sendcmd will turn off interrupt, and send the flush...
3521          * To write all data in the battery backed cache to disks */
3522         memset(flush_buf, 0, 4);
3523         return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3524                               TYPE_CMD);
3525         if (return_code == IO_OK) {
3526                 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3527         } else {
3528                 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3529         }
3530         free_irq(hba[i]->intr[2], hba[i]);
3531 }
3532
3533 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3534 {
3535         ctlr_info_t *tmp_ptr;
3536         int i, j;
3537
3538         if (pci_get_drvdata(pdev) == NULL) {
3539                 printk(KERN_ERR "cciss: Unable to remove device \n");
3540                 return;
3541         }
3542         tmp_ptr = pci_get_drvdata(pdev);
3543         i = tmp_ptr->ctlr;
3544         if (hba[i] == NULL) {
3545                 printk(KERN_ERR "cciss: device appears to "
3546                        "already be removed \n");
3547                 return;
3548         }
3549
3550         remove_proc_entry(hba[i]->devname, proc_cciss);
3551         unregister_blkdev(hba[i]->major, hba[i]->devname);
3552
3553         /* remove it from the disk list */
3554         for (j = 0; j < CISS_MAX_LUN; j++) {
3555                 struct gendisk *disk = hba[i]->gendisk[j];
3556                 if (disk) {
3557                         struct request_queue *q = disk->queue;
3558
3559                         if (disk->flags & GENHD_FL_UP)
3560                                 del_gendisk(disk);
3561                         if (q)
3562                                 blk_cleanup_queue(q);
3563                 }
3564         }
3565
3566         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
3567
3568         cciss_shutdown(pdev);
3569
3570 #ifdef CONFIG_PCI_MSI
3571         if (hba[i]->msix_vector)
3572                 pci_disable_msix(hba[i]->pdev);
3573         else if (hba[i]->msi_vector)
3574                 pci_disable_msi(hba[i]->pdev);
3575 #endif                          /* CONFIG_PCI_MSI */
3576
3577         iounmap(hba[i]->vaddr);
3578
3579         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3580                             hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3581         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3582                             hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3583         kfree(hba[i]->cmd_pool_bits);
3584 #ifdef CONFIG_CISS_SCSI_TAPE
3585         kfree(hba[i]->scsi_rejects.complete);
3586 #endif
3587         /*
3588          * Deliberately omit pci_disable_device(): it does something nasty to
3589          * Smart Array controllers that pci_enable_device does not undo
3590          */
3591         pci_release_regions(pdev);
3592         pci_set_drvdata(pdev, NULL);
3593         free_hba(i);
3594 }
3595
3596 static struct pci_driver cciss_pci_driver = {
3597         .name = "cciss",
3598         .probe = cciss_init_one,
3599         .remove = __devexit_p(cciss_remove_one),
3600         .id_table = cciss_pci_device_id,        /* id_table */
3601         .shutdown = cciss_shutdown,
3602 };
3603
3604 /*
3605  *  This is it.  Register the PCI driver information for the cards we control
3606  *  the OS will call our registered routines when it finds one of our cards.
3607  */
3608 static int __init cciss_init(void)
3609 {
3610         printk(KERN_INFO DRIVER_NAME "\n");
3611
3612         /* Register for our PCI devices */
3613         return pci_register_driver(&cciss_pci_driver);
3614 }
3615
3616 static void __exit cciss_cleanup(void)
3617 {
3618         int i;
3619
3620         pci_unregister_driver(&cciss_pci_driver);
3621         /* double check that all controller entrys have been removed */
3622         for (i = 0; i < MAX_CTLR; i++) {
3623                 if (hba[i] != NULL) {
3624                         printk(KERN_WARNING "cciss: had to remove"
3625                                " controller %d\n", i);
3626                         cciss_remove_one(hba[i]->pdev);
3627                 }
3628         }
3629         remove_proc_entry("cciss", proc_root_driver);
3630 }
3631
3632 static void fail_all_cmds(unsigned long ctlr)
3633 {
3634         /* If we get here, the board is apparently dead. */
3635         ctlr_info_t *h = hba[ctlr];
3636         CommandList_struct *c;
3637         unsigned long flags;
3638
3639         printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3640         h->alive = 0;           /* the controller apparently died... */
3641
3642         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3643
3644         pci_disable_device(h->pdev);    /* Make sure it is really dead. */
3645
3646         /* move everything off the request queue onto the completed queue */
3647         while ((c = h->reqQ) != NULL) {
3648                 removeQ(&(h->reqQ), c);
3649                 h->Qdepth--;
3650                 addQ(&(h->cmpQ), c);
3651         }
3652
3653         /* Now, fail everything on the completed queue with a HW error */
3654         while ((c = h->cmpQ) != NULL) {
3655                 removeQ(&h->cmpQ, c);
3656                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3657                 if (c->cmd_type == CMD_RWREQ) {
3658                         complete_command(h, c, 0);
3659                 } else if (c->cmd_type == CMD_IOCTL_PEND)
3660                         complete(c->waiting);
3661 #ifdef CONFIG_CISS_SCSI_TAPE
3662                 else if (c->cmd_type == CMD_SCSI)
3663                         complete_scsi_command(c, 0, 0);
3664 #endif
3665         }
3666         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3667         return;
3668 }
3669
3670 module_init(cciss_init);
3671 module_exit(cciss_cleanup);