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