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