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