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