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