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