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