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