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