drivers/block/cciss.c

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