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