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