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 = -EFAULT;
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 gets the serial number of a logical drive via
1334  * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
1335  * number cannot be had, for whatever reason, 16 bytes of 0xff
1336  * are returned instead.
1337  */
1338 static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
1339                                 unsigned char *serial_no, int buflen)
1340 {
1341 #define PAGE_83_INQ_BYTES 64
1342         int rc;
1343         unsigned char *buf;
1344
1345         if (buflen > 16)
1346                 buflen = 16;
1347         memset(serial_no, 0xff, buflen);
1348         buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
1349         if (!buf)
1350                 return;
1351         memset(serial_no, 0, buflen);
1352         if (withirq)
1353                 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
1354                         PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
1355         else
1356                 rc = sendcmd(CISS_INQUIRY, ctlr, buf,
1357                         PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
1358         if (rc == IO_OK)
1359                 memcpy(serial_no, &buf[8], buflen);
1360         kfree(buf);
1361         return;
1362 }
1363
1364 /* This function will check the usage_count of the drive to be updated/added.
1365  * If the usage_count is zero and it is a heretofore unknown drive, or,
1366  * the drive's capacity, geometry, or serial number has changed,
1367  * then the drive information will be updated and the disk will be
1368  * re-registered with the kernel.  If these conditions don't hold,
1369  * then it will be left alone for the next reboot.  The exception to this
1370  * is disk 0 which will always be left registered with the kernel since it
1371  * is also the controller node.  Any changes to disk 0 will show up on
1372  * the next reboot.
1373  */
1374 static void cciss_update_drive_info(int ctlr, int drv_index)
1375 {
1376         ctlr_info_t *h = hba[ctlr];
1377         struct gendisk *disk;
1378         InquiryData_struct *inq_buff = NULL;
1379         unsigned int block_size;
1380         sector_t total_size;
1381         unsigned long flags = 0;
1382         int ret = 0;
1383         drive_info_struct *drvinfo;
1384
1385         /* Get information about the disk and modify the driver structure */
1386         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
1387         drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
1388         if (inq_buff == NULL || drvinfo == NULL)
1389                 goto mem_msg;
1390
1391         /* testing to see if 16-byte CDBs are already being used */
1392         if (h->cciss_read == CCISS_READ_16) {
1393                 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1394                         &total_size, &block_size);
1395
1396         } else {
1397                 cciss_read_capacity(ctlr, drv_index, 1,
1398                                     &total_size, &block_size);
1399
1400                 /* if read_capacity returns all F's this volume is >2TB */
1401                 /* in size so we switch to 16-byte CDB's for all */
1402                 /* read/write ops */
1403                 if (total_size == 0xFFFFFFFFULL) {
1404                         cciss_read_capacity_16(ctlr, drv_index, 1,
1405                         &total_size, &block_size);
1406                         h->cciss_read = CCISS_READ_16;
1407                         h->cciss_write = CCISS_WRITE_16;
1408                 } else {
1409                         h->cciss_read = CCISS_READ_10;
1410                         h->cciss_write = CCISS_WRITE_10;
1411                 }
1412         }
1413
1414         cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1415                                inq_buff, drvinfo);
1416         drvinfo->block_size = block_size;
1417         drvinfo->nr_blocks = total_size + 1;
1418
1419         cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
1420                         sizeof(drvinfo->serial_no));
1421
1422         /* Is it the same disk we already know, and nothing's changed? */
1423         if (h->drv[drv_index].raid_level != -1 &&
1424                 ((memcmp(drvinfo->serial_no,
1425                                 h->drv[drv_index].serial_no, 16) == 0) &&
1426                 drvinfo->block_size == h->drv[drv_index].block_size &&
1427                 drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
1428                 drvinfo->heads == h->drv[drv_index].heads &&
1429                 drvinfo->sectors == h->drv[drv_index].sectors &&
1430                 drvinfo->cylinders == h->drv[drv_index].cylinders)) {
1431                         /* The disk is unchanged, nothing to update */
1432                         goto freeret;
1433         }
1434
1435         /* Not the same disk, or something's changed, so we need to */
1436         /* deregister it, and re-register it, if it's not in use. */
1437
1438         /* if the disk already exists then deregister it before proceeding */
1439         /* (unless it's the first disk (for the controller node). */
1440         if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
1441                 printk(KERN_WARNING "disk %d has changed.\n", drv_index);
1442                 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1443                 h->drv[drv_index].busy_configuring = 1;
1444                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1445
1446                 /* deregister_disk sets h->drv[drv_index].queue = NULL */
1447                 /* which keeps the interrupt handler from starting */
1448                 /* the queue. */
1449                 ret = deregister_disk(h->gendisk[drv_index],
1450                                       &h->drv[drv_index], 0);
1451                 h->drv[drv_index].busy_configuring = 0;
1452         }
1453
1454         /* If the disk is in use return */
1455         if (ret)
1456                 goto freeret;
1457
1458         /* Save the new information from cciss_geometry_inquiry */
1459         /* and serial number inquiry. */
1460         h->drv[drv_index].block_size = drvinfo->block_size;
1461         h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
1462         h->drv[drv_index].heads = drvinfo->heads;
1463         h->drv[drv_index].sectors = drvinfo->sectors;
1464         h->drv[drv_index].cylinders = drvinfo->cylinders;
1465         h->drv[drv_index].raid_level = drvinfo->raid_level;
1466         memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
1467
1468         ++h->num_luns;
1469         disk = h->gendisk[drv_index];
1470         set_capacity(disk, h->drv[drv_index].nr_blocks);
1471
1472         /* if it's the controller (if drv_index == 0) it's already added */
1473         if (drv_index) {
1474                 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1475                 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1476                 disk->major = h->major;
1477                 disk->first_minor = drv_index << NWD_SHIFT;
1478                 disk->fops = &cciss_fops;
1479                 disk->private_data = &h->drv[drv_index];
1480
1481                 /* Set up queue information */
1482                 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1483
1484                 /* This is a hardware imposed limit. */
1485                 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1486
1487                 /* This is a limit in the driver and could be eliminated. */
1488                 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1489
1490                 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
1491
1492                 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1493
1494                 disk->queue->queuedata = hba[ctlr];
1495
1496                 blk_queue_hardsect_size(disk->queue,
1497                                         hba[ctlr]->drv[drv_index].block_size);
1498
1499                 /* Make sure all queue data is written out before */
1500                 /* setting h->drv[drv_index].queue, as setting this */
1501                 /* allows the interrupt handler to start the queue */
1502                 wmb();
1503                 h->drv[drv_index].queue = disk->queue;
1504                 add_disk(disk);
1505         }
1506
1507       freeret:
1508         kfree(inq_buff);
1509         kfree(drvinfo);
1510         return;
1511       mem_msg:
1512         printk(KERN_ERR "cciss: out of memory\n");
1513         goto freeret;
1514 }
1515
1516 /* This function will find the first index of the controllers drive array
1517  * that has a -1 for the raid_level and will return that index.  This is
1518  * where new drives will be added.  If the index to be returned is greater
1519  * than the highest_lun index for the controller then highest_lun is set
1520  * to this new index.  If there are no available indexes then -1 is returned.
1521  */
1522 static int cciss_find_free_drive_index(int ctlr)
1523 {
1524         int i;
1525
1526         for (i = 0; i < CISS_MAX_LUN; i++) {
1527                 if (hba[ctlr]->drv[i].raid_level == -1) {
1528                         if (i > hba[ctlr]->highest_lun)
1529                                 hba[ctlr]->highest_lun = i;
1530                         return i;
1531                 }
1532         }
1533         return -1;
1534 }
1535
1536 /* This function will add and remove logical drives from the Logical
1537  * drive array of the controller and maintain persistency of ordering
1538  * so that mount points are preserved until the next reboot.  This allows
1539  * for the removal of logical drives in the middle of the drive array
1540  * without a re-ordering of those drives.
1541  * INPUT
1542  * h            = The controller to perform the operations on
1543  * del_disk     = The disk to remove if specified.  If the value given
1544  *                is NULL then no disk is removed.
1545  */
1546 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1547 {
1548         int ctlr = h->ctlr;
1549         int num_luns;
1550         ReportLunData_struct *ld_buff = NULL;
1551         int return_code;
1552         int listlength = 0;
1553         int i;
1554         int drv_found;
1555         int drv_index = 0;
1556         __u32 lunid = 0;
1557         unsigned long flags;
1558
1559         /* Set busy_configuring flag for this operation */
1560         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1561         if (h->busy_configuring) {
1562                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1563                 return -EBUSY;
1564         }
1565         h->busy_configuring = 1;
1566         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1567
1568         if (!capable(CAP_SYS_RAWIO))
1569                 return -EPERM;
1570
1571         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1572         if (ld_buff == NULL)
1573                 goto mem_msg;
1574
1575         return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1576                                       sizeof(ReportLunData_struct), 0,
1577                                       0, 0, TYPE_CMD);
1578
1579         if (return_code == IO_OK)
1580                 listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
1581         else {  /* reading number of logical volumes failed */
1582                 printk(KERN_WARNING "cciss: report logical volume"
1583                        " command failed\n");
1584                 listlength = 0;
1585                 goto freeret;
1586         }
1587
1588         num_luns = listlength / 8;      /* 8 bytes per entry */
1589         if (num_luns > CISS_MAX_LUN) {
1590                 num_luns = CISS_MAX_LUN;
1591                 printk(KERN_WARNING "cciss: more luns configured"
1592                        " on controller than can be handled by"
1593                        " this driver.\n");
1594         }
1595
1596         /* Compare controller drive array to driver's drive array */
1597         /* to see if any drives are missing on the controller due */
1598         /* to action of Array Config Utility (user deletes drive) */
1599         /* and deregister logical drives which have disappeared.  */
1600         for (i = 0; i <= h->highest_lun; i++) {
1601                 int j;
1602                 drv_found = 0;
1603                 for (j = 0; j < num_luns; j++) {
1604                         memcpy(&lunid, &ld_buff->LUN[j][0], 4);
1605                         lunid = le32_to_cpu(lunid);
1606                         if (h->drv[i].LunID == lunid) {
1607                                 drv_found = 1;
1608                                 break;
1609                         }
1610                 }
1611                 if (!drv_found) {
1612                         /* Deregister it from the OS, it's gone. */
1613                         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1614                         h->drv[i].busy_configuring = 1;
1615                         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1616                         return_code = deregister_disk(h->gendisk[i],
1617                                 &h->drv[i], 1);
1618                         h->drv[i].busy_configuring = 0;
1619                 }
1620         }
1621
1622         /* Compare controller drive array to driver's drive array.
1623          * Check for updates in the drive information and any new drives
1624          * on the controller due to ACU adding logical drives, or changing
1625          * a logical drive's size, etc.  Reregister any new/changed drives
1626          */
1627         for (i = 0; i < num_luns; i++) {
1628                 int j;
1629
1630                 drv_found = 0;
1631
1632                 memcpy(&lunid, &ld_buff->LUN[i][0], 4);
1633                 lunid = le32_to_cpu(lunid);
1634
1635                 /* Find if the LUN is already in the drive array
1636                  * of the driver.  If so then update its info
1637                  * if not in use.  If it does not exist then find
1638                  * the first free index and add it.
1639                  */
1640                 for (j = 0; j <= h->highest_lun; j++) {
1641                         if (h->drv[j].raid_level != -1 &&
1642                                 h->drv[j].LunID == lunid) {
1643                                 drv_index = j;
1644                                 drv_found = 1;
1645                                 break;
1646                         }
1647                 }
1648
1649                 /* check if the drive was found already in the array */
1650                 if (!drv_found) {
1651                         drv_index = cciss_find_free_drive_index(ctlr);
1652                         if (drv_index == -1)
1653                                 goto freeret;
1654                         /*Check if the gendisk needs to be allocated */
1655                         if (!h->gendisk[drv_index]) {
1656                                 h->gendisk[drv_index] =
1657                                         alloc_disk(1 << NWD_SHIFT);
1658                                 if (!h->gendisk[drv_index]){
1659                                         printk(KERN_ERR "cciss: could not "
1660                                                 "allocate new disk %d\n",
1661                                                 drv_index);
1662                                         goto mem_msg;
1663                                 }
1664                         }
1665                         h->drv[drv_index].LunID = lunid;
1666
1667                         /* Don't need to mark this busy because nobody
1668                          * else knows about this disk yet to contend
1669                          * for access to it.
1670                          */
1671                         h->drv[drv_index].busy_configuring = 0;
1672                         wmb();
1673
1674                 }
1675                 cciss_update_drive_info(ctlr, drv_index);
1676         }               /* end for */
1677
1678       freeret:
1679         kfree(ld_buff);
1680         h->busy_configuring = 0;
1681         /* We return -1 here to tell the ACU that we have registered/updated
1682          * all of the drives that we can and to keep it from calling us
1683          * additional times.
1684          */
1685         return -1;
1686       mem_msg:
1687         printk(KERN_ERR "cciss: out of memory\n");
1688         h->busy_configuring = 0;
1689         goto freeret;
1690 }
1691
1692 /* This function will deregister the disk and it's queue from the
1693  * kernel.  It must be called with the controller lock held and the
1694  * drv structures busy_configuring flag set.  It's parameters are:
1695  *
1696  * disk = This is the disk to be deregistered
1697  * drv  = This is the drive_info_struct associated with the disk to be
1698  *        deregistered.  It contains information about the disk used
1699  *        by the driver.
1700  * clear_all = This flag determines whether or not the disk information
1701  *             is going to be completely cleared out and the highest_lun
1702  *             reset.  Sometimes we want to clear out information about
1703  *             the disk in preparation for re-adding it.  In this case
1704  *             the highest_lun should be left unchanged and the LunID
1705  *             should not be cleared.
1706 */
1707 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1708                            int clear_all)
1709 {
1710         int i;
1711         ctlr_info_t *h = get_host(disk);
1712
1713         if (!capable(CAP_SYS_RAWIO))
1714                 return -EPERM;
1715
1716         /* make sure logical volume is NOT is use */
1717         if (clear_all || (h->gendisk[0] == disk)) {
1718                 if (drv->usage_count > 1)
1719                         return -EBUSY;
1720         } else if (drv->usage_count > 0)
1721                 return -EBUSY;
1722
1723         /* invalidate the devices and deregister the disk.  If it is disk
1724          * zero do not deregister it but just zero out it's values.  This
1725          * allows us to delete disk zero but keep the controller registered.
1726          */
1727         if (h->gendisk[0] != disk) {
1728                 struct request_queue *q = disk->queue;
1729                 if (disk->flags & GENHD_FL_UP)
1730                         del_gendisk(disk);
1731                 if (q) {
1732                         blk_cleanup_queue(q);
1733                         /* Set drv->queue to NULL so that we do not try
1734                          * to call blk_start_queue on this queue in the
1735                          * interrupt handler
1736                          */
1737                         drv->queue = NULL;
1738                 }
1739                 /* If clear_all is set then we are deleting the logical
1740                  * drive, not just refreshing its info.  For drives
1741                  * other than disk 0 we will call put_disk.  We do not
1742                  * do this for disk 0 as we need it to be able to
1743                  * configure the controller.
1744                  */
1745                 if (clear_all){
1746                         /* This isn't pretty, but we need to find the
1747                          * disk in our array and NULL our the pointer.
1748                          * This is so that we will call alloc_disk if
1749                          * this index is used again later.
1750                          */
1751                         for (i=0; i < CISS_MAX_LUN; i++){
1752                                 if (h->gendisk[i] == disk) {
1753                                         h->gendisk[i] = NULL;
1754                                         break;
1755                                 }
1756                         }
1757                         put_disk(disk);
1758                 }
1759         } else {
1760                 set_capacity(disk, 0);
1761         }
1762
1763         --h->num_luns;
1764         /* zero out the disk size info */
1765         drv->nr_blocks = 0;
1766         drv->block_size = 0;
1767         drv->heads = 0;
1768         drv->sectors = 0;
1769         drv->cylinders = 0;
1770         drv->raid_level = -1;   /* This can be used as a flag variable to
1771                                  * indicate that this element of the drive
1772                                  * array is free.
1773                                  */
1774
1775         if (clear_all) {
1776                 /* check to see if it was the last disk */
1777                 if (drv == h->drv + h->highest_lun) {
1778                         /* if so, find the new hightest lun */
1779                         int i, newhighest = -1;
1780                         for (i = 0; i <= h->highest_lun; i++) {
1781                                 /* if the disk has size > 0, it is available */
1782                                 if (h->drv[i].heads)
1783                                         newhighest = i;
1784                         }
1785                         h->highest_lun = newhighest;
1786                 }
1787
1788                 drv->LunID = 0;
1789         }
1790         return 0;
1791 }
1792
1793 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,
1794                                                                                                                            1: address logical volume log_unit,
1795                                                                                                                            2: periph device address is scsi3addr */
1796                     unsigned int log_unit, __u8 page_code,
1797                     unsigned char *scsi3addr, int cmd_type)
1798 {
1799         ctlr_info_t *h = hba[ctlr];
1800         u64bit buff_dma_handle;
1801         int status = IO_OK;
1802
1803         c->cmd_type = CMD_IOCTL_PEND;
1804         c->Header.ReplyQueue = 0;
1805         if (buff != NULL) {
1806                 c->Header.SGList = 1;
1807                 c->Header.SGTotal = 1;
1808         } else {
1809                 c->Header.SGList = 0;
1810                 c->Header.SGTotal = 0;
1811         }
1812         c->Header.Tag.lower = c->busaddr;
1813
1814         c->Request.Type.Type = cmd_type;
1815         if (cmd_type == TYPE_CMD) {
1816                 switch (cmd) {
1817                 case CISS_INQUIRY:
1818                         /* If the logical unit number is 0 then, this is going
1819                            to controller so It's a physical command
1820                            mode = 0 target = 0.  So we have nothing to write.
1821                            otherwise, if use_unit_num == 1,
1822                            mode = 1(volume set addressing) target = LUNID
1823                            otherwise, if use_unit_num == 2,
1824                            mode = 0(periph dev addr) target = scsi3addr */
1825                         if (use_unit_num == 1) {
1826                                 c->Header.LUN.LogDev.VolId =
1827                                     h->drv[log_unit].LunID;
1828                                 c->Header.LUN.LogDev.Mode = 1;
1829                         } else if (use_unit_num == 2) {
1830                                 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1831                                        8);
1832                                 c->Header.LUN.LogDev.Mode = 0;
1833                         }
1834                         /* are we trying to read a vital product page */
1835                         if (page_code != 0) {
1836                                 c->Request.CDB[1] = 0x01;
1837                                 c->Request.CDB[2] = page_code;
1838                         }
1839                         c->Request.CDBLen = 6;
1840                         c->Request.Type.Attribute = ATTR_SIMPLE;
1841                         c->Request.Type.Direction = XFER_READ;
1842                         c->Request.Timeout = 0;
1843                         c->Request.CDB[0] = CISS_INQUIRY;
1844                         c->Request.CDB[4] = size & 0xFF;
1845                         break;
1846                 case CISS_REPORT_LOG:
1847                 case CISS_REPORT_PHYS:
1848                         /* Talking to controller so It's a physical command
1849                            mode = 00 target = 0.  Nothing to write.
1850                          */
1851                         c->Request.CDBLen = 12;
1852                         c->Request.Type.Attribute = ATTR_SIMPLE;
1853                         c->Request.Type.Direction = XFER_READ;
1854                         c->Request.Timeout = 0;
1855                         c->Request.CDB[0] = cmd;
1856                         c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
1857                         c->Request.CDB[7] = (size >> 16) & 0xFF;
1858                         c->Request.CDB[8] = (size >> 8) & 0xFF;
1859                         c->Request.CDB[9] = size & 0xFF;
1860                         break;
1861
1862                 case CCISS_READ_CAPACITY:
1863                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1864                         c->Header.LUN.LogDev.Mode = 1;
1865                         c->Request.CDBLen = 10;
1866                         c->Request.Type.Attribute = ATTR_SIMPLE;
1867                         c->Request.Type.Direction = XFER_READ;
1868                         c->Request.Timeout = 0;
1869                         c->Request.CDB[0] = cmd;
1870                         break;
1871                 case CCISS_READ_CAPACITY_16:
1872                         c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1873                         c->Header.LUN.LogDev.Mode = 1;
1874                         c->Request.CDBLen = 16;
1875                         c->Request.Type.Attribute = ATTR_SIMPLE;
1876                         c->Request.Type.Direction = XFER_READ;
1877                         c->Request.Timeout = 0;
1878                         c->Request.CDB[0] = cmd;
1879                         c->Request.CDB[1] = 0x10;
1880                         c->Request.CDB[10] = (size >> 24) & 0xFF;
1881                         c->Request.CDB[11] = (size >> 16) & 0xFF;
1882                         c->Request.CDB[12] = (size >> 8) & 0xFF;
1883                         c->Request.CDB[13] = size & 0xFF;
1884                         c->Request.Timeout = 0;
1885                         c->Request.CDB[0] = cmd;
1886                         break;
1887                 case CCISS_CACHE_FLUSH:
1888                         c->Request.CDBLen = 12;
1889                         c->Request.Type.Attribute = ATTR_SIMPLE;
1890                         c->Request.Type.Direction = XFER_WRITE;
1891                         c->Request.Timeout = 0;
1892                         c->Request.CDB[0] = BMIC_WRITE;
1893                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1894                         break;
1895                 default:
1896                         printk(KERN_WARNING
1897                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
1898                         return IO_ERROR;
1899                 }
1900         } else if (cmd_type == TYPE_MSG) {
1901                 switch (cmd) {
1902                 case 0: /* ABORT message */
1903                         c->Request.CDBLen = 12;
1904                         c->Request.Type.Attribute = ATTR_SIMPLE;
1905                         c->Request.Type.Direction = XFER_WRITE;
1906                         c->Request.Timeout = 0;
1907                         c->Request.CDB[0] = cmd;        /* abort */
1908                         c->Request.CDB[1] = 0;  /* abort a command */
1909                         /* buff contains the tag of the command to abort */
1910                         memcpy(&c->Request.CDB[4], buff, 8);
1911                         break;
1912                 case 1: /* RESET message */
1913                         c->Request.CDBLen = 12;
1914                         c->Request.Type.Attribute = ATTR_SIMPLE;
1915                         c->Request.Type.Direction = XFER_WRITE;
1916                         c->Request.Timeout = 0;
1917                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1918                         c->Request.CDB[0] = cmd;        /* reset */
1919                         c->Request.CDB[1] = 0x04;       /* reset a LUN */
1920                         break;
1921                 case 3: /* No-Op message */
1922                         c->Request.CDBLen = 1;
1923                         c->Request.Type.Attribute = ATTR_SIMPLE;
1924                         c->Request.Type.Direction = XFER_WRITE;
1925                         c->Request.Timeout = 0;
1926                         c->Request.CDB[0] = cmd;
1927                         break;
1928                 default:
1929                         printk(KERN_WARNING
1930                                "cciss%d: unknown message type %d\n", ctlr, cmd);
1931                         return IO_ERROR;
1932                 }
1933         } else {
1934                 printk(KERN_WARNING
1935                        "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1936                 return IO_ERROR;
1937         }
1938         /* Fill in the scatter gather information */
1939         if (size > 0) {
1940                 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1941                                                              buff, size,
1942                                                              PCI_DMA_BIDIRECTIONAL);
1943                 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1944                 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1945                 c->SG[0].Len = size;
1946                 c->SG[0].Ext = 0;       /* we are not chaining */
1947         }
1948         return status;
1949 }
1950
1951 static int sendcmd_withirq(__u8 cmd,
1952                            int ctlr,
1953                            void *buff,
1954                            size_t size,
1955                            unsigned int use_unit_num,
1956                            unsigned int log_unit, __u8 page_code, int cmd_type)
1957 {
1958         ctlr_info_t *h = hba[ctlr];
1959         CommandList_struct *c;
1960         u64bit buff_dma_handle;
1961         unsigned long flags;
1962         int return_status;
1963         DECLARE_COMPLETION_ONSTACK(wait);
1964
1965         if ((c = cmd_alloc(h, 0)) == NULL)
1966                 return -ENOMEM;
1967         return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1968                                  log_unit, page_code, NULL, cmd_type);
1969         if (return_status != IO_OK) {
1970                 cmd_free(h, c, 0);
1971                 return return_status;
1972         }
1973       resend_cmd2:
1974         c->waiting = &wait;
1975
1976         /* Put the request on the tail of the queue and send it */
1977         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1978         addQ(&h->reqQ, c);
1979         h->Qdepth++;
1980         start_io(h);
1981         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1982
1983         wait_for_completion(&wait);
1984
1985         if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
1986                 switch (c->err_info->CommandStatus) {
1987                 case CMD_TARGET_STATUS:
1988                         printk(KERN_WARNING "cciss: cmd %p has "
1989                                " completed with errors\n", c);
1990                         if (c->err_info->ScsiStatus) {
1991                                 printk(KERN_WARNING "cciss: cmd %p "
1992                                        "has SCSI Status = %x\n",
1993                                        c, c->err_info->ScsiStatus);
1994                         }
1995
1996                         break;
1997                 case CMD_DATA_UNDERRUN:
1998                 case CMD_DATA_OVERRUN:
1999                         /* expected for inquire and report lun commands */
2000                         break;
2001                 case CMD_INVALID:
2002                         printk(KERN_WARNING "cciss: Cmd %p is "
2003                                "reported invalid\n", c);
2004                         return_status = IO_ERROR;
2005                         break;
2006                 case CMD_PROTOCOL_ERR:
2007                         printk(KERN_WARNING "cciss: cmd %p has "
2008                                "protocol error \n", c);
2009                         return_status = IO_ERROR;
2010                         break;
2011                 case CMD_HARDWARE_ERR:
2012                         printk(KERN_WARNING "cciss: cmd %p had "
2013                                " hardware error\n", c);
2014                         return_status = IO_ERROR;
2015                         break;
2016                 case CMD_CONNECTION_LOST:
2017                         printk(KERN_WARNING "cciss: cmd %p had "
2018                                "connection lost\n", c);
2019                         return_status = IO_ERROR;
2020                         break;
2021                 case CMD_ABORTED:
2022                         printk(KERN_WARNING "cciss: cmd %p was "
2023                                "aborted\n", c);
2024                         return_status = IO_ERROR;
2025                         break;
2026                 case CMD_ABORT_FAILED:
2027                         printk(KERN_WARNING "cciss: cmd %p reports "
2028                                "abort failed\n", c);
2029                         return_status = IO_ERROR;
2030                         break;
2031                 case CMD_UNSOLICITED_ABORT:
2032                         printk(KERN_WARNING
2033                                "cciss%d: unsolicited abort %p\n", ctlr, c);
2034                         if (c->retry_count < MAX_CMD_RETRIES) {
2035                                 printk(KERN_WARNING
2036                                        "cciss%d: retrying %p\n", ctlr, c);
2037                                 c->retry_count++;
2038                                 /* erase the old error information */
2039                                 memset(c->err_info, 0,
2040                                        sizeof(ErrorInfo_struct));
2041                                 return_status = IO_OK;
2042                                 INIT_COMPLETION(wait);
2043                                 goto resend_cmd2;
2044                         }
2045                         return_status = IO_ERROR;
2046                         break;
2047                 default:
2048                         printk(KERN_WARNING "cciss: cmd %p returned "
2049                                "unknown status %x\n", c,
2050                                c->err_info->CommandStatus);
2051                         return_status = IO_ERROR;
2052                 }
2053         }
2054         /* unlock the buffers from DMA */
2055         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2056         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2057         pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
2058                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2059         cmd_free(h, c, 0);
2060         return return_status;
2061 }
2062
2063 static void cciss_geometry_inquiry(int ctlr, int logvol,
2064                                    int withirq, sector_t total_size,
2065                                    unsigned int block_size,
2066                                    InquiryData_struct *inq_buff,
2067                                    drive_info_struct *drv)
2068 {
2069         int return_code;
2070         unsigned long t;
2071
2072         memset(inq_buff, 0, sizeof(InquiryData_struct));
2073         if (withirq)
2074                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
2075                                               inq_buff, sizeof(*inq_buff), 1,
2076                                               logvol, 0xC1, TYPE_CMD);
2077         else
2078                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
2079                                       sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
2080                                       TYPE_CMD);
2081         if (return_code == IO_OK) {
2082                 if (inq_buff->data_byte[8] == 0xFF) {
2083                         printk(KERN_WARNING
2084                                "cciss: reading geometry failed, volume "
2085                                "does not support reading geometry\n");
2086                         drv->heads = 255;
2087                         drv->sectors = 32;      // Sectors per track
2088                         drv->cylinders = total_size + 1;
2089                         drv->raid_level = RAID_UNKNOWN;
2090                 } else {
2091                         drv->heads = inq_buff->data_byte[6];
2092                         drv->sectors = inq_buff->data_byte[7];
2093                         drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
2094                         drv->cylinders += inq_buff->data_byte[5];
2095                         drv->raid_level = inq_buff->data_byte[8];
2096                 }
2097                 drv->block_size = block_size;
2098                 drv->nr_blocks = total_size + 1;
2099                 t = drv->heads * drv->sectors;
2100                 if (t > 1) {
2101                         sector_t real_size = total_size + 1;
2102                         unsigned long rem = sector_div(real_size, t);
2103                         if (rem)
2104                                 real_size++;
2105                         drv->cylinders = real_size;
2106                 }
2107         } else {                /* Get geometry failed */
2108                 printk(KERN_WARNING "cciss: reading geometry failed\n");
2109         }
2110         printk(KERN_INFO "      heads=%d, sectors=%d, cylinders=%d\n\n",
2111                drv->heads, drv->sectors, drv->cylinders);
2112 }
2113
2114 static void
2115 cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
2116                     unsigned int *block_size)
2117 {
2118         ReadCapdata_struct *buf;
2119         int return_code;
2120
2121         buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
2122         if (!buf) {
2123                 printk(KERN_WARNING "cciss: out of memory\n");
2124                 return;
2125         }
2126
2127         if (withirq)
2128                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
2129                                 ctlr, buf, sizeof(ReadCapdata_struct),
2130                                         1, logvol, 0, TYPE_CMD);
2131         else
2132                 return_code = sendcmd(CCISS_READ_CAPACITY,
2133                                 ctlr, buf, sizeof(ReadCapdata_struct),
2134                                         1, logvol, 0, NULL, TYPE_CMD);
2135         if (return_code == IO_OK) {
2136                 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
2137                 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2138         } else {                /* read capacity command failed */
2139                 printk(KERN_WARNING "cciss: read capacity failed\n");
2140                 *total_size = 0;
2141                 *block_size = BLOCK_SIZE;
2142         }
2143         if (*total_size != 0)
2144                 printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2145                 (unsigned long long)*total_size+1, *block_size);
2146         kfree(buf);
2147 }
2148
2149 static void
2150 cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,                                 unsigned int *block_size)
2151 {
2152         ReadCapdata_struct_16 *buf;
2153         int return_code;
2154
2155         buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2156         if (!buf) {
2157                 printk(KERN_WARNING "cciss: out of memory\n");
2158                 return;
2159         }
2160
2161         if (withirq) {
2162                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2163                         ctlr, buf, sizeof(ReadCapdata_struct_16),
2164                                 1, logvol, 0, TYPE_CMD);
2165         }
2166         else {
2167                 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2168                         ctlr, buf, sizeof(ReadCapdata_struct_16),
2169                                 1, logvol, 0, NULL, TYPE_CMD);
2170         }
2171         if (return_code == IO_OK) {
2172                 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2173                 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
2174         } else {                /* read capacity command failed */
2175                 printk(KERN_WARNING "cciss: read capacity failed\n");
2176                 *total_size = 0;
2177                 *block_size = BLOCK_SIZE;
2178         }
2179         printk(KERN_INFO "      blocks= %llu block_size= %d\n",
2180                (unsigned long long)*total_size+1, *block_size);
2181         kfree(buf);
2182 }
2183
2184 static int cciss_revalidate(struct gendisk *disk)
2185 {
2186         ctlr_info_t *h = get_host(disk);
2187         drive_info_struct *drv = get_drv(disk);
2188         int logvol;
2189         int FOUND = 0;
2190         unsigned int block_size;
2191         sector_t total_size;
2192         InquiryData_struct *inq_buff = NULL;
2193
2194         for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2195                 if (h->drv[logvol].LunID == drv->LunID) {
2196                         FOUND = 1;
2197                         break;
2198                 }
2199         }
2200
2201         if (!FOUND)
2202                 return 1;
2203
2204         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2205         if (inq_buff == NULL) {
2206                 printk(KERN_WARNING "cciss: out of memory\n");
2207                 return 1;
2208         }
2209         if (h->cciss_read == CCISS_READ_10) {
2210                 cciss_read_capacity(h->ctlr, logvol, 1,
2211                                         &total_size, &block_size);
2212         } else {
2213                 cciss_read_capacity_16(h->ctlr, logvol, 1,
2214                                         &total_size, &block_size);
2215         }
2216         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2217                                inq_buff, drv);
2218
2219         blk_queue_hardsect_size(drv->queue, drv->block_size);
2220         set_capacity(disk, drv->nr_blocks);
2221
2222         kfree(inq_buff);
2223         return 0;
2224 }
2225
2226 /*
2227  *   Wait polling for a command to complete.
2228  *   The memory mapped FIFO is polled for the completion.
2229  *   Used only at init time, interrupts from the HBA are disabled.
2230  */
2231 static unsigned long pollcomplete(int ctlr)
2232 {
2233         unsigned long done;
2234         int i;
2235
2236         /* Wait (up to 20 seconds) for a command to complete */
2237
2238         for (i = 20 * HZ; i > 0; i--) {
2239                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
2240                 if (done == FIFO_EMPTY)
2241                         schedule_timeout_uninterruptible(1);
2242                 else
2243                         return done;
2244         }
2245         /* Invalid address to tell caller we ran out of time */
2246         return 1;
2247 }
2248
2249 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2250 {
2251         /* We get in here if sendcmd() is polling for completions
2252            and gets some command back that it wasn't expecting --
2253            something other than that which it just sent down.
2254            Ordinarily, that shouldn't happen, but it can happen when
2255            the scsi tape stuff gets into error handling mode, and
2256            starts using sendcmd() to try to abort commands and
2257            reset tape drives.  In that case, sendcmd may pick up
2258            completions of commands that were sent to logical drives
2259            through the block i/o system, or cciss ioctls completing, etc.
2260            In that case, we need to save those completions for later
2261            processing by the interrupt handler.
2262          */
2263
2264 #ifdef CONFIG_CISS_SCSI_TAPE
2265         struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
2266
2267         /* If it's not the scsi tape stuff doing error handling, (abort */
2268         /* or reset) then we don't expect anything weird. */
2269         if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2270 #endif
2271                 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2272                        "Invalid command list address returned! (%lx)\n",
2273                        ctlr, complete);
2274                 /* not much we can do. */
2275 #ifdef CONFIG_CISS_SCSI_TAPE
2276                 return 1;
2277         }
2278
2279         /* We've sent down an abort or reset, but something else
2280            has completed */
2281         if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
2282                 /* Uh oh.  No room to save it for later... */
2283                 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
2284                        "reject list overflow, command lost!\n", ctlr);
2285                 return 1;
2286         }
2287         /* Save it for later */
2288         srl->complete[srl->ncompletions] = complete;
2289         srl->ncompletions++;
2290 #endif
2291         return 0;
2292 }
2293
2294 /*
2295  * Send a command to the controller, and wait for it to complete.
2296  * Only used at init time.
2297  */
2298 static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
2299                                                                                                    1: address logical volume log_unit,
2300                                                                                                    2: periph device address is scsi3addr */
2301                    unsigned int log_unit,
2302                    __u8 page_code, unsigned char *scsi3addr, int cmd_type)
2303 {
2304         CommandList_struct *c;
2305         int i;
2306         unsigned long complete;
2307         ctlr_info_t *info_p = hba[ctlr];
2308         u64bit buff_dma_handle;
2309         int status, done = 0;
2310
2311         if ((c = cmd_alloc(info_p, 1)) == NULL) {
2312                 printk(KERN_WARNING "cciss: unable to get memory");
2313                 return IO_ERROR;
2314         }
2315         status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
2316                           log_unit, page_code, scsi3addr, cmd_type);
2317         if (status != IO_OK) {
2318                 cmd_free(info_p, c, 1);
2319                 return status;
2320         }
2321       resend_cmd1:
2322         /*
2323          * Disable interrupt
2324          */
2325 #ifdef CCISS_DEBUG
2326         printk(KERN_DEBUG "cciss: turning intr off\n");
2327 #endif                          /* CCISS_DEBUG */
2328         info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2329
2330         /* Make sure there is room in the command FIFO */
2331         /* Actually it should be completely empty at this time */
2332         /* unless we are in here doing error handling for the scsi */
2333         /* tape side of the driver. */
2334         for (i = 200000; i > 0; i--) {
2335                 /* if fifo isn't full go */
2336                 if (!(info_p->access.fifo_full(info_p))) {
2337
2338                         break;
2339                 }
2340                 udelay(10);
2341                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2342                        " waiting!\n", ctlr);
2343         }
2344         /*
2345          * Send the cmd
2346          */
2347         info_p->access.submit_command(info_p, c);
2348         done = 0;
2349         do {
2350                 complete = pollcomplete(ctlr);
2351
2352 #ifdef CCISS_DEBUG
2353                 printk(KERN_DEBUG "cciss: command completed\n");
2354 #endif                          /* CCISS_DEBUG */
2355
2356                 if (complete == 1) {
2357                         printk(KERN_WARNING
2358                                "cciss cciss%d: SendCmd Timeout out, "
2359                                "No command list address returned!\n", ctlr);
2360                         status = IO_ERROR;
2361                         done = 1;
2362                         break;
2363                 }
2364
2365                 /* This will need to change for direct lookup completions */
2366                 if ((complete & CISS_ERROR_BIT)
2367                     && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2368                         /* if data overrun or underun on Report command
2369                            ignore it
2370                          */
2371                         if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2372                              (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2373                              (c->Request.CDB[0] == CISS_INQUIRY)) &&
2374                             ((c->err_info->CommandStatus ==
2375                               CMD_DATA_OVERRUN) ||
2376                              (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2377                             )) {
2378                                 complete = c->busaddr;
2379                         } else {
2380                                 if (c->err_info->CommandStatus ==
2381                                     CMD_UNSOLICITED_ABORT) {
2382                                         printk(KERN_WARNING "cciss%d: "
2383                                                "unsolicited abort %p\n",
2384                                                ctlr, c);
2385                                         if (c->retry_count < MAX_CMD_RETRIES) {
2386                                                 printk(KERN_WARNING
2387                                                        "cciss%d: retrying %p\n",
2388                                                        ctlr, c);
2389                                                 c->retry_count++;
2390                                                 /* erase the old error */
2391                                                 /* information */
2392                                                 memset(c->err_info, 0,
2393                                                        sizeof
2394                                                        (ErrorInfo_struct));
2395                                                 goto resend_cmd1;
2396                                         } else {
2397                                                 printk(KERN_WARNING
2398                                                        "cciss%d: retried %p too "
2399                                                        "many times\n", ctlr, c);
2400                                                 status = IO_ERROR;
2401                                                 goto cleanup1;
2402                                         }
2403                                 } else if (c->err_info->CommandStatus ==
2404                                            CMD_UNABORTABLE) {
2405                                         printk(KERN_WARNING
2406                                                "cciss%d: command could not be aborted.\n",
2407                                                ctlr);
2408                                         status = IO_ERROR;
2409                                         goto cleanup1;
2410                                 }
2411                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2412                                        " Error %x \n", ctlr,
2413                                        c->err_info->CommandStatus);
2414                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2415                                        " offensive info\n"
2416                                        "  size %x\n   num %x   value %x\n",
2417                                        ctlr,
2418                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2419                                        offense_size,
2420                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2421                                        offense_num,
2422                                        c->err_info->MoreErrInfo.Invalid_Cmd.
2423                                        offense_value);
2424                                 status = IO_ERROR;
2425                                 goto cleanup1;
2426                         }
2427                 }
2428                 /* This will need changing for direct lookup completions */
2429                 if (complete != c->busaddr) {
2430                         if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2431                                 BUG();  /* we are pretty much hosed if we get here. */
2432                         }
2433                         continue;
2434                 } else
2435                         done = 1;
2436         } while (!done);
2437
2438       cleanup1:
2439         /* unlock the data buffer from DMA */
2440         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2441         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2442         pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2443                          c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2444 #ifdef CONFIG_CISS_SCSI_TAPE
2445         /* if we saved some commands for later, process them now. */
2446         if (info_p->scsi_rejects.ncompletions > 0)
2447                 do_cciss_intr(0, info_p);
2448 #endif
2449         cmd_free(info_p, c, 1);
2450         return status;
2451 }
2452
2453 /*
2454  * Map (physical) PCI mem into (virtual) kernel space
2455  */
2456 static void __iomem *remap_pci_mem(ulong base, ulong size)
2457 {
2458         ulong page_base = ((ulong) base) & PAGE_MASK;
2459         ulong page_offs = ((ulong) base) - page_base;
2460         void __iomem *page_remapped = ioremap(page_base, page_offs + size);
2461
2462         return page_remapped ? (page_remapped + page_offs) : NULL;
2463 }
2464
2465 /*
2466  * Takes jobs of the Q and sends them to the hardware, then puts it on
2467  * the Q to wait for completion.
2468  */
2469 static void start_io(ctlr_info_t *h)
2470 {
2471         CommandList_struct *c;
2472
2473         while ((c = h->reqQ) != NULL) {
2474                 /* can't do anything if fifo is full */
2475                 if ((h->access.fifo_full(h))) {
2476                         printk(KERN_WARNING "cciss: fifo full\n");
2477                         break;
2478                 }
2479
2480                 /* Get the first entry from the Request Q */
2481                 removeQ(&(h->reqQ), c);
2482                 h->Qdepth--;
2483
2484                 /* Tell the controller execute command */
2485                 h->access.submit_command(h, c);
2486
2487                 /* Put job onto the completed Q */
2488                 addQ(&(h->cmpQ), c);
2489         }
2490 }
2491
2492 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2493 /* Zeros out the error record and then resends the command back */
2494 /* to the controller */
2495 static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
2496 {
2497         /* erase the old error information */
2498         memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2499
2500         /* add it to software queue and then send it to the controller */
2501         addQ(&(h->reqQ), c);
2502         h->Qdepth++;
2503         if (h->Qdepth > h->maxQsinceinit)
2504                 h->maxQsinceinit = h->Qdepth;
2505
2506         start_io(h);
2507 }
2508
2509 static inline unsigned int make_status_bytes(unsigned int scsi_status_byte,
2510         unsigned int msg_byte, unsigned int host_byte,
2511         unsigned int driver_byte)
2512 {
2513         /* inverse of macros in scsi.h */
2514         return (scsi_status_byte & 0xff) |
2515                 ((msg_byte & 0xff) << 8) |
2516                 ((host_byte & 0xff) << 16) |
2517                 ((driver_byte & 0xff) << 24);
2518 }
2519
2520 static inline int evaluate_target_status(CommandList_struct *cmd)
2521 {
2522         unsigned char sense_key;
2523         unsigned char status_byte, msg_byte, host_byte, driver_byte;
2524         int error_value;
2525
2526         /* If we get in here, it means we got "target status", that is, scsi status */
2527         status_byte = cmd->err_info->ScsiStatus;
2528         driver_byte = DRIVER_OK;
2529         msg_byte = cmd->err_info->CommandStatus; /* correct?  seems too device specific */
2530
2531         if (blk_pc_request(cmd->rq))
2532                 host_byte = DID_PASSTHROUGH;
2533         else
2534                 host_byte = DID_OK;
2535
2536         error_value = make_status_bytes(status_byte, msg_byte,
2537                 host_byte, driver_byte);
2538
2539         if (cmd->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION) {
2540                 if (!blk_pc_request(cmd->rq))
2541                         printk(KERN_WARNING "cciss: cmd %p "
2542                                "has SCSI Status 0x%x\n",
2543                                cmd, cmd->err_info->ScsiStatus);
2544                 return error_value;
2545         }
2546
2547         /* check the sense key */
2548         sense_key = 0xf & cmd->err_info->SenseInfo[2];
2549         /* no status or recovered error */
2550         if (((sense_key == 0x0) || (sense_key == 0x1)) && !blk_pc_request(cmd->rq))
2551                 error_value = 0;
2552
2553         if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
2554                 if (error_value != 0)
2555                         printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2556                                " sense key = 0x%x\n", cmd, sense_key);
2557                 return error_value;
2558         }
2559
2560         /* SG_IO or similar, copy sense data back */
2561         if (cmd->rq->sense) {
2562                 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2563                         cmd->rq->sense_len = cmd->err_info->SenseLen;
2564                 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2565                         cmd->rq->sense_len);
2566         } else
2567                 cmd->rq->sense_len = 0;
2568
2569         return error_value;
2570 }
2571
2572 /* checks the status of the job and calls complete buffers to mark all
2573  * buffers for the completed job. Note that this function does not need
2574  * to hold the hba/queue lock.
2575  */
2576 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2577                                     int timeout)
2578 {
2579         int retry_cmd = 0;
2580         struct request *rq = cmd->rq;
2581
2582         rq->errors = 0;
2583
2584         if (timeout)
2585                 rq->errors = make_status_bytes(0, 0, 0, DRIVER_TIMEOUT);
2586
2587         if (cmd->err_info->CommandStatus == 0)  /* no error has occurred */
2588                 goto after_error_processing;
2589
2590         switch (cmd->err_info->CommandStatus) {
2591         case CMD_TARGET_STATUS:
2592                 rq->errors = evaluate_target_status(cmd);
2593                 break;
2594         case CMD_DATA_UNDERRUN:
2595                 if (blk_fs_request(cmd->rq)) {
2596                         printk(KERN_WARNING "cciss: cmd %p has"
2597                                " completed with data underrun "
2598                                "reported\n", cmd);
2599                         cmd->rq->data_len = cmd->err_info->ResidualCnt;
2600                 }
2601                 break;
2602         case CMD_DATA_OVERRUN:
2603                 if (blk_fs_request(cmd->rq))
2604                         printk(KERN_WARNING "cciss: cmd %p has"
2605                                " completed with data overrun "
2606                                "reported\n", cmd);
2607                 break;
2608         case CMD_INVALID:
2609                 printk(KERN_WARNING "cciss: cmd %p is "
2610                        "reported invalid\n", cmd);
2611                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2612                         cmd->err_info->CommandStatus, DRIVER_OK,
2613                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2614                 break;
2615         case CMD_PROTOCOL_ERR:
2616                 printk(KERN_WARNING "cciss: cmd %p has "
2617                        "protocol error \n", cmd);
2618                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2619                         cmd->err_info->CommandStatus, DRIVER_OK,
2620                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2621                 break;
2622         case CMD_HARDWARE_ERR:
2623                 printk(KERN_WARNING "cciss: cmd %p had "
2624                        " hardware error\n", cmd);
2625                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2626                         cmd->err_info->CommandStatus, DRIVER_OK,
2627                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2628                 break;
2629         case CMD_CONNECTION_LOST:
2630                 printk(KERN_WARNING "cciss: cmd %p had "
2631                        "connection lost\n", cmd);
2632                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2633                         cmd->err_info->CommandStatus, DRIVER_OK,
2634                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2635                 break;
2636         case CMD_ABORTED:
2637                 printk(KERN_WARNING "cciss: cmd %p was "
2638                        "aborted\n", cmd);
2639                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2640                         cmd->err_info->CommandStatus, DRIVER_OK,
2641                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2642                 break;
2643         case CMD_ABORT_FAILED:
2644                 printk(KERN_WARNING "cciss: cmd %p reports "
2645                        "abort failed\n", cmd);
2646                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2647                         cmd->err_info->CommandStatus, DRIVER_OK,
2648                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2649                 break;
2650         case CMD_UNSOLICITED_ABORT:
2651                 printk(KERN_WARNING "cciss%d: unsolicited "
2652                        "abort %p\n", h->ctlr, cmd);
2653                 if (cmd->retry_count < MAX_CMD_RETRIES) {
2654                         retry_cmd = 1;
2655                         printk(KERN_WARNING
2656                                "cciss%d: retrying %p\n", h->ctlr, cmd);
2657                         cmd->retry_count++;
2658                 } else
2659                         printk(KERN_WARNING
2660                                "cciss%d: %p retried too "
2661                                "many times\n", h->ctlr, cmd);
2662                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2663                         cmd->err_info->CommandStatus, DRIVER_OK,
2664                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ABORT);
2665                 break;
2666         case CMD_TIMEOUT:
2667                 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
2668                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2669                         cmd->err_info->CommandStatus, DRIVER_OK,
2670                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2671                 break;
2672         default:
2673                 printk(KERN_WARNING "cciss: cmd %p returned "
2674                        "unknown status %x\n", cmd,
2675                        cmd->err_info->CommandStatus);
2676                 rq->errors = make_status_bytes(SAM_STAT_GOOD,
2677                         cmd->err_info->CommandStatus, DRIVER_OK,
2678                         blk_pc_request(cmd->rq) ? DID_PASSTHROUGH : DID_ERROR);
2679         }
2680
2681 after_error_processing:
2682
2683         /* We need to return this command */
2684         if (retry_cmd) {
2685                 resend_cciss_cmd(h, cmd);
2686                 return;
2687         }
2688         cmd->rq->completion_data = cmd;
2689         blk_complete_request(cmd->rq);
2690 }
2691
2692 /*
2693  * Get a request and submit it to the controller.
2694  */
2695 static void do_cciss_request(struct request_queue *q)
2696 {
2697         ctlr_info_t *h = q->queuedata;
2698         CommandList_struct *c;
2699         sector_t start_blk;
2700         int seg;
2701         struct request *creq;
2702         u64bit temp64;
2703         struct scatterlist tmp_sg[MAXSGENTRIES];
2704         drive_info_struct *drv;
2705         int i, dir;
2706
2707         /* We call start_io here in case there is a command waiting on the
2708          * queue that has not been sent.
2709          */
2710         if (blk_queue_plugged(q))
2711                 goto startio;
2712
2713       queue:
2714         creq = elv_next_request(q);
2715         if (!creq)
2716                 goto startio;
2717
2718         BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
2719
2720         if ((c = cmd_alloc(h, 1)) == NULL)
2721                 goto full;
2722
2723         blkdev_dequeue_request(creq);
2724
2725         spin_unlock_irq(q->queue_lock);
2726
2727         c->cmd_type = CMD_RWREQ;
2728         c->rq = creq;
2729
2730         /* fill in the request */
2731         drv = creq->rq_disk->private_data;
2732         c->Header.ReplyQueue = 0;       // unused in simple mode
2733         /* got command from pool, so use the command block index instead */
2734         /* for direct lookups. */
2735         /* The first 2 bits are reserved for controller error reporting. */
2736         c->Header.Tag.lower = (c->cmdindex << 3);
2737         c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
2738         c->Header.LUN.LogDev.VolId = drv->LunID;
2739         c->Header.LUN.LogDev.Mode = 1;
2740         c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2741         c->Request.Type.Type = TYPE_CMD;        // It is a command.
2742         c->Request.Type.Attribute = ATTR_SIMPLE;
2743         c->Request.Type.Direction =
2744             (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
2745         c->Request.Timeout = 0; // Don't time out
2746         c->Request.CDB[0] =
2747             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
2748         start_blk = creq->sector;
2749 #ifdef CCISS_DEBUG
2750         printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2751                (int)creq->nr_sectors);
2752 #endif                          /* CCISS_DEBUG */
2753
2754         sg_init_table(tmp_sg, MAXSGENTRIES);
2755         seg = blk_rq_map_sg(q, creq, tmp_sg);
2756
2757         /* get the DMA records for the setup */
2758         if (c->Request.Type.Direction == XFER_READ)
2759                 dir = PCI_DMA_FROMDEVICE;
2760         else
2761                 dir = PCI_DMA_TODEVICE;
2762
2763         for (i = 0; i < seg; i++) {
2764                 c->SG[i].Len = tmp_sg[i].length;
2765                 temp64.val = (__u64) pci_map_page(h->pdev, sg_page(&tmp_sg[i]),
2766                                                   tmp_sg[i].offset,
2767                                                   tmp_sg[i].length, dir);
2768                 c->SG[i].Addr.lower = temp64.val32.lower;
2769                 c->SG[i].Addr.upper = temp64.val32.upper;
2770                 c->SG[i].Ext = 0;       // we are not chaining
2771         }
2772         /* track how many SG entries we are using */
2773         if (seg > h->maxSG)
2774                 h->maxSG = seg;
2775
2776 #ifdef CCISS_DEBUG
2777         printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2778                creq->nr_sectors, seg);
2779 #endif                          /* CCISS_DEBUG */
2780
2781         c->Header.SGList = c->Header.SGTotal = seg;
2782         if (likely(blk_fs_request(creq))) {
2783                 if(h->cciss_read == CCISS_READ_10) {
2784                         c->Request.CDB[1] = 0;
2785                         c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
2786                         c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2787                         c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2788                         c->Request.CDB[5] = start_blk & 0xff;
2789                         c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
2790                         c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2791                         c->Request.CDB[8] = creq->nr_sectors & 0xff;
2792                         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2793                 } else {
2794                         u32 upper32 = upper_32_bits(start_blk);
2795
2796                         c->Request.CDBLen = 16;
2797                         c->Request.CDB[1]= 0;
2798                         c->Request.CDB[2]= (upper32 >> 24) & 0xff;      //MSB
2799                         c->Request.CDB[3]= (upper32 >> 16) & 0xff;
2800                         c->Request.CDB[4]= (upper32 >>  8) & 0xff;
2801                         c->Request.CDB[5]= upper32 & 0xff;
2802                         c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2803                         c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2804                         c->Request.CDB[8]= (start_blk >>  8) & 0xff;
2805                         c->Request.CDB[9]= start_blk & 0xff;
2806                         c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
2807                         c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
2808                         c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
2809                         c->Request.CDB[13]= creq->nr_sectors & 0xff;
2810                         c->Request.CDB[14] = c->Request.CDB[15] = 0;
2811                 }
2812         } else if (blk_pc_request(creq)) {
2813                 c->Request.CDBLen = creq->cmd_len;
2814                 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
2815         } else {
2816                 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2817                 BUG();
2818         }
2819
2820         spin_lock_irq(q->queue_lock);
2821
2822         addQ(&(h->reqQ), c);
2823         h->Qdepth++;
2824         if (h->Qdepth > h->maxQsinceinit)
2825                 h->maxQsinceinit = h->Qdepth;
2826
2827         goto queue;
2828 full:
2829         blk_stop_queue(q);
2830 startio:
2831         /* We will already have the driver lock here so not need
2832          * to lock it.
2833          */
2834         start_io(h);
2835 }
2836
2837 static inline unsigned long get_next_completion(ctlr_info_t *h)
2838 {
2839 #ifdef CONFIG_CISS_SCSI_TAPE
2840         /* Any rejects from sendcmd() lying around? Process them first */
2841         if (h->scsi_rejects.ncompletions == 0)
2842                 return h->access.command_completed(h);
2843         else {
2844                 struct sendcmd_reject_list *srl;
2845                 int n;
2846                 srl = &h->scsi_rejects;
2847                 n = --srl->ncompletions;
2848                 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2849                 printk("p");
2850                 return srl->complete[n];
2851         }
2852 #else
2853         return h->access.command_completed(h);
2854 #endif
2855 }
2856
2857 static inline int interrupt_pending(ctlr_info_t *h)
2858 {
2859 #ifdef CONFIG_CISS_SCSI_TAPE
2860         return (h->access.intr_pending(h)
2861                 || (h->scsi_rejects.ncompletions > 0));
2862 #else
2863         return h->access.intr_pending(h);
2864 #endif
2865 }
2866
2867 static inline long interrupt_not_for_us(ctlr_info_t *h)
2868 {
2869 #ifdef CONFIG_CISS_SCSI_TAPE
2870         return (((h->access.intr_pending(h) == 0) ||
2871                  (h->interrupts_enabled == 0))
2872                 && (h->scsi_rejects.ncompletions == 0));
2873 #else
2874         return (((h->access.intr_pending(h) == 0) ||
2875                  (h->interrupts_enabled == 0)));
2876 #endif
2877 }
2878
2879 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
2880 {
2881         ctlr_info_t *h = dev_id;
2882         CommandList_struct *c;
2883         unsigned long flags;
2884         __u32 a, a1, a2;
2885
2886         if (interrupt_not_for_us(h))
2887                 return IRQ_NONE;
2888         /*
2889          * If there are completed commands in the completion queue,
2890          * we had better do something about it.
2891          */
2892         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2893         while (interrupt_pending(h)) {
2894                 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
2895                         a1 = a;
2896                         if ((a & 0x04)) {
2897                                 a2 = (a >> 3);
2898                                 if (a2 >= h->nr_cmds) {
2899                                         printk(KERN_WARNING
2900                                                "cciss: controller cciss%d failed, stopping.\n",
2901                                                h->ctlr);
2902                                         fail_all_cmds(h->ctlr);
2903                                         return IRQ_HANDLED;
2904                                 }
2905
2906                                 c = h->cmd_pool + a2;
2907                                 a = c->busaddr;
2908
2909                         } else {
2910                                 a &= ~3;
2911                                 if ((c = h->cmpQ) == NULL) {
2912                                         printk(KERN_WARNING
2913                                                "cciss: Completion of %08x ignored\n",
2914                                                a1);
2915                                         continue;
2916                                 }
2917                                 while (c->busaddr != a) {
2918                                         c = c->next;
2919                                         if (c == h->cmpQ)
2920                                                 break;
2921                                 }
2922                         }
2923                         /*
2924                          * If we've found the command, take it off the
2925                          * completion Q and free it
2926                          */
2927                         if (c->busaddr == a) {
2928                                 removeQ(&h->cmpQ, c);
2929                                 if (c->cmd_type == CMD_RWREQ) {
2930                                         complete_command(h, c, 0);
2931                                 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2932                                         complete(c->waiting);
2933                                 }
2934 #                               ifdef CONFIG_CISS_SCSI_TAPE
2935                                 else if (c->cmd_type == CMD_SCSI)
2936                                         complete_scsi_command(c, 0, a1);
2937 #                               endif
2938                                 continue;
2939                         }
2940                 }
2941         }
2942
2943         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2944         return IRQ_HANDLED;
2945 }
2946
2947 /*
2948  *  We cannot read the structure directly, for portability we must use
2949  *   the io functions.
2950  *   This is for debug only.
2951  */
2952 #ifdef CCISS_DEBUG
2953 static void print_cfg_table(CfgTable_struct *tb)
2954 {
2955         int i;
2956         char temp_name[17];
2957
2958         printk("Controller Configuration information\n");
2959         printk("------------------------------------\n");
2960         for (i = 0; i < 4; i++)
2961                 temp_name[i] = readb(&(tb->Signature[i]));
2962         temp_name[4] = '\0';
2963         printk("   Signature = %s\n", temp_name);
2964         printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
2965         printk("   Transport methods supported = 0x%x\n",
2966                readl(&(tb->TransportSupport)));
2967         printk("   Transport methods active = 0x%x\n",
2968                readl(&(tb->TransportActive)));
2969         printk("   Requested transport Method = 0x%x\n",
2970                readl(&(tb->HostWrite.TransportRequest)));
2971         printk("   Coalesce Interrupt Delay = 0x%x\n",
2972                readl(&(tb->HostWrite.CoalIntDelay)));
2973         printk("   Coalesce Interrupt Count = 0x%x\n",
2974                readl(&(tb->HostWrite.CoalIntCount)));
2975         printk("   Max outstanding commands = 0x%d\n",
2976                readl(&(tb->CmdsOutMax)));
2977         printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2978         for (i = 0; i < 16; i++)
2979                 temp_name[i] = readb(&(tb->ServerName[i]));
2980         temp_name[16] = '\0';
2981         printk("   Server Name = %s\n", temp_name);
2982         printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
2983 }
2984 #endif                          /* CCISS_DEBUG */
2985
2986 static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
2987 {
2988         int i, offset, mem_type, bar_type;
2989         if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2990                 return 0;
2991         offset = 0;
2992         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2993                 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
2994                 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2995                         offset += 4;
2996                 else {
2997                         mem_type = pci_resource_flags(pdev, i) &
2998                             PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2999                         switch (mem_type) {
3000                         case PCI_BASE_ADDRESS_MEM_TYPE_32:
3001                         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
3002                                 offset += 4;    /* 32 bit */
3003                                 break;
3004                         case PCI_BASE_ADDRESS_MEM_TYPE_64:
3005                                 offset += 8;
3006                                 break;
3007                         default:        /* reserved in PCI 2.2 */
3008                                 printk(KERN_WARNING
3009                                        "Base address is invalid\n");
3010                                 return -1;
3011                                 break;
3012                         }
3013                 }
3014                 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
3015                         return i + 1;
3016         }
3017         return -1;
3018 }
3019
3020 /* If MSI/MSI-X is supported by the kernel we will try to enable it on
3021  * controllers that are capable. If not, we use IO-APIC mode.
3022  */
3023
3024 static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
3025                                            struct pci_dev *pdev, __u32 board_id)
3026 {
3027 #ifdef CONFIG_PCI_MSI
3028         int err;
3029         struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
3030         {0, 2}, {0, 3}
3031         };
3032
3033         /* Some boards advertise MSI but don't really support it */
3034         if ((board_id == 0x40700E11) ||
3035             (board_id == 0x40800E11) ||
3036             (board_id == 0x40820E11) || (board_id == 0x40830E11))
3037                 goto default_int_mode;
3038
3039         if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
3040                 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
3041                 if (!err) {
3042                         c->intr[0] = cciss_msix_entries[0].vector;
3043                         c->intr[1] = cciss_msix_entries[1].vector;
3044                         c->intr[2] = cciss_msix_entries[2].vector;
3045                         c->intr[3] = cciss_msix_entries[3].vector;
3046                         c->msix_vector = 1;
3047                         return;
3048                 }
3049                 if (err > 0) {
3050                         printk(KERN_WARNING "cciss: only %d MSI-X vectors "
3051                                "available\n", err);
3052                         goto default_int_mode;
3053                 } else {
3054                         printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
3055                                err);
3056                         goto default_int_mode;
3057                 }
3058         }
3059         if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
3060                 if (!pci_enable_msi(pdev)) {
3061                         c->msi_vector = 1;
3062                 } else {
3063                         printk(KERN_WARNING "cciss: MSI init failed\n");
3064                 }
3065         }
3066 default_int_mode:
3067 #endif                          /* CONFIG_PCI_MSI */
3068         /* if we get here we're going to use the default interrupt mode */
3069         c->intr[SIMPLE_MODE_INT] = pdev->irq;
3070         return;
3071 }
3072
3073 static int __devinit cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
3074 {
3075         ushort subsystem_vendor_id, subsystem_device_id, command;
3076         __u32 board_id, scratchpad = 0;
3077         __u64 cfg_offset;
3078         __u32 cfg_base_addr;
3079         __u64 cfg_base_addr_index;
3080         int i, err;
3081
3082         /* check to see if controller has been disabled */
3083         /* BEFORE trying to enable it */
3084         (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
3085         if (!(command & 0x02)) {
3086                 printk(KERN_WARNING
3087                        "cciss: controller appears to be disabled\n");
3088                 return -ENODEV;
3089         }
3090
3091         err = pci_enable_device(pdev);
3092         if (err) {
3093                 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
3094                 return err;
3095         }
3096
3097         err = pci_request_regions(pdev, "cciss");
3098         if (err) {
3099                 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
3100                        "aborting\n");
3101                 return err;
3102         }
3103
3104         subsystem_vendor_id = pdev->subsystem_vendor;
3105         subsystem_device_id = pdev->subsystem_device;
3106         board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
3107                     subsystem_vendor_id);
3108
3109 #ifdef CCISS_DEBUG
3110         printk("command = %x\n", command);
3111         printk("irq = %x\n", pdev->irq);
3112         printk("board_id = %x\n", board_id);
3113 #endif                          /* CCISS_DEBUG */
3114
3115 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
3116  * else we use the IO-APIC interrupt assigned to us by system ROM.
3117  */
3118         cciss_interrupt_mode(c, pdev, board_id);
3119
3120         /*
3121          * Memory base addr is first addr , the second points to the config
3122          *   table
3123          */
3124
3125         c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
3126 #ifdef CCISS_DEBUG
3127         printk("address 0 = %x\n", c->paddr);
3128 #endif                          /* CCISS_DEBUG */
3129         c->vaddr = remap_pci_mem(c->paddr, 0x250);
3130
3131         /* Wait for the board to become ready.  (PCI hotplug needs this.)
3132          * We poll for up to 120 secs, once per 100ms. */
3133         for (i = 0; i < 1200; i++) {
3134                 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
3135                 if (scratchpad == CCISS_FIRMWARE_READY)
3136                         break;
3137                 set_current_state(TASK_INTERRUPTIBLE);
3138                 schedule_timeout(HZ / 10);      /* wait 100ms */
3139         }
3140         if (scratchpad != CCISS_FIRMWARE_READY) {
3141                 printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
3142                 err = -ENODEV;
3143                 goto err_out_free_res;
3144         }
3145
3146         /* get the address index number */
3147         cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
3148         cfg_base_addr &= (__u32) 0x0000ffff;
3149 #ifdef CCISS_DEBUG
3150         printk("cfg base address = %x\n", cfg_base_addr);
3151 #endif                          /* CCISS_DEBUG */
3152         cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
3153 #ifdef CCISS_DEBUG
3154         printk("cfg base address index = %x\n", cfg_base_addr_index);
3155 #endif                          /* CCISS_DEBUG */
3156         if (cfg_base_addr_index == -1) {
3157                 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
3158                 err = -ENODEV;
3159                 goto err_out_free_res;
3160         }
3161
3162         cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
3163 #ifdef CCISS_DEBUG
3164         printk("cfg offset = %x\n", cfg_offset);
3165 #endif                          /* CCISS_DEBUG */
3166         c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
3167                                                        cfg_base_addr_index) +
3168                                     cfg_offset, sizeof(CfgTable_struct));
3169         c->board_id = board_id;
3170
3171 #ifdef CCISS_DEBUG
3172         print_cfg_table(c->cfgtable);
3173 #endif                          /* CCISS_DEBUG */
3174
3175         /* Some controllers support Zero Memory Raid (ZMR).
3176          * When configured in ZMR mode the number of supported
3177          * commands drops to 64. So instead of just setting an
3178          * arbitrary value we make the driver a little smarter.
3179          * We read the config table to tell us how many commands
3180          * are supported on the controller then subtract 4 to
3181          * leave a little room for ioctl calls.
3182          */
3183         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3184         for (i = 0; i < ARRAY_SIZE(products); i++) {
3185                 if (board_id == products[i].board_id) {
3186                         c->product_name = products[i].product_name;
3187                         c->access = *(products[i].access);
3188                         c->nr_cmds = c->max_commands - 4;
3189                         break;
3190                 }
3191         }
3192         if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3193             (readb(&c->cfgtable->Signature[1]) != 'I') ||
3194             (readb(&c->cfgtable->Signature[2]) != 'S') ||
3195             (readb(&c->cfgtable->Signature[3]) != 'S')) {
3196                 printk("Does not appear to be a valid CISS config table\n");
3197                 err = -ENODEV;
3198                 goto err_out_free_res;
3199         }
3200         /* We didn't find the controller in our list. We know the
3201          * signature is valid. If it's an HP device let's try to
3202          * bind to the device and fire it up. Otherwise we bail.
3203          */
3204         if (i == ARRAY_SIZE(products)) {
3205                 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3206                         c->product_name = products[i-1].product_name;
3207                         c->access = *(products[i-1].access);
3208                         c->nr_cmds = c->max_commands - 4;
3209                         printk(KERN_WARNING "cciss: This is an unknown "
3210                                 "Smart Array controller.\n"
3211                                 "cciss: Please update to the latest driver "
3212                                 "available from www.hp.com.\n");
3213                 } else {
3214                         printk(KERN_WARNING "cciss: Sorry, I don't know how"
3215                                 " to access the Smart Array controller %08lx\n"
3216                                         , (unsigned long)board_id);
3217                         err = -ENODEV;
3218                         goto err_out_free_res;
3219                 }
3220         }
3221 #ifdef CONFIG_X86
3222         {
3223                 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3224                 __u32 prefetch;
3225                 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3226                 prefetch |= 0x100;
3227                 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3228         }
3229 #endif
3230
3231         /* Disabling DMA prefetch and refetch for the P600.
3232          * An ASIC bug may result in accesses to invalid memory addresses.
3233          * We've disabled prefetch for some time now. Testing with XEN
3234          * kernels revealed a bug in the refetch if dom0 resides on a P600.
3235          */
3236         if(board_id == 0x3225103C) {
3237                 __u32 dma_prefetch;
3238                 __u32 dma_refetch;
3239                 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3240                 dma_prefetch |= 0x8000;
3241                 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3242                 pci_read_config_dword(pdev, PCI_COMMAND_PARITY, &dma_refetch);
3243                 dma_refetch |= 0x1;
3244                 pci_write_config_dword(pdev, PCI_COMMAND_PARITY, dma_refetch);
3245         }
3246
3247 #ifdef CCISS_DEBUG
3248         printk("Trying to put board into Simple mode\n");
3249 #endif                          /* CCISS_DEBUG */
3250         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
3251         /* Update the field, and then ring the doorbell */
3252         writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3253         writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
3254
3255         /* under certain very rare conditions, this can take awhile.
3256          * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3257          * as we enter this code.) */
3258         for (i = 0; i < MAX_CONFIG_WAIT; i++) {
3259                 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3260                         break;
3261                 /* delay and try again */
3262                 set_current_state(TASK_INTERRUPTIBLE);
3263                 schedule_timeout(10);
3264         }
3265
3266 #ifdef CCISS_DEBUG
3267         printk(KERN_DEBUG "I counter got to %d %x\n", i,
3268                readl(c->vaddr + SA5_DOORBELL));
3269 #endif                          /* CCISS_DEBUG */
3270 #ifdef CCISS_DEBUG
3271         print_cfg_table(c->cfgtable);
3272 #endif                          /* CCISS_DEBUG */
3273
3274         if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
3275                 printk(KERN_WARNING "cciss: unable to get board into"
3276                        " simple mode\n");
3277                 err = -ENODEV;
3278                 goto err_out_free_res;
3279         }
3280         return 0;
3281
3282 err_out_free_res:
3283         /*
3284          * Deliberately omit pci_disable_device(): it does something nasty to
3285          * Smart Array controllers that pci_enable_device does not undo
3286          */
3287         pci_release_regions(pdev);
3288         return err;
3289 }
3290
3291 /*
3292  * Gets information about the local volumes attached to the controller.
3293  */
3294 static void cciss_getgeometry(int cntl_num)
3295 {
3296         ReportLunData_struct *ld_buff;
3297         InquiryData_struct *inq_buff;
3298         int return_code;
3299         int i;
3300         int listlength = 0;
3301         __u32 lunid = 0;
3302         unsigned block_size;
3303         sector_t total_size;
3304
3305         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
3306         if (ld_buff == NULL) {
3307                 printk(KERN_ERR "cciss: out of memory\n");
3308                 return;
3309         }
3310         inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3311         if (inq_buff == NULL) {
3312                 printk(KERN_ERR "cciss: out of memory\n");
3313                 kfree(ld_buff);
3314                 return;
3315         }
3316         /* Get the firmware version */
3317         return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3318                               sizeof(InquiryData_struct), 0, 0, 0, NULL,
3319                               TYPE_CMD);
3320         if (return_code == IO_OK) {
3321                 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3322                 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3323                 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3324                 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
3325         } else {                /* send command failed */
3326
3327                 printk(KERN_WARNING "cciss: unable to determine firmware"
3328                        " version of controller\n");
3329         }
3330         /* Get the number of logical volumes */
3331         return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3332                               sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3333                               TYPE_CMD);
3334
3335         if (return_code == IO_OK) {
3336 #ifdef CCISS_DEBUG
3337                 printk("LUN Data\n--------------------------\n");
3338 #endif                          /* CCISS_DEBUG */
3339
3340                 listlength |=
3341                     (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3342                 listlength |=
3343                     (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3344                 listlength |=
3345                     (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
3346                 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
3347         } else {                /* reading number of logical volumes failed */
3348
3349                 printk(KERN_WARNING "cciss: report logical volume"
3350                        " command failed\n");
3351                 listlength = 0;
3352         }
3353         hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
3354         if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3355                 printk(KERN_ERR
3356                        "ciss:  only %d number of logical volumes supported\n",
3357                        CISS_MAX_LUN);
3358                 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3359         }
3360 #ifdef CCISS_DEBUG
3361         printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3362                ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3363                ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3364                hba[cntl_num]->num_luns);
3365 #endif                          /* CCISS_DEBUG */
3366
3367         hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
3368         for (i = 0; i < CISS_MAX_LUN; i++) {
3369                 if (i < hba[cntl_num]->num_luns) {
3370                         lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3371                             << 24;
3372                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3373                             << 16;
3374                         lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3375                             << 8;
3376                         lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
3377
3378                         hba[cntl_num]->drv[i].LunID = lunid;
3379
3380 #ifdef CCISS_DEBUG
3381                         printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
3382                                ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3383                                ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3384                                hba[cntl_num]->drv[i].LunID);
3385 #endif                          /* CCISS_DEBUG */
3386
3387                 /* testing to see if 16-byte CDBs are already being used */
3388                 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3389                         cciss_read_capacity_16(cntl_num, i, 0,
3390                                             &total_size, &block_size);
3391                         goto geo_inq;
3392                 }
3393                 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3394
3395                 /* If read_capacity returns all F's the logical is >2TB */
3396                 /* so we switch to 16-byte CDBs for all read/write ops */
3397                 if(total_size == 0xFFFFFFFFULL) {
3398                         cciss_read_capacity_16(cntl_num, i, 0,
3399                         &total_size, &block_size);
3400                         hba[cntl_num]->cciss_read = CCISS_READ_16;
3401                         hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3402                 } else {
3403                         hba[cntl_num]->cciss_read = CCISS_READ_10;
3404                         hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3405                 }
3406 geo_inq:
3407                         cciss_geometry_inquiry(cntl_num, i, 0, total_size,
3408                                                block_size, inq_buff,
3409                                                &hba[cntl_num]->drv[i]);
3410                         cciss_get_serial_no(cntl_num, i, 0,
3411                                 hba[cntl_num]->drv[i].serial_no,
3412                                 sizeof(hba[cntl_num]->drv[i].serial_no));
3413                 } else {
3414                         /* initialize raid_level to indicate a free space */
3415                         hba[cntl_num]->drv[i].raid_level = -1;
3416                 }
3417         }
3418         kfree(ld_buff);
3419         kfree(inq_buff);
3420 }
3421
3422 /* Function to find the first free pointer into our hba[] array */
3423 /* Returns -1 if no free entries are left.  */
3424 static int alloc_cciss_hba(void)
3425 {
3426         int i;
3427
3428         for (i = 0; i < MAX_CTLR; i++) {
3429                 if (!hba[i]) {
3430                         ctlr_info_t *p;
3431
3432                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
3433                         if (!p)
3434                                 goto Enomem;
3435                         p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
3436                         if (!p->gendisk[0]) {
3437                                 kfree(p);
3438                                 goto Enomem;
3439                         }
3440                         hba[i] = p;
3441                         return i;
3442                 }
3443         }
3444         printk(KERN_WARNING "cciss: This driver supports a maximum"
3445                " of %d controllers.\n", MAX_CTLR);
3446         return -1;
3447 Enomem:
3448         printk(KERN_ERR "cciss: out of memory.\n");
3449         return -1;
3450 }
3451
3452 static void free_hba(int i)
3453 {
3454         ctlr_info_t *p = hba[i];
3455         int n;
3456
3457         hba[i] = NULL;
3458         for (n = 0; n < CISS_MAX_LUN; n++)
3459                 put_disk(p->gendisk[n]);
3460         kfree(p);
3461 }
3462
3463 /*
3464  *  This is it.  Find all the controllers and register them.  I really hate
3465  *  stealing all these major device numbers.
3466  *  returns the number of block devices registered.
3467  */
3468 static int __devinit cciss_init_one(struct pci_dev *pdev,
3469                                     const struct pci_device_id *ent)
3470 {
3471         int i;
3472         int j = 0;
3473         int rc;
3474         int dac;
3475
3476         i = alloc_cciss_hba();
3477         if (i < 0)
3478                 return -1;
3479
3480         hba[i]->busy_initializing = 1;
3481
3482         if (cciss_pci_init(hba[i], pdev) != 0)
3483                 goto clean1;
3484
3485         sprintf(hba[i]->devname, "cciss%d", i);
3486         hba[i]->ctlr = i;
3487         hba[i]->pdev = pdev;
3488
3489         /* configure PCI DMA stuff */
3490         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3491                 dac = 1;
3492         else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3493                 dac = 0;
3494         else {
3495                 printk(KERN_ERR "cciss: no suitable DMA available\n");
3496                 goto clean1;
3497         }
3498
3499         /*
3500          * register with the major number, or get a dynamic major number
3501          * by passing 0 as argument.  This is done for greater than
3502          * 8 controller support.
3503          */
3504         if (i < MAX_CTLR_ORIG)
3505                 hba[i]->major = COMPAQ_CISS_MAJOR + i;
3506         rc = register_blkdev(hba[i]->major, hba[i]->devname);
3507         if (rc == -EBUSY || rc == -EINVAL) {
3508                 printk(KERN_ERR
3509                        "cciss:  Unable to get major number %d for %s "
3510                        "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3511                 goto clean1;
3512         } else {
3513                 if (i >= MAX_CTLR_ORIG)
3514                         hba[i]->major = rc;
3515         }
3516
3517         /* make sure the board interrupts are off */
3518         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3519         if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
3520                         IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
3521                 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3522                        hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
3523                 goto clean2;
3524         }
3525
3526         printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
3527                hba[i]->devname, pdev->device, pci_name(pdev),
3528                hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
3529
3530         hba[i]->cmd_pool_bits =
3531             kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
3532                       1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3533         hba[i]->cmd_pool = (CommandList_struct *)
3534             pci_alloc_consistent(hba[i]->pdev,
3535                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3536                     &(hba[i]->cmd_pool_dhandle));
3537         hba[i]->errinfo_pool = (ErrorInfo_struct *)
3538             pci_alloc_consistent(hba[i]->pdev,
3539                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3540                     &(hba[i]->errinfo_pool_dhandle));
3541         if ((hba[i]->cmd_pool_bits == NULL)
3542             || (hba[i]->cmd_pool == NULL)
3543             || (hba[i]->errinfo_pool == NULL)) {
3544                 printk(KERN_ERR "cciss: out of memory");
3545                 goto clean4;
3546         }
3547 #ifdef CONFIG_CISS_SCSI_TAPE
3548         hba[i]->scsi_rejects.complete =
3549             kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3550                     (hba[i]->nr_cmds + 5), GFP_KERNEL);
3551         if (hba[i]->scsi_rejects.complete == NULL) {
3552                 printk(KERN_ERR "cciss: out of memory");
3553                 goto clean4;
3554         }
3555 #endif
3556         spin_lock_init(&hba[i]->lock);
3557
3558         /* Initialize the pdev driver private data.
3559            have it point to hba[i].  */
3560         pci_set_drvdata(pdev, hba[i]);
3561         /* command and error info recs zeroed out before
3562            they are used */
3563         memset(hba[i]->cmd_pool_bits, 0,
3564                ((hba[i]->nr_cmds + BITS_PER_LONG -
3565                  1) / BITS_PER_LONG) * sizeof(unsigned long));
3566
3567 #ifdef CCISS_DEBUG
3568         printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3569 #endif                          /* CCISS_DEBUG */
3570
3571         cciss_getgeometry(i);
3572
3573         cciss_scsi_setup(i);
3574
3575         /* Turn the interrupts on so we can service requests */
3576         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3577
3578         cciss_procinit(i);
3579
3580         hba[i]->cciss_max_sectors = 2048;
3581
3582         hba[i]->busy_initializing = 0;
3583
3584         do {
3585                 drive_info_struct *drv = &(hba[i]->drv[j]);
3586                 struct gendisk *disk = hba[i]->gendisk[j];
3587                 struct request_queue *q;
3588
3589                 /* Check if the disk was allocated already */
3590                 if (!disk){
3591                         hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3592                         disk = hba[i]->gendisk[j];
3593                 }
3594
3595                 /* Check that the disk was able to be allocated */
3596                 if (!disk) {
3597                         printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3598                         goto clean4;
3599                 }
3600
3601                 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3602                 if (!q) {
3603                         printk(KERN_ERR
3604                                "cciss:  unable to allocate queue for disk %d\n",
3605                                j);
3606                         goto clean4;
3607                 }
3608                 drv->queue = q;
3609
3610                 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3611
3612                 /* This is a hardware imposed limit. */
3613                 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3614
3615                 /* This is a limit in the driver and could be eliminated. */
3616                 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3617
3618                 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
3619
3620                 blk_queue_softirq_done(q, cciss_softirq_done);
3621
3622                 q->queuedata = hba[i];
3623                 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3624                 disk->major = hba[i]->major;
3625                 disk->first_minor = j << NWD_SHIFT;
3626                 disk->fops = &cciss_fops;
3627                 disk->queue = q;
3628                 disk->private_data = drv;
3629                 disk->driverfs_dev = &pdev->dev;
3630                 /* we must register the controller even if no disks exist */
3631                 /* this is for the online array utilities */
3632                 if (!drv->heads && j)
3633                         continue;
3634                 blk_queue_hardsect_size(q, drv->block_size);
3635                 set_capacity(disk, drv->nr_blocks);
3636                 j++;
3637         } while (j <= hba[i]->highest_lun);
3638
3639         /* Make sure all queue data is written out before */
3640         /* interrupt handler, triggered by add_disk,  */
3641         /* is allowed to start them. */
3642         wmb();
3643
3644         for (j = 0; j <= hba[i]->highest_lun; j++)
3645                 add_disk(hba[i]->gendisk[j]);
3646
3647         /* we must register the controller even if no disks exist */
3648         if (hba[i]->highest_lun == -1)
3649                 add_disk(hba[i]->gendisk[0]);
3650
3651         return 1;
3652
3653       clean4:
3654 #ifdef CONFIG_CISS_SCSI_TAPE
3655         kfree(hba[i]->scsi_rejects.complete);
3656 #endif
3657         kfree(hba[i]->cmd_pool_bits);
3658         if (hba[i]->cmd_pool)
3659                 pci_free_consistent(hba[i]->pdev,
3660                                     hba[i]->nr_cmds * sizeof(CommandList_struct),
3661                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3662         if (hba[i]->errinfo_pool)
3663                 pci_free_consistent(hba[i]->pdev,
3664                                     hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3665                                     hba[i]->errinfo_pool,
3666                                     hba[i]->errinfo_pool_dhandle);
3667         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
3668       clean2:
3669         unregister_blkdev(hba[i]->major, hba[i]->devname);
3670       clean1:
3671         hba[i]->busy_initializing = 0;
3672         /* cleanup any queues that may have been initialized */
3673         for (j=0; j <= hba[i]->highest_lun; j++){
3674                 drive_info_struct *drv = &(hba[i]->drv[j]);
3675                 if (drv->queue)
3676                         blk_cleanup_queue(drv->queue);
3677         }
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         return -1;
3686 }
3687
3688 static void cciss_shutdown(struct pci_dev *pdev)
3689 {
3690         ctlr_info_t *tmp_ptr;
3691         int i;
3692         char flush_buf[4];
3693         int return_code;
3694
3695         tmp_ptr = pci_get_drvdata(pdev);
3696         if (tmp_ptr == NULL)
3697                 return;
3698         i = tmp_ptr->ctlr;
3699         if (hba[i] == NULL)
3700                 return;
3701
3702         /* Turn board interrupts off  and send the flush cache command */
3703         /* sendcmd will turn off interrupt, and send the flush...
3704          * To write all data in the battery backed cache to disks */
3705         memset(flush_buf, 0, 4);
3706         return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3707                               TYPE_CMD);
3708         if (return_code == IO_OK) {
3709                 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3710         } else {
3711                 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3712         }
3713         free_irq(hba[i]->intr[2], hba[i]);
3714 }
3715
3716 static void __devexit cciss_remove_one(struct pci_dev *pdev)
3717 {
3718         ctlr_info_t *tmp_ptr;
3719         int i, j;
3720
3721         if (pci_get_drvdata(pdev) == NULL) {
3722                 printk(KERN_ERR "cciss: Unable to remove device \n");
3723                 return;
3724         }
3725         tmp_ptr = pci_get_drvdata(pdev);
3726         i = tmp_ptr->ctlr;
3727         if (hba[i] == NULL) {
3728                 printk(KERN_ERR "cciss: device appears to "
3729                        "already be removed \n");
3730                 return;
3731         }
3732
3733         remove_proc_entry(hba[i]->devname, proc_cciss);
3734         unregister_blkdev(hba[i]->major, hba[i]->devname);
3735
3736         /* remove it from the disk list */
3737         for (j = 0; j < CISS_MAX_LUN; j++) {
3738                 struct gendisk *disk = hba[i]->gendisk[j];
3739                 if (disk) {
3740                         struct request_queue *q = disk->queue;
3741
3742                         if (disk->flags & GENHD_FL_UP)
3743                                 del_gendisk(disk);
3744                         if (q)
3745                                 blk_cleanup_queue(q);
3746                 }
3747         }
3748
3749         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
3750
3751         cciss_shutdown(pdev);
3752
3753 #ifdef CONFIG_PCI_MSI
3754         if (hba[i]->msix_vector)
3755                 pci_disable_msix(hba[i]->pdev);
3756         else if (hba[i]->msi_vector)
3757                 pci_disable_msi(hba[i]->pdev);
3758 #endif                          /* CONFIG_PCI_MSI */
3759
3760         iounmap(hba[i]->vaddr);
3761
3762         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
3763                             hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3764         pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
3765                             hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3766         kfree(hba[i]->cmd_pool_bits);
3767 #ifdef CONFIG_CISS_SCSI_TAPE
3768         kfree(hba[i]->scsi_rejects.complete);
3769 #endif
3770         /*
3771          * Deliberately omit pci_disable_device(): it does something nasty to
3772          * Smart Array controllers that pci_enable_device does not undo
3773          */
3774         pci_release_regions(pdev);
3775         pci_set_drvdata(pdev, NULL);
3776         free_hba(i);
3777 }
3778
3779 static struct pci_driver cciss_pci_driver = {
3780         .name = "cciss",
3781         .probe = cciss_init_one,
3782         .remove = __devexit_p(cciss_remove_one),
3783         .id_table = cciss_pci_device_id,        /* id_table */
3784         .shutdown = cciss_shutdown,
3785 };
3786
3787 /*
3788  *  This is it.  Register the PCI driver information for the cards we control
3789  *  the OS will call our registered routines when it finds one of our cards.
3790  */
3791 static int __init cciss_init(void)
3792 {
3793         printk(KERN_INFO DRIVER_NAME "\n");
3794
3795         /* Register for our PCI devices */
3796         return pci_register_driver(&cciss_pci_driver);
3797 }
3798
3799 static void __exit cciss_cleanup(void)
3800 {
3801         int i;
3802
3803         pci_unregister_driver(&cciss_pci_driver);
3804         /* double check that all controller entrys have been removed */
3805         for (i = 0; i < MAX_CTLR; i++) {
3806                 if (hba[i] != NULL) {
3807                         printk(KERN_WARNING "cciss: had to remove"
3808                                " controller %d\n", i);
3809                         cciss_remove_one(hba[i]->pdev);
3810                 }
3811         }
3812         remove_proc_entry("driver/cciss", NULL);
3813 }
3814
3815 static void fail_all_cmds(unsigned long ctlr)
3816 {
3817         /* If we get here, the board is apparently dead. */
3818         ctlr_info_t *h = hba[ctlr];
3819         CommandList_struct *c;
3820         unsigned long flags;
3821
3822         printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3823         h->alive = 0;           /* the controller apparently died... */
3824
3825         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3826
3827         pci_disable_device(h->pdev);    /* Make sure it is really dead. */
3828
3829         /* move everything off the request queue onto the completed queue */
3830         while ((c = h->reqQ) != NULL) {
3831                 removeQ(&(h->reqQ), c);
3832                 h->Qdepth--;
3833                 addQ(&(h->cmpQ), c);
3834         }
3835
3836         /* Now, fail everything on the completed queue with a HW error */
3837         while ((c = h->cmpQ) != NULL) {
3838                 removeQ(&h->cmpQ, c);
3839                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3840                 if (c->cmd_type == CMD_RWREQ) {
3841                         complete_command(h, c, 0);
3842                 } else if (c->cmd_type == CMD_IOCTL_PEND)
3843                         complete(c->waiting);
3844 #ifdef CONFIG_CISS_SCSI_TAPE
3845                 else if (c->cmd_type == CMD_SCSI)
3846                         complete_scsi_command(c, 0, 0);
3847 #endif
3848         }
3849         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3850         return;
3851 }
3852
3853 module_init(cciss_init);
3854 module_exit(cciss_cleanup);