drivers/block/cciss.c

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