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