drivers/block/cciss.c

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