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