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