2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
3 * Copyright 2000, 2005 Hewlett-Packard Development Company, L.P.
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.
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.
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.
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
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>
33 #include <linux/bio.h>
34 #include <linux/blkpg.h>
35 #include <linux/timer.h>
36 #include <linux/proc_fs.h>
37 #include <linux/init.h>
38 #include <linux/hdreg.h>
39 #include <linux/spinlock.h>
40 #include <linux/compat.h>
41 #include <asm/uaccess.h>
44 #include <linux/dma-mapping.h>
45 #include <linux/blkdev.h>
46 #include <linux/genhd.h>
47 #include <linux/completion.h>
49 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
50 #define DRIVER_NAME "HP CISS Driver (v 2.6.8)"
51 #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,8)
53 /* Embedded module documentation macros - see modules.h */
54 MODULE_AUTHOR("Hewlett-Packard Company");
55 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.8");
56 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
57 " SA6i P600 P800 P400 P400i E200 E200i");
58 MODULE_LICENSE("GPL");
60 #include "cciss_cmd.h"
62 #include <linux/cciss_ioctl.h>
64 /* define the PCI info for the cards we can control */
65 static const struct pci_device_id cciss_pci_device_id
[] = {
66 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISS
,
67 0x0E11, 0x4070, 0, 0, 0},
68 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSB
,
69 0x0E11, 0x4080, 0, 0, 0},
70 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSB
,
71 0x0E11, 0x4082, 0, 0, 0},
72 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSB
,
73 0x0E11, 0x4083, 0, 0, 0},
74 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSC
,
75 0x0E11, 0x409A, 0, 0, 0},
76 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSC
,
77 0x0E11, 0x409B, 0, 0, 0},
78 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSC
,
79 0x0E11, 0x409C, 0, 0, 0},
80 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSC
,
81 0x0E11, 0x409D, 0, 0, 0},
82 { PCI_VENDOR_ID_COMPAQ
, PCI_DEVICE_ID_COMPAQ_CISSC
,
83 0x0E11, 0x4091, 0, 0, 0},
84 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSA
,
85 0x103C, 0x3225, 0, 0, 0},
86 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSC
,
87 0x103c, 0x3223, 0, 0, 0},
88 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSC
,
89 0x103c, 0x3234, 0, 0, 0},
90 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSC
,
91 0x103c, 0x3235, 0, 0, 0},
92 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSD
,
93 0x103c, 0x3211, 0, 0, 0},
94 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSD
,
95 0x103c, 0x3212, 0, 0, 0},
96 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSD
,
97 0x103c, 0x3213, 0, 0, 0},
98 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSD
,
99 0x103c, 0x3214, 0, 0, 0},
100 { PCI_VENDOR_ID_HP
, PCI_DEVICE_ID_HP_CISSD
,
101 0x103c, 0x3215, 0, 0, 0},
104 MODULE_DEVICE_TABLE(pci
, cciss_pci_device_id
);
106 #define NR_PRODUCTS (sizeof(products)/sizeof(struct board_type))
108 /* board_id = Subsystem Device ID & Vendor ID
109 * product = Marketing Name for the board
110 * access = Address of the struct of function pointers
112 static struct board_type products
[] = {
113 { 0x40700E11, "Smart Array 5300", &SA5_access
},
114 { 0x40800E11, "Smart Array 5i", &SA5B_access
},
115 { 0x40820E11, "Smart Array 532", &SA5B_access
},
116 { 0x40830E11, "Smart Array 5312", &SA5B_access
},
117 { 0x409A0E11, "Smart Array 641", &SA5_access
},
118 { 0x409B0E11, "Smart Array 642", &SA5_access
},
119 { 0x409C0E11, "Smart Array 6400", &SA5_access
},
120 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access
},
121 { 0x40910E11, "Smart Array 6i", &SA5_access
},
122 { 0x3225103C, "Smart Array P600", &SA5_access
},
123 { 0x3223103C, "Smart Array P800", &SA5_access
},
124 { 0x3234103C, "Smart Array P400", &SA5_access
},
125 { 0x3235103C, "Smart Array P400i", &SA5_access
},
126 { 0x3211103C, "Smart Array E200i", &SA5_access
},
127 { 0x3212103C, "Smart Array E200", &SA5_access
},
128 { 0x3213103C, "Smart Array E200i", &SA5_access
},
129 { 0x3214103C, "Smart Array E200i", &SA5_access
},
130 { 0x3215103C, "Smart Array E200i", &SA5_access
},
133 /* How long to wait (in millesconds) for board to go into simple mode */
134 #define MAX_CONFIG_WAIT 30000
135 #define MAX_IOCTL_CONFIG_WAIT 1000
137 /*define how many times we will try a command because of bus resets */
138 #define MAX_CMD_RETRIES 3
140 #define READ_AHEAD 1024
141 #define NR_CMDS 384 /* #commands that can be outstanding */
144 /* Originally cciss driver only supports 8 major numbers */
145 #define MAX_CTLR_ORIG 8
148 static ctlr_info_t
*hba
[MAX_CTLR
];
150 static void do_cciss_request(request_queue_t
*q
);
151 static int cciss_open(struct inode
*inode
, struct file
*filep
);
152 static int cciss_release(struct inode
*inode
, struct file
*filep
);
153 static int cciss_ioctl(struct inode
*inode
, struct file
*filep
,
154 unsigned int cmd
, unsigned long arg
);
156 static int revalidate_allvol(ctlr_info_t
*host
);
157 static int cciss_revalidate(struct gendisk
*disk
);
158 static int rebuild_lun_table(ctlr_info_t
*h
, struct gendisk
*del_disk
);
159 static int deregister_disk(struct gendisk
*disk
, drive_info_struct
*drv
, int clear_all
);
161 static void cciss_read_capacity(int ctlr
, int logvol
, ReadCapdata_struct
*buf
,
162 int withirq
, unsigned int *total_size
, unsigned int *block_size
);
163 static void cciss_geometry_inquiry(int ctlr
, int logvol
,
164 int withirq
, unsigned int total_size
,
165 unsigned int block_size
, InquiryData_struct
*inq_buff
,
166 drive_info_struct
*drv
);
167 static void cciss_getgeometry(int cntl_num
);
169 static void start_io( ctlr_info_t
*h
);
170 static int sendcmd( __u8 cmd
, int ctlr
, void *buff
, size_t size
,
171 unsigned int use_unit_num
, unsigned int log_unit
, __u8 page_code
,
172 unsigned char *scsi3addr
, int cmd_type
);
173 static int sendcmd_withirq(__u8 cmd
, int ctlr
, void *buff
, size_t size
,
174 unsigned int use_unit_num
, unsigned int log_unit
, __u8 page_code
,
177 static void fail_all_cmds(unsigned long ctlr
);
179 #ifdef CONFIG_PROC_FS
180 static int cciss_proc_get_info(char *buffer
, char **start
, off_t offset
,
181 int length
, int *eof
, void *data
);
182 static void cciss_procinit(int i
);
184 static void cciss_procinit(int i
) {}
185 #endif /* CONFIG_PROC_FS */
188 static long cciss_compat_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
);
191 static struct block_device_operations cciss_fops
= {
192 .owner
= THIS_MODULE
,
194 .release
= cciss_release
,
195 .ioctl
= cciss_ioctl
,
197 .compat_ioctl
= cciss_compat_ioctl
,
199 .revalidate_disk
= cciss_revalidate
,
203 * Enqueuing and dequeuing functions for cmdlists.
205 static inline void addQ(CommandList_struct
**Qptr
, CommandList_struct
*c
)
209 c
->next
= c
->prev
= c
;
211 c
->prev
= (*Qptr
)->prev
;
213 (*Qptr
)->prev
->next
= c
;
218 static inline CommandList_struct
*removeQ(CommandList_struct
**Qptr
,
219 CommandList_struct
*c
)
221 if (c
&& c
->next
!= c
) {
222 if (*Qptr
== c
) *Qptr
= c
->next
;
223 c
->prev
->next
= c
->next
;
224 c
->next
->prev
= c
->prev
;
231 #include "cciss_scsi.c" /* For SCSI tape support */
233 #ifdef CONFIG_PROC_FS
236 * Report information about this controller.
238 #define ENG_GIG 1000000000
239 #define ENG_GIG_FACTOR (ENG_GIG/512)
240 #define RAID_UNKNOWN 6
241 static const char *raid_label
[] = {"0","4","1(1+0)","5","5+1","ADG",
244 static struct proc_dir_entry
*proc_cciss
;
246 static int cciss_proc_get_info(char *buffer
, char **start
, off_t offset
,
247 int length
, int *eof
, void *data
)
252 ctlr_info_t
*h
= (ctlr_info_t
*)data
;
253 drive_info_struct
*drv
;
255 sector_t vol_sz
, vol_sz_frac
;
259 /* prevent displaying bogus info during configuration
260 * or deconfiguration of a logical volume
262 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
263 if (h
->busy_configuring
) {
264 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
267 h
->busy_configuring
= 1;
268 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
270 size
= sprintf(buffer
, "%s: HP %s Controller\n"
271 "Board ID: 0x%08lx\n"
272 "Firmware Version: %c%c%c%c\n"
274 "Logical drives: %d\n"
275 "Current Q depth: %d\n"
276 "Current # commands on controller: %d\n"
277 "Max Q depth since init: %d\n"
278 "Max # commands on controller since init: %d\n"
279 "Max SG entries since init: %d\n\n",
282 (unsigned long)h
->board_id
,
283 h
->firm_ver
[0], h
->firm_ver
[1], h
->firm_ver
[2], h
->firm_ver
[3],
284 (unsigned int)h
->intr
,
286 h
->Qdepth
, h
->commands_outstanding
,
287 h
->maxQsinceinit
, h
->max_outstanding
, h
->maxSG
);
289 pos
+= size
; len
+= size
;
290 cciss_proc_tape_report(ctlr
, buffer
, &pos
, &len
);
291 for(i
=0; i
<=h
->highest_lun
; i
++) {
297 vol_sz
= drv
->nr_blocks
;
298 vol_sz_frac
= sector_div(vol_sz
, ENG_GIG_FACTOR
);
300 sector_div(vol_sz_frac
, ENG_GIG_FACTOR
);
302 if (drv
->raid_level
> 5)
303 drv
->raid_level
= RAID_UNKNOWN
;
304 size
= sprintf(buffer
+len
, "cciss/c%dd%d:"
305 "\t%4u.%02uGB\tRAID %s\n",
306 ctlr
, i
, (int)vol_sz
, (int)vol_sz_frac
,
307 raid_label
[drv
->raid_level
]);
308 pos
+= size
; len
+= size
;
312 *start
= buffer
+offset
;
316 h
->busy_configuring
= 0;
321 cciss_proc_write(struct file
*file
, const char __user
*buffer
,
322 unsigned long count
, void *data
)
324 unsigned char cmd
[80];
326 #ifdef CONFIG_CISS_SCSI_TAPE
327 ctlr_info_t
*h
= (ctlr_info_t
*) data
;
331 if (count
> sizeof(cmd
)-1) return -EINVAL
;
332 if (copy_from_user(cmd
, buffer
, count
)) return -EFAULT
;
334 len
= strlen(cmd
); // above 3 lines ensure safety
335 if (len
&& cmd
[len
-1] == '\n')
337 # ifdef CONFIG_CISS_SCSI_TAPE
338 if (strcmp("engage scsi", cmd
)==0) {
339 rc
= cciss_engage_scsi(h
->ctlr
);
340 if (rc
!= 0) return -rc
;
343 /* might be nice to have "disengage" too, but it's not
344 safely possible. (only 1 module use count, lock issues.) */
350 * Get us a file in /proc/cciss that says something about each controller.
351 * Create /proc/cciss if it doesn't exist yet.
353 static void __devinit
cciss_procinit(int i
)
355 struct proc_dir_entry
*pde
;
357 if (proc_cciss
== NULL
) {
358 proc_cciss
= proc_mkdir("cciss", proc_root_driver
);
363 pde
= create_proc_read_entry(hba
[i
]->devname
,
364 S_IWUSR
| S_IRUSR
| S_IRGRP
| S_IROTH
,
365 proc_cciss
, cciss_proc_get_info
, hba
[i
]);
366 pde
->write_proc
= cciss_proc_write
;
368 #endif /* CONFIG_PROC_FS */
371 * For operations that cannot sleep, a command block is allocated at init,
372 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
373 * which ones are free or in use. For operations that can wait for kmalloc
374 * to possible sleep, this routine can be called with get_from_pool set to 0.
375 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
377 static CommandList_struct
* cmd_alloc(ctlr_info_t
*h
, int get_from_pool
)
379 CommandList_struct
*c
;
382 dma_addr_t cmd_dma_handle
, err_dma_handle
;
386 c
= (CommandList_struct
*) pci_alloc_consistent(
387 h
->pdev
, sizeof(CommandList_struct
), &cmd_dma_handle
);
390 memset(c
, 0, sizeof(CommandList_struct
));
394 c
->err_info
= (ErrorInfo_struct
*)pci_alloc_consistent(
395 h
->pdev
, sizeof(ErrorInfo_struct
),
398 if (c
->err_info
== NULL
)
400 pci_free_consistent(h
->pdev
,
401 sizeof(CommandList_struct
), c
, cmd_dma_handle
);
404 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
405 } else /* get it out of the controllers pool */
408 i
= find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
);
411 } while(test_and_set_bit(i
& (BITS_PER_LONG
- 1), h
->cmd_pool_bits
+(i
/BITS_PER_LONG
)) != 0);
413 printk(KERN_DEBUG
"cciss: using command buffer %d\n", i
);
416 memset(c
, 0, sizeof(CommandList_struct
));
417 cmd_dma_handle
= h
->cmd_pool_dhandle
418 + i
*sizeof(CommandList_struct
);
419 c
->err_info
= h
->errinfo_pool
+ i
;
420 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
421 err_dma_handle
= h
->errinfo_pool_dhandle
422 + i
*sizeof(ErrorInfo_struct
);
428 c
->busaddr
= (__u32
) cmd_dma_handle
;
429 temp64
.val
= (__u64
) err_dma_handle
;
430 c
->ErrDesc
.Addr
.lower
= temp64
.val32
.lower
;
431 c
->ErrDesc
.Addr
.upper
= temp64
.val32
.upper
;
432 c
->ErrDesc
.Len
= sizeof(ErrorInfo_struct
);
441 * Frees a command block that was previously allocated with cmd_alloc().
443 static void cmd_free(ctlr_info_t
*h
, CommandList_struct
*c
, int got_from_pool
)
450 temp64
.val32
.lower
= c
->ErrDesc
.Addr
.lower
;
451 temp64
.val32
.upper
= c
->ErrDesc
.Addr
.upper
;
452 pci_free_consistent(h
->pdev
, sizeof(ErrorInfo_struct
),
453 c
->err_info
, (dma_addr_t
) temp64
.val
);
454 pci_free_consistent(h
->pdev
, sizeof(CommandList_struct
),
455 c
, (dma_addr_t
) c
->busaddr
);
459 clear_bit(i
&(BITS_PER_LONG
-1), h
->cmd_pool_bits
+(i
/BITS_PER_LONG
));
464 static inline ctlr_info_t
*get_host(struct gendisk
*disk
)
466 return disk
->queue
->queuedata
;
469 static inline drive_info_struct
*get_drv(struct gendisk
*disk
)
471 return disk
->private_data
;
475 * Open. Make sure the device is really there.
477 static int cciss_open(struct inode
*inode
, struct file
*filep
)
479 ctlr_info_t
*host
= get_host(inode
->i_bdev
->bd_disk
);
480 drive_info_struct
*drv
= get_drv(inode
->i_bdev
->bd_disk
);
483 printk(KERN_DEBUG
"cciss_open %s\n", inode
->i_bdev
->bd_disk
->disk_name
);
484 #endif /* CCISS_DEBUG */
486 if (host
->busy_initializing
)
489 if (host
->busy_initializing
|| drv
->busy_configuring
)
492 * Root is allowed to open raw volume zero even if it's not configured
493 * so array config can still work. Root is also allowed to open any
494 * volume that has a LUN ID, so it can issue IOCTL to reread the
495 * disk information. I don't think I really like this
496 * but I'm already using way to many device nodes to claim another one
497 * for "raw controller".
499 if (drv
->nr_blocks
== 0) {
500 if (iminor(inode
) != 0) { /* not node 0? */
501 /* if not node 0 make sure it is a partition = 0 */
502 if (iminor(inode
) & 0x0f) {
504 /* if it is, make sure we have a LUN ID */
505 } else if (drv
->LunID
== 0) {
509 if (!capable(CAP_SYS_ADMIN
))
519 static int cciss_release(struct inode
*inode
, struct file
*filep
)
521 ctlr_info_t
*host
= get_host(inode
->i_bdev
->bd_disk
);
522 drive_info_struct
*drv
= get_drv(inode
->i_bdev
->bd_disk
);
525 printk(KERN_DEBUG
"cciss_release %s\n", inode
->i_bdev
->bd_disk
->disk_name
);
526 #endif /* CCISS_DEBUG */
535 static int do_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
)
539 ret
= cciss_ioctl(f
->f_dentry
->d_inode
, f
, cmd
, arg
);
544 static int cciss_ioctl32_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
);
545 static int cciss_ioctl32_big_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
);
547 static long cciss_compat_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
)
550 case CCISS_GETPCIINFO
:
551 case CCISS_GETINTINFO
:
552 case CCISS_SETINTINFO
:
553 case CCISS_GETNODENAME
:
554 case CCISS_SETNODENAME
:
555 case CCISS_GETHEARTBEAT
:
556 case CCISS_GETBUSTYPES
:
557 case CCISS_GETFIRMVER
:
558 case CCISS_GETDRIVVER
:
559 case CCISS_REVALIDVOLS
:
560 case CCISS_DEREGDISK
:
561 case CCISS_REGNEWDISK
:
563 case CCISS_RESCANDISK
:
564 case CCISS_GETLUNINFO
:
565 return do_ioctl(f
, cmd
, arg
);
567 case CCISS_PASSTHRU32
:
568 return cciss_ioctl32_passthru(f
, cmd
, arg
);
569 case CCISS_BIG_PASSTHRU32
:
570 return cciss_ioctl32_big_passthru(f
, cmd
, arg
);
577 static int cciss_ioctl32_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
)
579 IOCTL32_Command_struct __user
*arg32
=
580 (IOCTL32_Command_struct __user
*) arg
;
581 IOCTL_Command_struct arg64
;
582 IOCTL_Command_struct __user
*p
= compat_alloc_user_space(sizeof(arg64
));
587 err
|= copy_from_user(&arg64
.LUN_info
, &arg32
->LUN_info
, sizeof(arg64
.LUN_info
));
588 err
|= copy_from_user(&arg64
.Request
, &arg32
->Request
, sizeof(arg64
.Request
));
589 err
|= copy_from_user(&arg64
.error_info
, &arg32
->error_info
, sizeof(arg64
.error_info
));
590 err
|= get_user(arg64
.buf_size
, &arg32
->buf_size
);
591 err
|= get_user(cp
, &arg32
->buf
);
592 arg64
.buf
= compat_ptr(cp
);
593 err
|= copy_to_user(p
, &arg64
, sizeof(arg64
));
598 err
= do_ioctl(f
, CCISS_PASSTHRU
, (unsigned long) p
);
601 err
|= copy_in_user(&arg32
->error_info
, &p
->error_info
, sizeof(arg32
->error_info
));
607 static int cciss_ioctl32_big_passthru(struct file
*file
, unsigned cmd
, unsigned long arg
)
609 BIG_IOCTL32_Command_struct __user
*arg32
=
610 (BIG_IOCTL32_Command_struct __user
*) arg
;
611 BIG_IOCTL_Command_struct arg64
;
612 BIG_IOCTL_Command_struct __user
*p
= compat_alloc_user_space(sizeof(arg64
));
617 err
|= copy_from_user(&arg64
.LUN_info
, &arg32
->LUN_info
, sizeof(arg64
.LUN_info
));
618 err
|= copy_from_user(&arg64
.Request
, &arg32
->Request
, sizeof(arg64
.Request
));
619 err
|= copy_from_user(&arg64
.error_info
, &arg32
->error_info
, sizeof(arg64
.error_info
));
620 err
|= get_user(arg64
.buf_size
, &arg32
->buf_size
);
621 err
|= get_user(arg64
.malloc_size
, &arg32
->malloc_size
);
622 err
|= get_user(cp
, &arg32
->buf
);
623 arg64
.buf
= compat_ptr(cp
);
624 err
|= copy_to_user(p
, &arg64
, sizeof(arg64
));
629 err
= do_ioctl(file
, CCISS_BIG_PASSTHRU
, (unsigned long) p
);
632 err
|= copy_in_user(&arg32
->error_info
, &p
->error_info
, sizeof(arg32
->error_info
));
641 static int cciss_ioctl(struct inode
*inode
, struct file
*filep
,
642 unsigned int cmd
, unsigned long arg
)
644 struct block_device
*bdev
= inode
->i_bdev
;
645 struct gendisk
*disk
= bdev
->bd_disk
;
646 ctlr_info_t
*host
= get_host(disk
);
647 drive_info_struct
*drv
= get_drv(disk
);
648 int ctlr
= host
->ctlr
;
649 void __user
*argp
= (void __user
*)arg
;
652 printk(KERN_DEBUG
"cciss_ioctl: Called with cmd=%x %lx\n", cmd
, arg
);
653 #endif /* CCISS_DEBUG */
658 struct hd_geometry driver_geo
;
659 if (drv
->cylinders
) {
660 driver_geo
.heads
= drv
->heads
;
661 driver_geo
.sectors
= drv
->sectors
;
662 driver_geo
.cylinders
= drv
->cylinders
;
665 driver_geo
.start
= get_start_sect(inode
->i_bdev
);
666 if (copy_to_user(argp
, &driver_geo
, sizeof(struct hd_geometry
)))
671 case CCISS_GETPCIINFO
:
673 cciss_pci_info_struct pciinfo
;
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
)))
684 case CCISS_GETINTINFO
:
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
)))
694 case CCISS_SETINTINFO
:
696 cciss_coalint_struct intinfo
;
700 if (!arg
) return -EINVAL
;
701 if (!capable(CAP_SYS_ADMIN
)) return -EPERM
;
702 if (copy_from_user(&intinfo
, argp
, sizeof( cciss_coalint_struct
)))
704 if ( (intinfo
.delay
== 0 ) && (intinfo
.count
== 0))
707 // printk("cciss_ioctl: delay and count cannot be 0\n");
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
);
718 for(i
=0;i
<MAX_IOCTL_CONFIG_WAIT
;i
++) {
719 if (!(readl(host
->vaddr
+ SA5_DOORBELL
)
722 /* delay and try again */
725 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
726 if (i
>= MAX_IOCTL_CONFIG_WAIT
)
730 case CCISS_GETNODENAME
:
732 NodeName_type NodeName
;
735 if (!arg
) return -EINVAL
;
737 NodeName
[i
] = readb(&host
->cfgtable
->ServerName
[i
]);
738 if (copy_to_user(argp
, NodeName
, sizeof( NodeName_type
)))
742 case CCISS_SETNODENAME
:
744 NodeName_type NodeName
;
748 if (!arg
) return -EINVAL
;
749 if (!capable(CAP_SYS_ADMIN
)) return -EPERM
;
751 if (copy_from_user(NodeName
, argp
, sizeof( NodeName_type
)))
754 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
756 /* Update the field, and then ring the doorbell */
758 writeb( NodeName
[i
], &host
->cfgtable
->ServerName
[i
]);
760 writel( CFGTBL_ChangeReq
, host
->vaddr
+ SA5_DOORBELL
);
762 for(i
=0;i
<MAX_IOCTL_CONFIG_WAIT
;i
++) {
763 if (!(readl(host
->vaddr
+ SA5_DOORBELL
)
766 /* delay and try again */
769 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
770 if (i
>= MAX_IOCTL_CONFIG_WAIT
)
775 case CCISS_GETHEARTBEAT
:
777 Heartbeat_type heartbeat
;
779 if (!arg
) return -EINVAL
;
780 heartbeat
= readl(&host
->cfgtable
->HeartBeat
);
781 if (copy_to_user(argp
, &heartbeat
, sizeof( Heartbeat_type
)))
785 case CCISS_GETBUSTYPES
:
787 BusTypes_type BusTypes
;
789 if (!arg
) return -EINVAL
;
790 BusTypes
= readl(&host
->cfgtable
->BusTypes
);
791 if (copy_to_user(argp
, &BusTypes
, sizeof( BusTypes_type
) ))
795 case CCISS_GETFIRMVER
:
797 FirmwareVer_type firmware
;
799 if (!arg
) return -EINVAL
;
800 memcpy(firmware
, host
->firm_ver
, 4);
802 if (copy_to_user(argp
, firmware
, sizeof( FirmwareVer_type
)))
806 case CCISS_GETDRIVVER
:
808 DriverVer_type DriverVer
= DRIVER_VERSION
;
810 if (!arg
) return -EINVAL
;
812 if (copy_to_user(argp
, &DriverVer
, sizeof( DriverVer_type
) ))
817 case CCISS_REVALIDVOLS
:
818 if (bdev
!= bdev
->bd_contains
|| drv
!= host
->drv
)
820 return revalidate_allvol(host
);
822 case CCISS_GETLUNINFO
: {
823 LogvolInfo_struct luninfo
;
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
)))
833 case CCISS_DEREGDISK
:
834 return rebuild_lun_table(host
, disk
);
837 return rebuild_lun_table(host
, NULL
);
841 IOCTL_Command_struct iocommand
;
842 CommandList_struct
*c
;
846 DECLARE_COMPLETION(wait
);
848 if (!arg
) return -EINVAL
;
850 if (!capable(CAP_SYS_RAWIO
)) return -EPERM
;
852 if (copy_from_user(&iocommand
, argp
, sizeof( IOCTL_Command_struct
) ))
854 if((iocommand
.buf_size
< 1) &&
855 (iocommand
.Request
.Type
.Direction
!= XFER_NONE
))
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)
864 if(iocommand
.buf_size
> 0)
866 buff
= kmalloc(iocommand
.buf_size
, GFP_KERNEL
);
870 if (iocommand
.Request
.Type
.Direction
== XFER_WRITE
)
872 /* Copy the data into the buffer we created */
873 if (copy_from_user(buff
, iocommand
.buf
, iocommand
.buf_size
))
879 memset(buff
, 0, iocommand
.buf_size
);
881 if ((c
= cmd_alloc(host
, 0)) == NULL
)
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
892 c
->Header
.SGList
= 1;
893 c
->Header
.SGTotal
= 1;
894 } else // no buffers to fill
896 c
->Header
.SGList
= 0;
897 c
->Header
.SGTotal
= 0;
899 c
->Header
.LUN
= iocommand
.LUN_info
;
900 c
->Header
.Tag
.lower
= c
->busaddr
; // use the kernel address the cmd block for tag
902 // Fill in Request block
903 c
->Request
= iocommand
.Request
;
905 // Fill in the scatter gather information
906 if (iocommand
.buf_size
> 0 )
908 temp64
.val
= pci_map_single( host
->pdev
, buff
,
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
918 /* Put the request on the tail of the request queue */
919 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
920 addQ(&host
->reqQ
, c
);
923 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
925 wait_for_completion(&wait
);
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
);
933 /* Copy the error information out */
934 iocommand
.error_info
= *(c
->err_info
);
935 if ( copy_to_user(argp
, &iocommand
, sizeof( IOCTL_Command_struct
) ) )
938 cmd_free(host
, c
, 0);
942 if (iocommand
.Request
.Type
.Direction
== XFER_READ
)
944 /* Copy the data out of the buffer we created */
945 if (copy_to_user(iocommand
.buf
, buff
, iocommand
.buf_size
))
948 cmd_free(host
, c
, 0);
953 cmd_free(host
, c
, 0);
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
;
966 DECLARE_COMPLETION(wait
);
969 BYTE __user
*data_ptr
;
973 if (!capable(CAP_SYS_RAWIO
))
975 ioc
= (BIG_IOCTL_Command_struct
*)
976 kmalloc(sizeof(*ioc
), GFP_KERNEL
);
981 if (copy_from_user(ioc
, argp
, sizeof(*ioc
))) {
985 if ((ioc
->buf_size
< 1) &&
986 (ioc
->Request
.Type
.Direction
!= XFER_NONE
)) {
990 /* Check kmalloc limits using all SGs */
991 if (ioc
->malloc_size
> MAX_KMALLOC_SIZE
) {
995 if (ioc
->buf_size
> ioc
->malloc_size
* MAXSGENTRIES
) {
999 buff
= (unsigned char **) kmalloc(MAXSGENTRIES
*
1000 sizeof(char *), GFP_KERNEL
);
1005 memset(buff
, 0, MAXSGENTRIES
);
1006 buff_size
= (int *) kmalloc(MAXSGENTRIES
* sizeof(int),
1012 left
= ioc
->buf_size
;
1013 data_ptr
= ioc
->buf
;
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
) {
1022 if (ioc
->Request
.Type
.Direction
== XFER_WRITE
&&
1023 copy_from_user(buff
[sg_used
], data_ptr
, sz
)) {
1027 memset(buff
[sg_used
], 0, sz
);
1033 if ((c
= cmd_alloc(host
, 0)) == NULL
) {
1037 c
->cmd_type
= CMD_IOCTL_PEND
;
1038 c
->Header
.ReplyQueue
= 0;
1040 if( ioc
->buf_size
> 0) {
1041 c
->Header
.SGList
= sg_used
;
1042 c
->Header
.SGTotal
= sg_used
;
1044 c
->Header
.SGList
= 0;
1045 c
->Header
.SGTotal
= 0;
1047 c
->Header
.LUN
= ioc
->LUN_info
;
1048 c
->Header
.Tag
.lower
= c
->busaddr
;
1050 c
->Request
= ioc
->Request
;
1051 if (ioc
->buf_size
> 0 ) {
1053 for(i
=0; i
<sg_used
; i
++) {
1054 temp64
.val
= pci_map_single( host
->pdev
, buff
[i
],
1056 PCI_DMA_BIDIRECTIONAL
);
1057 c
->SG
[i
].Addr
.lower
= temp64
.val32
.lower
;
1058 c
->SG
[i
].Addr
.upper
= temp64
.val32
.upper
;
1059 c
->SG
[i
].Len
= buff_size
[i
];
1060 c
->SG
[i
].Ext
= 0; /* we are not chaining */
1064 /* Put the request on the tail of the request queue */
1065 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1066 addQ(&host
->reqQ
, c
);
1069 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1070 wait_for_completion(&wait
);
1071 /* unlock the buffers from DMA */
1072 for(i
=0; i
<sg_used
; i
++) {
1073 temp64
.val32
.lower
= c
->SG
[i
].Addr
.lower
;
1074 temp64
.val32
.upper
= c
->SG
[i
].Addr
.upper
;
1075 pci_unmap_single( host
->pdev
, (dma_addr_t
) temp64
.val
,
1076 buff_size
[i
], PCI_DMA_BIDIRECTIONAL
);
1078 /* Copy the error information out */
1079 ioc
->error_info
= *(c
->err_info
);
1080 if (copy_to_user(argp
, ioc
, sizeof(*ioc
))) {
1081 cmd_free(host
, c
, 0);
1085 if (ioc
->Request
.Type
.Direction
== XFER_READ
) {
1086 /* Copy the data out of the buffer we created */
1087 BYTE __user
*ptr
= ioc
->buf
;
1088 for(i
=0; i
< sg_used
; i
++) {
1089 if (copy_to_user(ptr
, buff
[i
], buff_size
[i
])) {
1090 cmd_free(host
, c
, 0);
1094 ptr
+= buff_size
[i
];
1097 cmd_free(host
, c
, 0);
1101 for(i
=0; i
<sg_used
; i
++)
1119 * revalidate_allvol is for online array config utilities. After a
1120 * utility reconfigures the drives in the array, it can use this function
1121 * (through an ioctl) to make the driver zap any previous disk structs for
1122 * that controller and get new ones.
1124 * Right now I'm using the getgeometry() function to do this, but this
1125 * function should probably be finer grained and allow you to revalidate one
1126 * particualar logical volume (instead of all of them on a particular
1129 static int revalidate_allvol(ctlr_info_t
*host
)
1131 int ctlr
= host
->ctlr
, i
;
1132 unsigned long flags
;
1134 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1135 if (host
->usage_count
> 1) {
1136 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1137 printk(KERN_WARNING
"cciss: Device busy for volume"
1138 " revalidation (usage=%d)\n", host
->usage_count
);
1141 host
->usage_count
++;
1142 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1144 for(i
=0; i
< NWD
; i
++) {
1145 struct gendisk
*disk
= host
->gendisk
[i
];
1146 if (disk
->flags
& GENHD_FL_UP
)
1151 * Set the partition and block size structures for all volumes
1152 * on this controller to zero. We will reread all of this data
1154 memset(host
->drv
, 0, sizeof(drive_info_struct
)
1157 * Tell the array controller not to give us any interrupts while
1158 * we check the new geometry. Then turn interrupts back on when
1161 host
->access
.set_intr_mask(host
, CCISS_INTR_OFF
);
1162 cciss_getgeometry(ctlr
);
1163 host
->access
.set_intr_mask(host
, CCISS_INTR_ON
);
1165 /* Loop through each real device */
1166 for (i
= 0; i
< NWD
; i
++) {
1167 struct gendisk
*disk
= host
->gendisk
[i
];
1168 drive_info_struct
*drv
= &(host
->drv
[i
]);
1169 /* we must register the controller even if no disks exist */
1170 /* this is for the online array utilities */
1171 if (!drv
->heads
&& i
)
1173 blk_queue_hardsect_size(drv
->queue
, drv
->block_size
);
1174 set_capacity(disk
, drv
->nr_blocks
);
1177 host
->usage_count
--;
1181 /* This function will check the usage_count of the drive to be updated/added.
1182 * If the usage_count is zero then the drive information will be updated and
1183 * the disk will be re-registered with the kernel. If not then it will be
1184 * left alone for the next reboot. The exception to this is disk 0 which
1185 * will always be left registered with the kernel since it is also the
1186 * controller node. Any changes to disk 0 will show up on the next
1189 static void cciss_update_drive_info(int ctlr
, int drv_index
)
1191 ctlr_info_t
*h
= hba
[ctlr
];
1192 struct gendisk
*disk
;
1193 ReadCapdata_struct
*size_buff
= NULL
;
1194 InquiryData_struct
*inq_buff
= NULL
;
1195 unsigned int block_size
;
1196 unsigned int total_size
;
1197 unsigned long flags
= 0;
1200 /* if the disk already exists then deregister it before proceeding*/
1201 if (h
->drv
[drv_index
].raid_level
!= -1){
1202 spin_lock_irqsave(CCISS_LOCK(h
->ctlr
), flags
);
1203 h
->drv
[drv_index
].busy_configuring
= 1;
1204 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
1205 ret
= deregister_disk(h
->gendisk
[drv_index
],
1206 &h
->drv
[drv_index
], 0);
1207 h
->drv
[drv_index
].busy_configuring
= 0;
1210 /* If the disk is in use return */
1215 /* Get information about the disk and modify the driver sturcture */
1216 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
1217 if (size_buff
== NULL
)
1219 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
1220 if (inq_buff
== NULL
)
1223 cciss_read_capacity(ctlr
, drv_index
, size_buff
, 1,
1224 &total_size
, &block_size
);
1225 cciss_geometry_inquiry(ctlr
, drv_index
, 1, total_size
, block_size
,
1226 inq_buff
, &h
->drv
[drv_index
]);
1229 disk
= h
->gendisk
[drv_index
];
1230 set_capacity(disk
, h
->drv
[drv_index
].nr_blocks
);
1233 /* if it's the controller it's already added */
1235 disk
->queue
= blk_init_queue(do_cciss_request
, &h
->lock
);
1237 /* Set up queue information */
1238 disk
->queue
->backing_dev_info
.ra_pages
= READ_AHEAD
;
1239 blk_queue_bounce_limit(disk
->queue
, hba
[ctlr
]->pdev
->dma_mask
);
1241 /* This is a hardware imposed limit. */
1242 blk_queue_max_hw_segments(disk
->queue
, MAXSGENTRIES
);
1244 /* This is a limit in the driver and could be eliminated. */
1245 blk_queue_max_phys_segments(disk
->queue
, MAXSGENTRIES
);
1247 blk_queue_max_sectors(disk
->queue
, 512);
1249 disk
->queue
->queuedata
= hba
[ctlr
];
1251 blk_queue_hardsect_size(disk
->queue
,
1252 hba
[ctlr
]->drv
[drv_index
].block_size
);
1254 h
->drv
[drv_index
].queue
= disk
->queue
;
1263 printk(KERN_ERR
"cciss: out of memory\n");
1267 /* This function will find the first index of the controllers drive array
1268 * that has a -1 for the raid_level and will return that index. This is
1269 * where new drives will be added. If the index to be returned is greater
1270 * than the highest_lun index for the controller then highest_lun is set
1271 * to this new index. If there are no available indexes then -1 is returned.
1273 static int cciss_find_free_drive_index(int ctlr
)
1277 for (i
=0; i
< CISS_MAX_LUN
; i
++){
1278 if (hba
[ctlr
]->drv
[i
].raid_level
== -1){
1279 if (i
> hba
[ctlr
]->highest_lun
)
1280 hba
[ctlr
]->highest_lun
= i
;
1287 /* This function will add and remove logical drives from the Logical
1288 * drive array of the controller and maintain persistancy of ordering
1289 * so that mount points are preserved until the next reboot. This allows
1290 * for the removal of logical drives in the middle of the drive array
1291 * without a re-ordering of those drives.
1293 * h = The controller to perform the operations on
1294 * del_disk = The disk to remove if specified. If the value given
1295 * is NULL then no disk is removed.
1297 static int rebuild_lun_table(ctlr_info_t
*h
, struct gendisk
*del_disk
)
1301 ReportLunData_struct
*ld_buff
= NULL
;
1302 drive_info_struct
*drv
= NULL
;
1309 unsigned long flags
;
1311 /* Set busy_configuring flag for this operation */
1312 spin_lock_irqsave(CCISS_LOCK(h
->ctlr
), flags
);
1313 if (h
->num_luns
>= CISS_MAX_LUN
){
1314 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
1318 if (h
->busy_configuring
){
1319 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
1322 h
->busy_configuring
= 1;
1324 /* if del_disk is NULL then we are being called to add a new disk
1325 * and update the logical drive table. If it is not NULL then
1326 * we will check if the disk is in use or not.
1328 if (del_disk
!= NULL
){
1329 drv
= get_drv(del_disk
);
1330 drv
->busy_configuring
= 1;
1331 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
1332 return_code
= deregister_disk(del_disk
, drv
, 1);
1333 drv
->busy_configuring
= 0;
1334 h
->busy_configuring
= 0;
1337 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
1338 if (!capable(CAP_SYS_RAWIO
))
1341 ld_buff
= kzalloc(sizeof(ReportLunData_struct
), GFP_KERNEL
);
1342 if (ld_buff
== NULL
)
1345 return_code
= sendcmd_withirq(CISS_REPORT_LOG
, ctlr
, ld_buff
,
1346 sizeof(ReportLunData_struct
), 0, 0, 0,
1349 if (return_code
== IO_OK
){
1350 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[0])) << 24;
1351 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[1])) << 16;
1352 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[2])) << 8;
1353 listlength
|= 0xff & (unsigned int)(ld_buff
->LUNListLength
[3]);
1354 } else{ /* reading number of logical volumes failed */
1355 printk(KERN_WARNING
"cciss: report logical volume"
1356 " command failed\n");
1361 num_luns
= listlength
/ 8; /* 8 bytes per entry */
1362 if (num_luns
> CISS_MAX_LUN
){
1363 num_luns
= CISS_MAX_LUN
;
1364 printk(KERN_WARNING
"cciss: more luns configured"
1365 " on controller than can be handled by"
1369 /* Compare controller drive array to drivers drive array.
1370 * Check for updates in the drive information and any new drives
1371 * on the controller.
1373 for (i
=0; i
< num_luns
; i
++){
1379 (unsigned int)(ld_buff
->LUN
[i
][3])) << 24;
1381 (unsigned int)(ld_buff
->LUN
[i
][2])) << 16;
1383 (unsigned int)(ld_buff
->LUN
[i
][1])) << 8;
1385 (unsigned int)(ld_buff
->LUN
[i
][0]);
1387 /* Find if the LUN is already in the drive array
1388 * of the controller. If so then update its info
1389 * if not is use. If it does not exist then find
1390 * the first free index and add it.
1392 for (j
=0; j
<= h
->highest_lun
; j
++){
1393 if (h
->drv
[j
].LunID
== lunid
){
1399 /* check if the drive was found already in the array */
1401 drv_index
= cciss_find_free_drive_index(ctlr
);
1402 if (drv_index
== -1)
1406 h
->drv
[drv_index
].LunID
= lunid
;
1407 cciss_update_drive_info(ctlr
, drv_index
);
1413 h
->busy_configuring
= 0;
1414 /* We return -1 here to tell the ACU that we have registered/updated
1415 * all of the drives that we can and to keep it from calling us
1420 printk(KERN_ERR
"cciss: out of memory\n");
1424 /* This function will deregister the disk and it's queue from the
1425 * kernel. It must be called with the controller lock held and the
1426 * drv structures busy_configuring flag set. It's parameters are:
1428 * disk = This is the disk to be deregistered
1429 * drv = This is the drive_info_struct associated with the disk to be
1430 * deregistered. It contains information about the disk used
1432 * clear_all = This flag determines whether or not the disk information
1433 * is going to be completely cleared out and the highest_lun
1434 * reset. Sometimes we want to clear out information about
1435 * the disk in preperation for re-adding it. In this case
1436 * the highest_lun should be left unchanged and the LunID
1437 * should not be cleared.
1439 static int deregister_disk(struct gendisk
*disk
, drive_info_struct
*drv
,
1442 ctlr_info_t
*h
= get_host(disk
);
1444 if (!capable(CAP_SYS_RAWIO
))
1447 /* make sure logical volume is NOT is use */
1448 if(clear_all
|| (h
->gendisk
[0] == disk
)) {
1449 if (drv
->usage_count
> 1)
1453 if( drv
->usage_count
> 0 )
1456 /* invalidate the devices and deregister the disk. If it is disk
1457 * zero do not deregister it but just zero out it's values. This
1458 * allows us to delete disk zero but keep the controller registered.
1460 if (h
->gendisk
[0] != disk
){
1461 if (disk
->flags
& GENHD_FL_UP
){
1462 blk_cleanup_queue(disk
->queue
);
1469 /* zero out the disk size info */
1471 drv
->block_size
= 0;
1475 drv
->raid_level
= -1; /* This can be used as a flag variable to
1476 * indicate that this element of the drive
1481 /* check to see if it was the last disk */
1482 if (drv
== h
->drv
+ h
->highest_lun
) {
1483 /* if so, find the new hightest lun */
1484 int i
, newhighest
=-1;
1485 for(i
=0; i
<h
->highest_lun
; i
++) {
1486 /* if the disk has size > 0, it is available */
1487 if (h
->drv
[i
].heads
)
1490 h
->highest_lun
= newhighest
;
1498 static int fill_cmd(CommandList_struct
*c
, __u8 cmd
, int ctlr
, void *buff
,
1500 unsigned int use_unit_num
, /* 0: address the controller,
1501 1: address logical volume log_unit,
1502 2: periph device address is scsi3addr */
1503 unsigned int log_unit
, __u8 page_code
, unsigned char *scsi3addr
,
1506 ctlr_info_t
*h
= hba
[ctlr
];
1507 u64bit buff_dma_handle
;
1510 c
->cmd_type
= CMD_IOCTL_PEND
;
1511 c
->Header
.ReplyQueue
= 0;
1513 c
->Header
.SGList
= 1;
1514 c
->Header
.SGTotal
= 1;
1516 c
->Header
.SGList
= 0;
1517 c
->Header
.SGTotal
= 0;
1519 c
->Header
.Tag
.lower
= c
->busaddr
;
1521 c
->Request
.Type
.Type
= cmd_type
;
1522 if (cmd_type
== TYPE_CMD
) {
1525 /* If the logical unit number is 0 then, this is going
1526 to controller so It's a physical command
1527 mode = 0 target = 0. So we have nothing to write.
1528 otherwise, if use_unit_num == 1,
1529 mode = 1(volume set addressing) target = LUNID
1530 otherwise, if use_unit_num == 2,
1531 mode = 0(periph dev addr) target = scsi3addr */
1532 if (use_unit_num
== 1) {
1533 c
->Header
.LUN
.LogDev
.VolId
=
1534 h
->drv
[log_unit
].LunID
;
1535 c
->Header
.LUN
.LogDev
.Mode
= 1;
1536 } else if (use_unit_num
== 2) {
1537 memcpy(c
->Header
.LUN
.LunAddrBytes
,scsi3addr
,8);
1538 c
->Header
.LUN
.LogDev
.Mode
= 0;
1540 /* are we trying to read a vital product page */
1541 if(page_code
!= 0) {
1542 c
->Request
.CDB
[1] = 0x01;
1543 c
->Request
.CDB
[2] = page_code
;
1545 c
->Request
.CDBLen
= 6;
1546 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1547 c
->Request
.Type
.Direction
= XFER_READ
;
1548 c
->Request
.Timeout
= 0;
1549 c
->Request
.CDB
[0] = CISS_INQUIRY
;
1550 c
->Request
.CDB
[4] = size
& 0xFF;
1552 case CISS_REPORT_LOG
:
1553 case CISS_REPORT_PHYS
:
1554 /* Talking to controller so It's a physical command
1555 mode = 00 target = 0. Nothing to write.
1557 c
->Request
.CDBLen
= 12;
1558 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1559 c
->Request
.Type
.Direction
= XFER_READ
;
1560 c
->Request
.Timeout
= 0;
1561 c
->Request
.CDB
[0] = cmd
;
1562 c
->Request
.CDB
[6] = (size
>> 24) & 0xFF; //MSB
1563 c
->Request
.CDB
[7] = (size
>> 16) & 0xFF;
1564 c
->Request
.CDB
[8] = (size
>> 8) & 0xFF;
1565 c
->Request
.CDB
[9] = size
& 0xFF;
1568 case CCISS_READ_CAPACITY
:
1569 c
->Header
.LUN
.LogDev
.VolId
= h
->drv
[log_unit
].LunID
;
1570 c
->Header
.LUN
.LogDev
.Mode
= 1;
1571 c
->Request
.CDBLen
= 10;
1572 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1573 c
->Request
.Type
.Direction
= XFER_READ
;
1574 c
->Request
.Timeout
= 0;
1575 c
->Request
.CDB
[0] = cmd
;
1577 case CCISS_CACHE_FLUSH
:
1578 c
->Request
.CDBLen
= 12;
1579 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1580 c
->Request
.Type
.Direction
= XFER_WRITE
;
1581 c
->Request
.Timeout
= 0;
1582 c
->Request
.CDB
[0] = BMIC_WRITE
;
1583 c
->Request
.CDB
[6] = BMIC_CACHE_FLUSH
;
1587 "cciss%d: Unknown Command 0x%c\n", ctlr
, cmd
);
1590 } else if (cmd_type
== TYPE_MSG
) {
1592 case 3: /* No-Op message */
1593 c
->Request
.CDBLen
= 1;
1594 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1595 c
->Request
.Type
.Direction
= XFER_WRITE
;
1596 c
->Request
.Timeout
= 0;
1597 c
->Request
.CDB
[0] = cmd
;
1601 "cciss%d: unknown message type %d\n",
1607 "cciss%d: unknown command type %d\n", ctlr
, cmd_type
);
1610 /* Fill in the scatter gather information */
1612 buff_dma_handle
.val
= (__u64
) pci_map_single(h
->pdev
,
1613 buff
, size
, PCI_DMA_BIDIRECTIONAL
);
1614 c
->SG
[0].Addr
.lower
= buff_dma_handle
.val32
.lower
;
1615 c
->SG
[0].Addr
.upper
= buff_dma_handle
.val32
.upper
;
1616 c
->SG
[0].Len
= size
;
1617 c
->SG
[0].Ext
= 0; /* we are not chaining */
1621 static int sendcmd_withirq(__u8 cmd
,
1625 unsigned int use_unit_num
,
1626 unsigned int log_unit
,
1630 ctlr_info_t
*h
= hba
[ctlr
];
1631 CommandList_struct
*c
;
1632 u64bit buff_dma_handle
;
1633 unsigned long flags
;
1635 DECLARE_COMPLETION(wait
);
1637 if ((c
= cmd_alloc(h
, 0)) == NULL
)
1639 return_status
= fill_cmd(c
, cmd
, ctlr
, buff
, size
, use_unit_num
,
1640 log_unit
, page_code
, NULL
, cmd_type
);
1641 if (return_status
!= IO_OK
) {
1643 return return_status
;
1648 /* Put the request on the tail of the queue and send it */
1649 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1653 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1655 wait_for_completion(&wait
);
1657 if(c
->err_info
->CommandStatus
!= 0)
1658 { /* an error has occurred */
1659 switch(c
->err_info
->CommandStatus
)
1661 case CMD_TARGET_STATUS
:
1662 printk(KERN_WARNING
"cciss: cmd %p has "
1663 " completed with errors\n", c
);
1664 if( c
->err_info
->ScsiStatus
)
1666 printk(KERN_WARNING
"cciss: cmd %p "
1667 "has SCSI Status = %x\n",
1669 c
->err_info
->ScsiStatus
);
1673 case CMD_DATA_UNDERRUN
:
1674 case CMD_DATA_OVERRUN
:
1675 /* expected for inquire and report lun commands */
1678 printk(KERN_WARNING
"cciss: Cmd %p is "
1679 "reported invalid\n", c
);
1680 return_status
= IO_ERROR
;
1682 case CMD_PROTOCOL_ERR
:
1683 printk(KERN_WARNING
"cciss: cmd %p has "
1684 "protocol error \n", c
);
1685 return_status
= IO_ERROR
;
1687 case CMD_HARDWARE_ERR
:
1688 printk(KERN_WARNING
"cciss: cmd %p had "
1689 " hardware error\n", c
);
1690 return_status
= IO_ERROR
;
1692 case CMD_CONNECTION_LOST
:
1693 printk(KERN_WARNING
"cciss: cmd %p had "
1694 "connection lost\n", c
);
1695 return_status
= IO_ERROR
;
1698 printk(KERN_WARNING
"cciss: cmd %p was "
1700 return_status
= IO_ERROR
;
1702 case CMD_ABORT_FAILED
:
1703 printk(KERN_WARNING
"cciss: cmd %p reports "
1704 "abort failed\n", c
);
1705 return_status
= IO_ERROR
;
1707 case CMD_UNSOLICITED_ABORT
:
1709 "cciss%d: unsolicited abort %p\n",
1711 if (c
->retry_count
< MAX_CMD_RETRIES
) {
1713 "cciss%d: retrying %p\n",
1716 /* erase the old error information */
1717 memset(c
->err_info
, 0,
1718 sizeof(ErrorInfo_struct
));
1719 return_status
= IO_OK
;
1720 INIT_COMPLETION(wait
);
1723 return_status
= IO_ERROR
;
1726 printk(KERN_WARNING
"cciss: cmd %p returned "
1727 "unknown status %x\n", c
,
1728 c
->err_info
->CommandStatus
);
1729 return_status
= IO_ERROR
;
1732 /* unlock the buffers from DMA */
1733 pci_unmap_single( h
->pdev
, (dma_addr_t
) buff_dma_handle
.val
,
1734 size
, PCI_DMA_BIDIRECTIONAL
);
1736 return(return_status
);
1739 static void cciss_geometry_inquiry(int ctlr
, int logvol
,
1740 int withirq
, unsigned int total_size
,
1741 unsigned int block_size
, InquiryData_struct
*inq_buff
,
1742 drive_info_struct
*drv
)
1745 memset(inq_buff
, 0, sizeof(InquiryData_struct
));
1747 return_code
= sendcmd_withirq(CISS_INQUIRY
, ctlr
,
1748 inq_buff
, sizeof(*inq_buff
), 1, logvol
,0xC1, TYPE_CMD
);
1750 return_code
= sendcmd(CISS_INQUIRY
, ctlr
, inq_buff
,
1751 sizeof(*inq_buff
), 1, logvol
,0xC1, NULL
, TYPE_CMD
);
1752 if (return_code
== IO_OK
) {
1753 if(inq_buff
->data_byte
[8] == 0xFF) {
1755 "cciss: reading geometry failed, volume "
1756 "does not support reading geometry\n");
1757 drv
->block_size
= block_size
;
1758 drv
->nr_blocks
= total_size
;
1760 drv
->sectors
= 32; // Sectors per track
1761 drv
->cylinders
= total_size
/ 255 / 32;
1765 drv
->block_size
= block_size
;
1766 drv
->nr_blocks
= total_size
;
1767 drv
->heads
= inq_buff
->data_byte
[6];
1768 drv
->sectors
= inq_buff
->data_byte
[7];
1769 drv
->cylinders
= (inq_buff
->data_byte
[4] & 0xff) << 8;
1770 drv
->cylinders
+= inq_buff
->data_byte
[5];
1771 drv
->raid_level
= inq_buff
->data_byte
[8];
1772 t
= drv
->heads
* drv
->sectors
;
1774 drv
->cylinders
= total_size
/t
;
1777 } else { /* Get geometry failed */
1778 printk(KERN_WARNING
"cciss: reading geometry failed\n");
1780 printk(KERN_INFO
" heads= %d, sectors= %d, cylinders= %d\n\n",
1781 drv
->heads
, drv
->sectors
, drv
->cylinders
);
1784 cciss_read_capacity(int ctlr
, int logvol
, ReadCapdata_struct
*buf
,
1785 int withirq
, unsigned int *total_size
, unsigned int *block_size
)
1788 memset(buf
, 0, sizeof(*buf
));
1790 return_code
= sendcmd_withirq(CCISS_READ_CAPACITY
,
1791 ctlr
, buf
, sizeof(*buf
), 1, logvol
, 0, TYPE_CMD
);
1793 return_code
= sendcmd(CCISS_READ_CAPACITY
,
1794 ctlr
, buf
, sizeof(*buf
), 1, logvol
, 0, NULL
, TYPE_CMD
);
1795 if (return_code
== IO_OK
) {
1796 *total_size
= be32_to_cpu(*((__be32
*) &buf
->total_size
[0]))+1;
1797 *block_size
= be32_to_cpu(*((__be32
*) &buf
->block_size
[0]));
1798 } else { /* read capacity command failed */
1799 printk(KERN_WARNING
"cciss: read capacity failed\n");
1801 *block_size
= BLOCK_SIZE
;
1803 printk(KERN_INFO
" blocks= %u block_size= %d\n",
1804 *total_size
, *block_size
);
1808 static int cciss_revalidate(struct gendisk
*disk
)
1810 ctlr_info_t
*h
= get_host(disk
);
1811 drive_info_struct
*drv
= get_drv(disk
);
1814 unsigned int block_size
;
1815 unsigned int total_size
;
1816 ReadCapdata_struct
*size_buff
= NULL
;
1817 InquiryData_struct
*inq_buff
= NULL
;
1819 for(logvol
=0; logvol
< CISS_MAX_LUN
; logvol
++)
1821 if(h
->drv
[logvol
].LunID
== drv
->LunID
) {
1827 if (!FOUND
) return 1;
1829 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
1830 if (size_buff
== NULL
)
1832 printk(KERN_WARNING
"cciss: out of memory\n");
1835 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
1836 if (inq_buff
== NULL
)
1838 printk(KERN_WARNING
"cciss: out of memory\n");
1843 cciss_read_capacity(h
->ctlr
, logvol
, size_buff
, 1, &total_size
, &block_size
);
1844 cciss_geometry_inquiry(h
->ctlr
, logvol
, 1, total_size
, block_size
, inq_buff
, drv
);
1846 blk_queue_hardsect_size(drv
->queue
, drv
->block_size
);
1847 set_capacity(disk
, drv
->nr_blocks
);
1855 * Wait polling for a command to complete.
1856 * The memory mapped FIFO is polled for the completion.
1857 * Used only at init time, interrupts from the HBA are disabled.
1859 static unsigned long pollcomplete(int ctlr
)
1864 /* Wait (up to 20 seconds) for a command to complete */
1866 for (i
= 20 * HZ
; i
> 0; i
--) {
1867 done
= hba
[ctlr
]->access
.command_completed(hba
[ctlr
]);
1868 if (done
== FIFO_EMPTY
)
1869 schedule_timeout_uninterruptible(1);
1873 /* Invalid address to tell caller we ran out of time */
1877 * Send a command to the controller, and wait for it to complete.
1878 * Only used at init time.
1885 unsigned int use_unit_num
, /* 0: address the controller,
1886 1: address logical volume log_unit,
1887 2: periph device address is scsi3addr */
1888 unsigned int log_unit
,
1890 unsigned char *scsi3addr
,
1893 CommandList_struct
*c
;
1895 unsigned long complete
;
1896 ctlr_info_t
*info_p
= hba
[ctlr
];
1897 u64bit buff_dma_handle
;
1900 if ((c
= cmd_alloc(info_p
, 1)) == NULL
) {
1901 printk(KERN_WARNING
"cciss: unable to get memory");
1904 status
= fill_cmd(c
, cmd
, ctlr
, buff
, size
, use_unit_num
,
1905 log_unit
, page_code
, scsi3addr
, cmd_type
);
1906 if (status
!= IO_OK
) {
1907 cmd_free(info_p
, c
, 1);
1915 printk(KERN_DEBUG
"cciss: turning intr off\n");
1916 #endif /* CCISS_DEBUG */
1917 info_p
->access
.set_intr_mask(info_p
, CCISS_INTR_OFF
);
1919 /* Make sure there is room in the command FIFO */
1920 /* Actually it should be completely empty at this time. */
1921 for (i
= 200000; i
> 0; i
--)
1923 /* if fifo isn't full go */
1924 if (!(info_p
->access
.fifo_full(info_p
)))
1930 printk(KERN_WARNING
"cciss cciss%d: SendCmd FIFO full,"
1931 " waiting!\n", ctlr
);
1936 info_p
->access
.submit_command(info_p
, c
);
1937 complete
= pollcomplete(ctlr
);
1940 printk(KERN_DEBUG
"cciss: command completed\n");
1941 #endif /* CCISS_DEBUG */
1943 if (complete
!= 1) {
1944 if ( (complete
& CISS_ERROR_BIT
)
1945 && (complete
& ~CISS_ERROR_BIT
) == c
->busaddr
)
1947 /* if data overrun or underun on Report command
1950 if (((c
->Request
.CDB
[0] == CISS_REPORT_LOG
) ||
1951 (c
->Request
.CDB
[0] == CISS_REPORT_PHYS
) ||
1952 (c
->Request
.CDB
[0] == CISS_INQUIRY
)) &&
1953 ((c
->err_info
->CommandStatus
==
1954 CMD_DATA_OVERRUN
) ||
1955 (c
->err_info
->CommandStatus
==
1959 complete
= c
->busaddr
;
1961 if (c
->err_info
->CommandStatus
==
1962 CMD_UNSOLICITED_ABORT
) {
1963 printk(KERN_WARNING
"cciss%d: "
1964 "unsolicited abort %p\n",
1966 if (c
->retry_count
< MAX_CMD_RETRIES
) {
1968 "cciss%d: retrying %p\n",
1971 /* erase the old error */
1973 memset(c
->err_info
, 0,
1974 sizeof(ErrorInfo_struct
));
1978 "cciss%d: retried %p too "
1979 "many times\n", ctlr
, c
);
1984 printk(KERN_WARNING
"ciss ciss%d: sendcmd"
1985 " Error %x \n", ctlr
,
1986 c
->err_info
->CommandStatus
);
1987 printk(KERN_WARNING
"ciss ciss%d: sendcmd"
1989 " size %x\n num %x value %x\n", ctlr
,
1990 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_size
,
1991 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_num
,
1992 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_value
);
1997 if (complete
!= c
->busaddr
) {
1998 printk( KERN_WARNING
"cciss cciss%d: SendCmd "
1999 "Invalid command list address returned! (%lx)\n",
2005 printk( KERN_WARNING
2006 "cciss cciss%d: SendCmd Timeout out, "
2007 "No command list address returned!\n",
2013 /* unlock the data buffer from DMA */
2014 pci_unmap_single(info_p
->pdev
, (dma_addr_t
) buff_dma_handle
.val
,
2015 size
, PCI_DMA_BIDIRECTIONAL
);
2016 cmd_free(info_p
, c
, 1);
2020 * Map (physical) PCI mem into (virtual) kernel space
2022 static void __iomem
*remap_pci_mem(ulong base
, ulong size
)
2024 ulong page_base
= ((ulong
) base
) & PAGE_MASK
;
2025 ulong page_offs
= ((ulong
) base
) - page_base
;
2026 void __iomem
*page_remapped
= ioremap(page_base
, page_offs
+size
);
2028 return page_remapped
? (page_remapped
+ page_offs
) : NULL
;
2032 * Takes jobs of the Q and sends them to the hardware, then puts it on
2033 * the Q to wait for completion.
2035 static void start_io( ctlr_info_t
*h
)
2037 CommandList_struct
*c
;
2039 while(( c
= h
->reqQ
) != NULL
)
2041 /* can't do anything if fifo is full */
2042 if ((h
->access
.fifo_full(h
))) {
2043 printk(KERN_WARNING
"cciss: fifo full\n");
2047 /* Get the frist entry from the Request Q */
2048 removeQ(&(h
->reqQ
), c
);
2051 /* Tell the controller execute command */
2052 h
->access
.submit_command(h
, c
);
2054 /* Put job onto the completed Q */
2055 addQ (&(h
->cmpQ
), c
);
2059 static inline void complete_buffers(struct bio
*bio
, int status
)
2062 struct bio
*xbh
= bio
->bi_next
;
2063 int nr_sectors
= bio_sectors(bio
);
2065 bio
->bi_next
= NULL
;
2066 blk_finished_io(len
);
2067 bio_endio(bio
, nr_sectors
<< 9, status
? 0 : -EIO
);
2072 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2073 /* Zeros out the error record and then resends the command back */
2074 /* to the controller */
2075 static inline void resend_cciss_cmd( ctlr_info_t
*h
, CommandList_struct
*c
)
2077 /* erase the old error information */
2078 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
2080 /* add it to software queue and then send it to the controller */
2083 if(h
->Qdepth
> h
->maxQsinceinit
)
2084 h
->maxQsinceinit
= h
->Qdepth
;
2088 /* checks the status of the job and calls complete buffers to mark all
2089 * buffers for the completed job.
2091 static inline void complete_command( ctlr_info_t
*h
, CommandList_struct
*cmd
,
2102 if(cmd
->err_info
->CommandStatus
!= 0)
2103 { /* an error has occurred */
2104 switch(cmd
->err_info
->CommandStatus
)
2106 unsigned char sense_key
;
2107 case CMD_TARGET_STATUS
:
2110 if( cmd
->err_info
->ScsiStatus
== 0x02)
2112 printk(KERN_WARNING
"cciss: cmd %p "
2113 "has CHECK CONDITION "
2114 " byte 2 = 0x%x\n", cmd
,
2115 cmd
->err_info
->SenseInfo
[2]
2117 /* check the sense key */
2119 cmd
->err_info
->SenseInfo
[2];
2120 /* no status or recovered error */
2121 if((sense_key
== 0x0) ||
2128 printk(KERN_WARNING
"cciss: cmd %p "
2129 "has SCSI Status 0x%x\n",
2130 cmd
, cmd
->err_info
->ScsiStatus
);
2133 case CMD_DATA_UNDERRUN
:
2134 printk(KERN_WARNING
"cciss: cmd %p has"
2135 " completed with data underrun "
2138 case CMD_DATA_OVERRUN
:
2139 printk(KERN_WARNING
"cciss: cmd %p has"
2140 " completed with data overrun "
2144 printk(KERN_WARNING
"cciss: cmd %p is "
2145 "reported invalid\n", cmd
);
2148 case CMD_PROTOCOL_ERR
:
2149 printk(KERN_WARNING
"cciss: cmd %p has "
2150 "protocol error \n", cmd
);
2153 case CMD_HARDWARE_ERR
:
2154 printk(KERN_WARNING
"cciss: cmd %p had "
2155 " hardware error\n", cmd
);
2158 case CMD_CONNECTION_LOST
:
2159 printk(KERN_WARNING
"cciss: cmd %p had "
2160 "connection lost\n", cmd
);
2164 printk(KERN_WARNING
"cciss: cmd %p was "
2168 case CMD_ABORT_FAILED
:
2169 printk(KERN_WARNING
"cciss: cmd %p reports "
2170 "abort failed\n", cmd
);
2173 case CMD_UNSOLICITED_ABORT
:
2174 printk(KERN_WARNING
"cciss%d: unsolicited "
2175 "abort %p\n", h
->ctlr
, cmd
);
2176 if (cmd
->retry_count
< MAX_CMD_RETRIES
) {
2179 "cciss%d: retrying %p\n",
2184 "cciss%d: %p retried too "
2185 "many times\n", h
->ctlr
, cmd
);
2189 printk(KERN_WARNING
"cciss: cmd %p timedout\n",
2194 printk(KERN_WARNING
"cciss: cmd %p returned "
2195 "unknown status %x\n", cmd
,
2196 cmd
->err_info
->CommandStatus
);
2200 /* We need to return this command */
2202 resend_cciss_cmd(h
,cmd
);
2205 /* command did not need to be retried */
2206 /* unmap the DMA mapping for all the scatter gather elements */
2207 for(i
=0; i
<cmd
->Header
.SGList
; i
++) {
2208 temp64
.val32
.lower
= cmd
->SG
[i
].Addr
.lower
;
2209 temp64
.val32
.upper
= cmd
->SG
[i
].Addr
.upper
;
2210 pci_unmap_page(hba
[cmd
->ctlr
]->pdev
,
2211 temp64
.val
, cmd
->SG
[i
].Len
,
2212 (cmd
->Request
.Type
.Direction
== XFER_READ
) ?
2213 PCI_DMA_FROMDEVICE
: PCI_DMA_TODEVICE
);
2215 complete_buffers(cmd
->rq
->bio
, status
);
2218 printk("Done with %p\n", cmd
->rq
);
2219 #endif /* CCISS_DEBUG */
2221 end_that_request_last(cmd
->rq
);
2226 * Get a request and submit it to the controller.
2228 static void do_cciss_request(request_queue_t
*q
)
2230 ctlr_info_t
*h
= q
->queuedata
;
2231 CommandList_struct
*c
;
2233 struct request
*creq
;
2235 struct scatterlist tmp_sg
[MAXSGENTRIES
];
2236 drive_info_struct
*drv
;
2239 /* We call start_io here in case there is a command waiting on the
2240 * queue that has not been sent.
2242 if (blk_queue_plugged(q
))
2246 creq
= elv_next_request(q
);
2250 if (creq
->nr_phys_segments
> MAXSGENTRIES
)
2253 if (( c
= cmd_alloc(h
, 1)) == NULL
)
2256 blkdev_dequeue_request(creq
);
2258 spin_unlock_irq(q
->queue_lock
);
2260 c
->cmd_type
= CMD_RWREQ
;
2263 /* fill in the request */
2264 drv
= creq
->rq_disk
->private_data
;
2265 c
->Header
.ReplyQueue
= 0; // unused in simple mode
2266 /* got command from pool, so use the command block index instead */
2267 /* for direct lookups. */
2268 /* The first 2 bits are reserved for controller error reporting. */
2269 c
->Header
.Tag
.lower
= (c
->cmdindex
<< 3);
2270 c
->Header
.Tag
.lower
|= 0x04; /* flag for direct lookup. */
2271 c
->Header
.LUN
.LogDev
.VolId
= drv
->LunID
;
2272 c
->Header
.LUN
.LogDev
.Mode
= 1;
2273 c
->Request
.CDBLen
= 10; // 12 byte commands not in FW yet;
2274 c
->Request
.Type
.Type
= TYPE_CMD
; // It is a command.
2275 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
2276 c
->Request
.Type
.Direction
=
2277 (rq_data_dir(creq
) == READ
) ? XFER_READ
: XFER_WRITE
;
2278 c
->Request
.Timeout
= 0; // Don't time out
2279 c
->Request
.CDB
[0] = (rq_data_dir(creq
) == READ
) ? CCISS_READ
: CCISS_WRITE
;
2280 start_blk
= creq
->sector
;
2282 printk(KERN_DEBUG
"ciss: sector =%d nr_sectors=%d\n",(int) creq
->sector
,
2283 (int) creq
->nr_sectors
);
2284 #endif /* CCISS_DEBUG */
2286 seg
= blk_rq_map_sg(q
, creq
, tmp_sg
);
2288 /* get the DMA records for the setup */
2289 if (c
->Request
.Type
.Direction
== XFER_READ
)
2290 dir
= PCI_DMA_FROMDEVICE
;
2292 dir
= PCI_DMA_TODEVICE
;
2294 for (i
=0; i
<seg
; i
++)
2296 c
->SG
[i
].Len
= tmp_sg
[i
].length
;
2297 temp64
.val
= (__u64
) pci_map_page(h
->pdev
, tmp_sg
[i
].page
,
2298 tmp_sg
[i
].offset
, tmp_sg
[i
].length
,
2300 c
->SG
[i
].Addr
.lower
= temp64
.val32
.lower
;
2301 c
->SG
[i
].Addr
.upper
= temp64
.val32
.upper
;
2302 c
->SG
[i
].Ext
= 0; // we are not chaining
2304 /* track how many SG entries we are using */
2309 printk(KERN_DEBUG
"cciss: Submitting %d sectors in %d segments\n", creq
->nr_sectors
, seg
);
2310 #endif /* CCISS_DEBUG */
2312 c
->Header
.SGList
= c
->Header
.SGTotal
= seg
;
2313 c
->Request
.CDB
[1]= 0;
2314 c
->Request
.CDB
[2]= (start_blk
>> 24) & 0xff; //MSB
2315 c
->Request
.CDB
[3]= (start_blk
>> 16) & 0xff;
2316 c
->Request
.CDB
[4]= (start_blk
>> 8) & 0xff;
2317 c
->Request
.CDB
[5]= start_blk
& 0xff;
2318 c
->Request
.CDB
[6]= 0; // (sect >> 24) & 0xff; MSB
2319 c
->Request
.CDB
[7]= (creq
->nr_sectors
>> 8) & 0xff;
2320 c
->Request
.CDB
[8]= creq
->nr_sectors
& 0xff;
2321 c
->Request
.CDB
[9] = c
->Request
.CDB
[11] = c
->Request
.CDB
[12] = 0;
2323 spin_lock_irq(q
->queue_lock
);
2327 if(h
->Qdepth
> h
->maxQsinceinit
)
2328 h
->maxQsinceinit
= h
->Qdepth
;
2334 /* We will already have the driver lock here so not need
2340 static irqreturn_t
do_cciss_intr(int irq
, void *dev_id
, struct pt_regs
*regs
)
2342 ctlr_info_t
*h
= dev_id
;
2343 CommandList_struct
*c
;
2344 unsigned long flags
;
2347 int start_queue
= h
->next_to_run
;
2349 /* Is this interrupt for us? */
2350 if (( h
->access
.intr_pending(h
) == 0) || (h
->interrupts_enabled
== 0))
2354 * If there are completed commands in the completion queue,
2355 * we had better do something about it.
2357 spin_lock_irqsave(CCISS_LOCK(h
->ctlr
), flags
);
2358 while( h
->access
.intr_pending(h
))
2360 while((a
= h
->access
.command_completed(h
)) != FIFO_EMPTY
)
2365 if (a2
>= NR_CMDS
) {
2366 printk(KERN_WARNING
"cciss: controller cciss%d failed, stopping.\n", h
->ctlr
);
2367 fail_all_cmds(h
->ctlr
);
2371 c
= h
->cmd_pool
+ a2
;
2376 if ((c
= h
->cmpQ
) == NULL
) {
2377 printk(KERN_WARNING
"cciss: Completion of %08x ignored\n", a1
);
2380 while(c
->busaddr
!= a
) {
2387 * If we've found the command, take it off the
2388 * completion Q and free it
2390 if (c
->busaddr
== a
) {
2391 removeQ(&h
->cmpQ
, c
);
2392 if (c
->cmd_type
== CMD_RWREQ
) {
2393 complete_command(h
, c
, 0);
2394 } else if (c
->cmd_type
== CMD_IOCTL_PEND
) {
2395 complete(c
->waiting
);
2397 # ifdef CONFIG_CISS_SCSI_TAPE
2398 else if (c
->cmd_type
== CMD_SCSI
)
2399 complete_scsi_command(c
, 0, a1
);
2406 /* check to see if we have maxed out the number of commands that can
2407 * be placed on the queue. If so then exit. We do this check here
2408 * in case the interrupt we serviced was from an ioctl and did not
2409 * free any new commands.
2411 if ((find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
)) == NR_CMDS
)
2414 /* We have room on the queue for more commands. Now we need to queue
2415 * them up. We will also keep track of the next queue to run so
2416 * that every queue gets a chance to be started first.
2418 for (j
=0; j
< h
->highest_lun
+ 1; j
++){
2419 int curr_queue
= (start_queue
+ j
) % (h
->highest_lun
+ 1);
2420 /* make sure the disk has been added and the drive is real
2421 * because this can be called from the middle of init_one.
2423 if(!(h
->drv
[curr_queue
].queue
) ||
2424 !(h
->drv
[curr_queue
].heads
))
2426 blk_start_queue(h
->gendisk
[curr_queue
]->queue
);
2428 /* check to see if we have maxed out the number of commands
2429 * that can be placed on the queue.
2431 if ((find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
)) == NR_CMDS
)
2433 if (curr_queue
== start_queue
){
2434 h
->next_to_run
= (start_queue
+ 1) % (h
->highest_lun
+ 1);
2437 h
->next_to_run
= curr_queue
;
2441 curr_queue
= (curr_queue
+ 1) % (h
->highest_lun
+ 1);
2446 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
2450 * We cannot read the structure directly, for portablity we must use
2452 * This is for debug only.
2455 static void print_cfg_table( CfgTable_struct
*tb
)
2460 printk("Controller Configuration information\n");
2461 printk("------------------------------------\n");
2463 temp_name
[i
] = readb(&(tb
->Signature
[i
]));
2465 printk(" Signature = %s\n", temp_name
);
2466 printk(" Spec Number = %d\n", readl(&(tb
->SpecValence
)));
2467 printk(" Transport methods supported = 0x%x\n",
2468 readl(&(tb
-> TransportSupport
)));
2469 printk(" Transport methods active = 0x%x\n",
2470 readl(&(tb
->TransportActive
)));
2471 printk(" Requested transport Method = 0x%x\n",
2472 readl(&(tb
->HostWrite
.TransportRequest
)));
2473 printk(" Coalese Interrupt Delay = 0x%x\n",
2474 readl(&(tb
->HostWrite
.CoalIntDelay
)));
2475 printk(" Coalese Interrupt Count = 0x%x\n",
2476 readl(&(tb
->HostWrite
.CoalIntCount
)));
2477 printk(" Max outstanding commands = 0x%d\n",
2478 readl(&(tb
->CmdsOutMax
)));
2479 printk(" Bus Types = 0x%x\n", readl(&(tb
-> BusTypes
)));
2481 temp_name
[i
] = readb(&(tb
->ServerName
[i
]));
2482 temp_name
[16] = '\0';
2483 printk(" Server Name = %s\n", temp_name
);
2484 printk(" Heartbeat Counter = 0x%x\n\n\n",
2485 readl(&(tb
->HeartBeat
)));
2487 #endif /* CCISS_DEBUG */
2489 static void release_io_mem(ctlr_info_t
*c
)
2491 /* if IO mem was not protected do nothing */
2492 if( c
->io_mem_addr
== 0)
2494 release_region(c
->io_mem_addr
, c
->io_mem_length
);
2496 c
->io_mem_length
= 0;
2499 static int find_PCI_BAR_index(struct pci_dev
*pdev
,
2500 unsigned long pci_bar_addr
)
2502 int i
, offset
, mem_type
, bar_type
;
2503 if (pci_bar_addr
== PCI_BASE_ADDRESS_0
) /* looking for BAR zero? */
2506 for (i
=0; i
<DEVICE_COUNT_RESOURCE
; i
++) {
2507 bar_type
= pci_resource_flags(pdev
, i
) &
2508 PCI_BASE_ADDRESS_SPACE
;
2509 if (bar_type
== PCI_BASE_ADDRESS_SPACE_IO
)
2512 mem_type
= pci_resource_flags(pdev
, i
) &
2513 PCI_BASE_ADDRESS_MEM_TYPE_MASK
;
2515 case PCI_BASE_ADDRESS_MEM_TYPE_32
:
2516 case PCI_BASE_ADDRESS_MEM_TYPE_1M
:
2517 offset
+= 4; /* 32 bit */
2519 case PCI_BASE_ADDRESS_MEM_TYPE_64
:
2522 default: /* reserved in PCI 2.2 */
2523 printk(KERN_WARNING
"Base address is invalid\n");
2528 if (offset
== pci_bar_addr
- PCI_BASE_ADDRESS_0
)
2534 static int cciss_pci_init(ctlr_info_t
*c
, struct pci_dev
*pdev
)
2536 ushort subsystem_vendor_id
, subsystem_device_id
, command
;
2537 __u32 board_id
, scratchpad
= 0;
2539 __u32 cfg_base_addr
;
2540 __u64 cfg_base_addr_index
;
2543 /* check to see if controller has been disabled */
2544 /* BEFORE trying to enable it */
2545 (void) pci_read_config_word(pdev
, PCI_COMMAND
,&command
);
2546 if(!(command
& 0x02))
2548 printk(KERN_WARNING
"cciss: controller appears to be disabled\n");
2552 if (pci_enable_device(pdev
))
2554 printk(KERN_ERR
"cciss: Unable to Enable PCI device\n");
2558 subsystem_vendor_id
= pdev
->subsystem_vendor
;
2559 subsystem_device_id
= pdev
->subsystem_device
;
2560 board_id
= (((__u32
) (subsystem_device_id
<< 16) & 0xffff0000) |
2561 subsystem_vendor_id
);
2563 /* search for our IO range so we can protect it */
2564 for(i
=0; i
<DEVICE_COUNT_RESOURCE
; i
++)
2566 /* is this an IO range */
2567 if( pci_resource_flags(pdev
, i
) & 0x01 ) {
2568 c
->io_mem_addr
= pci_resource_start(pdev
, i
);
2569 c
->io_mem_length
= pci_resource_end(pdev
, i
) -
2570 pci_resource_start(pdev
, i
) +1;
2572 printk("IO value found base_addr[%d] %lx %lx\n", i
,
2573 c
->io_mem_addr
, c
->io_mem_length
);
2574 #endif /* CCISS_DEBUG */
2575 /* register the IO range */
2576 if(!request_region( c
->io_mem_addr
,
2577 c
->io_mem_length
, "cciss"))
2579 printk(KERN_WARNING
"cciss I/O memory range already in use addr=%lx length=%ld\n",
2580 c
->io_mem_addr
, c
->io_mem_length
);
2582 c
->io_mem_length
= 0;
2589 printk("command = %x\n", command
);
2590 printk("irq = %x\n", pdev
->irq
);
2591 printk("board_id = %x\n", board_id
);
2592 #endif /* CCISS_DEBUG */
2594 c
->intr
= pdev
->irq
;
2597 * Memory base addr is first addr , the second points to the config
2601 c
->paddr
= pci_resource_start(pdev
, 0); /* addressing mode bits already removed */
2603 printk("address 0 = %x\n", c
->paddr
);
2604 #endif /* CCISS_DEBUG */
2605 c
->vaddr
= remap_pci_mem(c
->paddr
, 200);
2607 /* Wait for the board to become ready. (PCI hotplug needs this.)
2608 * We poll for up to 120 secs, once per 100ms. */
2609 for (i
=0; i
< 1200; i
++) {
2610 scratchpad
= readl(c
->vaddr
+ SA5_SCRATCHPAD_OFFSET
);
2611 if (scratchpad
== CCISS_FIRMWARE_READY
)
2613 set_current_state(TASK_INTERRUPTIBLE
);
2614 schedule_timeout(HZ
/ 10); /* wait 100ms */
2616 if (scratchpad
!= CCISS_FIRMWARE_READY
) {
2617 printk(KERN_WARNING
"cciss: Board not ready. Timed out.\n");
2621 /* get the address index number */
2622 cfg_base_addr
= readl(c
->vaddr
+ SA5_CTCFG_OFFSET
);
2623 cfg_base_addr
&= (__u32
) 0x0000ffff;
2625 printk("cfg base address = %x\n", cfg_base_addr
);
2626 #endif /* CCISS_DEBUG */
2627 cfg_base_addr_index
=
2628 find_PCI_BAR_index(pdev
, cfg_base_addr
);
2630 printk("cfg base address index = %x\n", cfg_base_addr_index
);
2631 #endif /* CCISS_DEBUG */
2632 if (cfg_base_addr_index
== -1) {
2633 printk(KERN_WARNING
"cciss: Cannot find cfg_base_addr_index\n");
2638 cfg_offset
= readl(c
->vaddr
+ SA5_CTMEM_OFFSET
);
2640 printk("cfg offset = %x\n", cfg_offset
);
2641 #endif /* CCISS_DEBUG */
2642 c
->cfgtable
= remap_pci_mem(pci_resource_start(pdev
,
2643 cfg_base_addr_index
) + cfg_offset
,
2644 sizeof(CfgTable_struct
));
2645 c
->board_id
= board_id
;
2648 print_cfg_table(c
->cfgtable
);
2649 #endif /* CCISS_DEBUG */
2651 for(i
=0; i
<NR_PRODUCTS
; i
++) {
2652 if (board_id
== products
[i
].board_id
) {
2653 c
->product_name
= products
[i
].product_name
;
2654 c
->access
= *(products
[i
].access
);
2658 if (i
== NR_PRODUCTS
) {
2659 printk(KERN_WARNING
"cciss: Sorry, I don't know how"
2660 " to access the Smart Array controller %08lx\n",
2661 (unsigned long)board_id
);
2664 if ( (readb(&c
->cfgtable
->Signature
[0]) != 'C') ||
2665 (readb(&c
->cfgtable
->Signature
[1]) != 'I') ||
2666 (readb(&c
->cfgtable
->Signature
[2]) != 'S') ||
2667 (readb(&c
->cfgtable
->Signature
[3]) != 'S') )
2669 printk("Does not appear to be a valid CISS config table\n");
2675 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2677 prefetch
= readl(&(c
->cfgtable
->SCSI_Prefetch
));
2679 writel(prefetch
, &(c
->cfgtable
->SCSI_Prefetch
));
2684 printk("Trying to put board into Simple mode\n");
2685 #endif /* CCISS_DEBUG */
2686 c
->max_commands
= readl(&(c
->cfgtable
->CmdsOutMax
));
2687 /* Update the field, and then ring the doorbell */
2688 writel( CFGTBL_Trans_Simple
,
2689 &(c
->cfgtable
->HostWrite
.TransportRequest
));
2690 writel( CFGTBL_ChangeReq
, c
->vaddr
+ SA5_DOORBELL
);
2692 /* under certain very rare conditions, this can take awhile.
2693 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2694 * as we enter this code.) */
2695 for(i
=0;i
<MAX_CONFIG_WAIT
;i
++) {
2696 if (!(readl(c
->vaddr
+ SA5_DOORBELL
) & CFGTBL_ChangeReq
))
2698 /* delay and try again */
2699 set_current_state(TASK_INTERRUPTIBLE
);
2700 schedule_timeout(10);
2704 printk(KERN_DEBUG
"I counter got to %d %x\n", i
, readl(c
->vaddr
+ SA5_DOORBELL
));
2705 #endif /* CCISS_DEBUG */
2707 print_cfg_table(c
->cfgtable
);
2708 #endif /* CCISS_DEBUG */
2710 if (!(readl(&(c
->cfgtable
->TransportActive
)) & CFGTBL_Trans_Simple
))
2712 printk(KERN_WARNING
"cciss: unable to get board into"
2721 * Gets information about the local volumes attached to the controller.
2723 static void cciss_getgeometry(int cntl_num
)
2725 ReportLunData_struct
*ld_buff
;
2726 ReadCapdata_struct
*size_buff
;
2727 InquiryData_struct
*inq_buff
;
2735 ld_buff
= kmalloc(sizeof(ReportLunData_struct
), GFP_KERNEL
);
2736 if (ld_buff
== NULL
)
2738 printk(KERN_ERR
"cciss: out of memory\n");
2741 memset(ld_buff
, 0, sizeof(ReportLunData_struct
));
2742 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
2743 if (size_buff
== NULL
)
2745 printk(KERN_ERR
"cciss: out of memory\n");
2749 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
2750 if (inq_buff
== NULL
)
2752 printk(KERN_ERR
"cciss: out of memory\n");
2757 /* Get the firmware version */
2758 return_code
= sendcmd(CISS_INQUIRY
, cntl_num
, inq_buff
,
2759 sizeof(InquiryData_struct
), 0, 0 ,0, NULL
, TYPE_CMD
);
2760 if (return_code
== IO_OK
)
2762 hba
[cntl_num
]->firm_ver
[0] = inq_buff
->data_byte
[32];
2763 hba
[cntl_num
]->firm_ver
[1] = inq_buff
->data_byte
[33];
2764 hba
[cntl_num
]->firm_ver
[2] = inq_buff
->data_byte
[34];
2765 hba
[cntl_num
]->firm_ver
[3] = inq_buff
->data_byte
[35];
2766 } else /* send command failed */
2768 printk(KERN_WARNING
"cciss: unable to determine firmware"
2769 " version of controller\n");
2771 /* Get the number of logical volumes */
2772 return_code
= sendcmd(CISS_REPORT_LOG
, cntl_num
, ld_buff
,
2773 sizeof(ReportLunData_struct
), 0, 0, 0, NULL
, TYPE_CMD
);
2775 if( return_code
== IO_OK
)
2778 printk("LUN Data\n--------------------------\n");
2779 #endif /* CCISS_DEBUG */
2781 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[0])) << 24;
2782 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[1])) << 16;
2783 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[2])) << 8;
2784 listlength
|= 0xff & (unsigned int)(ld_buff
->LUNListLength
[3]);
2785 } else /* reading number of logical volumes failed */
2787 printk(KERN_WARNING
"cciss: report logical volume"
2788 " command failed\n");
2791 hba
[cntl_num
]->num_luns
= listlength
/ 8; // 8 bytes pre entry
2792 if (hba
[cntl_num
]->num_luns
> CISS_MAX_LUN
)
2794 printk(KERN_ERR
"ciss: only %d number of logical volumes supported\n",
2796 hba
[cntl_num
]->num_luns
= CISS_MAX_LUN
;
2799 printk(KERN_DEBUG
"Length = %x %x %x %x = %d\n", ld_buff
->LUNListLength
[0],
2800 ld_buff
->LUNListLength
[1], ld_buff
->LUNListLength
[2],
2801 ld_buff
->LUNListLength
[3], hba
[cntl_num
]->num_luns
);
2802 #endif /* CCISS_DEBUG */
2804 hba
[cntl_num
]->highest_lun
= hba
[cntl_num
]->num_luns
-1;
2805 // for(i=0; i< hba[cntl_num]->num_luns; i++)
2806 for(i
=0; i
< CISS_MAX_LUN
; i
++)
2808 if (i
< hba
[cntl_num
]->num_luns
){
2809 lunid
= (0xff & (unsigned int)(ld_buff
->LUN
[i
][3]))
2811 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][2]))
2813 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][1]))
2815 lunid
|= 0xff & (unsigned int)(ld_buff
->LUN
[i
][0]);
2817 hba
[cntl_num
]->drv
[i
].LunID
= lunid
;
2821 printk(KERN_DEBUG
"LUN[%d]: %x %x %x %x = %x\n", i
,
2822 ld_buff
->LUN
[i
][0], ld_buff
->LUN
[i
][1],
2823 ld_buff
->LUN
[i
][2], ld_buff
->LUN
[i
][3],
2824 hba
[cntl_num
]->drv
[i
].LunID
);
2825 #endif /* CCISS_DEBUG */
2826 cciss_read_capacity(cntl_num
, i
, size_buff
, 0,
2827 &total_size
, &block_size
);
2828 cciss_geometry_inquiry(cntl_num
, i
, 0, total_size
,
2829 block_size
, inq_buff
, &hba
[cntl_num
]->drv
[i
]);
2831 /* initialize raid_level to indicate a free space */
2832 hba
[cntl_num
]->drv
[i
].raid_level
= -1;
2840 /* Function to find the first free pointer into our hba[] array */
2841 /* Returns -1 if no free entries are left. */
2842 static int alloc_cciss_hba(void)
2844 struct gendisk
*disk
[NWD
];
2846 for (n
= 0; n
< NWD
; n
++) {
2847 disk
[n
] = alloc_disk(1 << NWD_SHIFT
);
2852 for(i
=0; i
< MAX_CTLR
; i
++) {
2855 p
= kmalloc(sizeof(ctlr_info_t
), GFP_KERNEL
);
2858 memset(p
, 0, sizeof(ctlr_info_t
));
2859 for (n
= 0; n
< NWD
; n
++)
2860 p
->gendisk
[n
] = disk
[n
];
2865 printk(KERN_WARNING
"cciss: This driver supports a maximum"
2866 " of %d controllers.\n", MAX_CTLR
);
2869 printk(KERN_ERR
"cciss: out of memory.\n");
2876 static void free_hba(int i
)
2878 ctlr_info_t
*p
= hba
[i
];
2882 for (n
= 0; n
< NWD
; n
++)
2883 put_disk(p
->gendisk
[n
]);
2888 * This is it. Find all the controllers and register them. I really hate
2889 * stealing all these major device numbers.
2890 * returns the number of block devices registered.
2892 static int __devinit
cciss_init_one(struct pci_dev
*pdev
,
2893 const struct pci_device_id
*ent
)
2900 printk(KERN_DEBUG
"cciss: Device 0x%x has been found at"
2901 " bus %d dev %d func %d\n",
2902 pdev
->device
, pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
),
2903 PCI_FUNC(pdev
->devfn
));
2904 i
= alloc_cciss_hba();
2908 hba
[i
]->busy_initializing
= 1;
2910 if (cciss_pci_init(hba
[i
], pdev
) != 0)
2913 sprintf(hba
[i
]->devname
, "cciss%d", i
);
2915 hba
[i
]->pdev
= pdev
;
2917 /* configure PCI DMA stuff */
2918 if (!pci_set_dma_mask(pdev
, DMA_64BIT_MASK
))
2919 printk("cciss: using DAC cycles\n");
2920 else if (!pci_set_dma_mask(pdev
, DMA_32BIT_MASK
))
2921 printk("cciss: not using DAC cycles\n");
2923 printk("cciss: no suitable DMA available\n");
2928 * register with the major number, or get a dynamic major number
2929 * by passing 0 as argument. This is done for greater than
2930 * 8 controller support.
2932 if (i
< MAX_CTLR_ORIG
)
2933 hba
[i
]->major
= MAJOR_NR
+ i
;
2934 rc
= register_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
2935 if(rc
== -EBUSY
|| rc
== -EINVAL
) {
2937 "cciss: Unable to get major number %d for %s "
2938 "on hba %d\n", hba
[i
]->major
, hba
[i
]->devname
, i
);
2942 if (i
>= MAX_CTLR_ORIG
)
2946 /* make sure the board interrupts are off */
2947 hba
[i
]->access
.set_intr_mask(hba
[i
], CCISS_INTR_OFF
);
2948 if( request_irq(hba
[i
]->intr
, do_cciss_intr
,
2949 SA_INTERRUPT
| SA_SHIRQ
| SA_SAMPLE_RANDOM
,
2950 hba
[i
]->devname
, hba
[i
])) {
2951 printk(KERN_ERR
"cciss: Unable to get irq %d for %s\n",
2952 hba
[i
]->intr
, hba
[i
]->devname
);
2955 hba
[i
]->cmd_pool_bits
= kmalloc(((NR_CMDS
+BITS_PER_LONG
-1)/BITS_PER_LONG
)*sizeof(unsigned long), GFP_KERNEL
);
2956 hba
[i
]->cmd_pool
= (CommandList_struct
*)pci_alloc_consistent(
2957 hba
[i
]->pdev
, NR_CMDS
* sizeof(CommandList_struct
),
2958 &(hba
[i
]->cmd_pool_dhandle
));
2959 hba
[i
]->errinfo_pool
= (ErrorInfo_struct
*)pci_alloc_consistent(
2960 hba
[i
]->pdev
, NR_CMDS
* sizeof( ErrorInfo_struct
),
2961 &(hba
[i
]->errinfo_pool_dhandle
));
2962 if((hba
[i
]->cmd_pool_bits
== NULL
)
2963 || (hba
[i
]->cmd_pool
== NULL
)
2964 || (hba
[i
]->errinfo_pool
== NULL
)) {
2965 printk( KERN_ERR
"cciss: out of memory");
2969 spin_lock_init(&hba
[i
]->lock
);
2971 /* Initialize the pdev driver private data.
2972 have it point to hba[i]. */
2973 pci_set_drvdata(pdev
, hba
[i
]);
2974 /* command and error info recs zeroed out before
2976 memset(hba
[i
]->cmd_pool_bits
, 0, ((NR_CMDS
+BITS_PER_LONG
-1)/BITS_PER_LONG
)*sizeof(unsigned long));
2979 printk(KERN_DEBUG
"Scanning for drives on controller cciss%d\n",i
);
2980 #endif /* CCISS_DEBUG */
2982 cciss_getgeometry(i
);
2984 cciss_scsi_setup(i
);
2986 /* Turn the interrupts on so we can service requests */
2987 hba
[i
]->access
.set_intr_mask(hba
[i
], CCISS_INTR_ON
);
2991 for(j
=0; j
< NWD
; j
++) { /* mfm */
2992 drive_info_struct
*drv
= &(hba
[i
]->drv
[j
]);
2993 struct gendisk
*disk
= hba
[i
]->gendisk
[j
];
2995 q
= blk_init_queue(do_cciss_request
, &hba
[i
]->lock
);
2998 "cciss: unable to allocate queue for disk %d\n",
3004 q
->backing_dev_info
.ra_pages
= READ_AHEAD
;
3005 blk_queue_bounce_limit(q
, hba
[i
]->pdev
->dma_mask
);
3007 /* This is a hardware imposed limit. */
3008 blk_queue_max_hw_segments(q
, MAXSGENTRIES
);
3010 /* This is a limit in the driver and could be eliminated. */
3011 blk_queue_max_phys_segments(q
, MAXSGENTRIES
);
3013 blk_queue_max_sectors(q
, 512);
3015 q
->queuedata
= hba
[i
];
3016 sprintf(disk
->disk_name
, "cciss/c%dd%d", i
, j
);
3017 sprintf(disk
->devfs_name
, "cciss/host%d/target%d", i
, j
);
3018 disk
->major
= hba
[i
]->major
;
3019 disk
->first_minor
= j
<< NWD_SHIFT
;
3020 disk
->fops
= &cciss_fops
;
3022 disk
->private_data
= drv
;
3023 /* we must register the controller even if no disks exist */
3024 /* this is for the online array utilities */
3025 if(!drv
->heads
&& j
)
3027 blk_queue_hardsect_size(q
, drv
->block_size
);
3028 set_capacity(disk
, drv
->nr_blocks
);
3032 hba
[i
]->busy_initializing
= 0;
3036 if(hba
[i
]->cmd_pool_bits
)
3037 kfree(hba
[i
]->cmd_pool_bits
);
3038 if(hba
[i
]->cmd_pool
)
3039 pci_free_consistent(hba
[i
]->pdev
,
3040 NR_CMDS
* sizeof(CommandList_struct
),
3041 hba
[i
]->cmd_pool
, hba
[i
]->cmd_pool_dhandle
);
3042 if(hba
[i
]->errinfo_pool
)
3043 pci_free_consistent(hba
[i
]->pdev
,
3044 NR_CMDS
* sizeof( ErrorInfo_struct
),
3045 hba
[i
]->errinfo_pool
,
3046 hba
[i
]->errinfo_pool_dhandle
);
3047 free_irq(hba
[i
]->intr
, hba
[i
]);
3049 unregister_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
3051 release_io_mem(hba
[i
]);
3053 hba
[i
]->busy_initializing
= 0;
3057 static void __devexit
cciss_remove_one (struct pci_dev
*pdev
)
3059 ctlr_info_t
*tmp_ptr
;
3064 if (pci_get_drvdata(pdev
) == NULL
)
3066 printk( KERN_ERR
"cciss: Unable to remove device \n");
3069 tmp_ptr
= pci_get_drvdata(pdev
);
3073 printk(KERN_ERR
"cciss: device appears to "
3074 "already be removed \n");
3077 /* Turn board interrupts off and send the flush cache command */
3078 /* sendcmd will turn off interrupt, and send the flush...
3079 * To write all data in the battery backed cache to disks */
3080 memset(flush_buf
, 0, 4);
3081 return_code
= sendcmd(CCISS_CACHE_FLUSH
, i
, flush_buf
, 4, 0, 0, 0, NULL
,
3083 if(return_code
!= IO_OK
)
3085 printk(KERN_WARNING
"Error Flushing cache on controller %d\n",
3088 free_irq(hba
[i
]->intr
, hba
[i
]);
3089 pci_set_drvdata(pdev
, NULL
);
3090 iounmap(hba
[i
]->vaddr
);
3091 cciss_unregister_scsi(i
); /* unhook from SCSI subsystem */
3092 unregister_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
3093 remove_proc_entry(hba
[i
]->devname
, proc_cciss
);
3095 /* remove it from the disk list */
3096 for (j
= 0; j
< NWD
; j
++) {
3097 struct gendisk
*disk
= hba
[i
]->gendisk
[j
];
3098 if (disk
->flags
& GENHD_FL_UP
)
3099 blk_cleanup_queue(disk
->queue
);
3103 pci_free_consistent(hba
[i
]->pdev
, NR_CMDS
* sizeof(CommandList_struct
),
3104 hba
[i
]->cmd_pool
, hba
[i
]->cmd_pool_dhandle
);
3105 pci_free_consistent(hba
[i
]->pdev
, NR_CMDS
* sizeof( ErrorInfo_struct
),
3106 hba
[i
]->errinfo_pool
, hba
[i
]->errinfo_pool_dhandle
);
3107 kfree(hba
[i
]->cmd_pool_bits
);
3108 release_io_mem(hba
[i
]);
3112 static struct pci_driver cciss_pci_driver
= {
3114 .probe
= cciss_init_one
,
3115 .remove
= __devexit_p(cciss_remove_one
),
3116 .id_table
= cciss_pci_device_id
, /* id_table */
3120 * This is it. Register the PCI driver information for the cards we control
3121 * the OS will call our registered routines when it finds one of our cards.
3123 static int __init
cciss_init(void)
3125 printk(KERN_INFO DRIVER_NAME
"\n");
3127 /* Register for our PCI devices */
3128 return pci_module_init(&cciss_pci_driver
);
3131 static void __exit
cciss_cleanup(void)
3135 pci_unregister_driver(&cciss_pci_driver
);
3136 /* double check that all controller entrys have been removed */
3137 for (i
=0; i
< MAX_CTLR
; i
++)
3141 printk(KERN_WARNING
"cciss: had to remove"
3142 " controller %d\n", i
);
3143 cciss_remove_one(hba
[i
]->pdev
);
3146 remove_proc_entry("cciss", proc_root_driver
);
3149 static void fail_all_cmds(unsigned long ctlr
)
3151 /* If we get here, the board is apparently dead. */
3152 ctlr_info_t
*h
= hba
[ctlr
];
3153 CommandList_struct
*c
;
3154 unsigned long flags
;
3156 printk(KERN_WARNING
"cciss%d: controller not responding.\n", h
->ctlr
);
3157 h
->alive
= 0; /* the controller apparently died... */
3159 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
3161 pci_disable_device(h
->pdev
); /* Make sure it is really dead. */
3163 /* move everything off the request queue onto the completed queue */
3164 while( (c
= h
->reqQ
) != NULL
) {
3165 removeQ(&(h
->reqQ
), c
);
3167 addQ (&(h
->cmpQ
), c
);
3170 /* Now, fail everything on the completed queue with a HW error */
3171 while( (c
= h
->cmpQ
) != NULL
) {
3172 removeQ(&h
->cmpQ
, c
);
3173 c
->err_info
->CommandStatus
= CMD_HARDWARE_ERR
;
3174 if (c
->cmd_type
== CMD_RWREQ
) {
3175 complete_command(h
, c
, 0);
3176 } else if (c
->cmd_type
== CMD_IOCTL_PEND
)
3177 complete(c
->waiting
);
3178 #ifdef CONFIG_CISS_SCSI_TAPE
3179 else if (c
->cmd_type
== CMD_SCSI
)
3180 complete_scsi_command(c
, 0, 0);
3183 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
3187 module_init(cciss_init
);
3188 module_exit(cciss_cleanup
);