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