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 deregister_disk(struct gendisk
*disk
);
159 static int register_new_disk(ctlr_info_t
*h
);
161 static void cciss_getgeometry(int cntl_num
);
163 static void start_io( ctlr_info_t
*h
);
164 static int sendcmd( __u8 cmd
, int ctlr
, void *buff
, size_t size
,
165 unsigned int use_unit_num
, unsigned int log_unit
, __u8 page_code
,
166 unsigned char *scsi3addr
, int cmd_type
);
168 #ifdef CONFIG_PROC_FS
169 static int cciss_proc_get_info(char *buffer
, char **start
, off_t offset
,
170 int length
, int *eof
, void *data
);
171 static void cciss_procinit(int i
);
173 static void cciss_procinit(int i
) {}
174 #endif /* CONFIG_PROC_FS */
177 static long cciss_compat_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
);
180 static struct block_device_operations cciss_fops
= {
181 .owner
= THIS_MODULE
,
183 .release
= cciss_release
,
184 .ioctl
= cciss_ioctl
,
186 .compat_ioctl
= cciss_compat_ioctl
,
188 .revalidate_disk
= cciss_revalidate
,
192 * Enqueuing and dequeuing functions for cmdlists.
194 static inline void addQ(CommandList_struct
**Qptr
, CommandList_struct
*c
)
198 c
->next
= c
->prev
= c
;
200 c
->prev
= (*Qptr
)->prev
;
202 (*Qptr
)->prev
->next
= c
;
207 static inline CommandList_struct
*removeQ(CommandList_struct
**Qptr
,
208 CommandList_struct
*c
)
210 if (c
&& c
->next
!= c
) {
211 if (*Qptr
== c
) *Qptr
= c
->next
;
212 c
->prev
->next
= c
->next
;
213 c
->next
->prev
= c
->prev
;
220 #include "cciss_scsi.c" /* For SCSI tape support */
222 #ifdef CONFIG_PROC_FS
225 * Report information about this controller.
227 #define ENG_GIG 1000000000
228 #define ENG_GIG_FACTOR (ENG_GIG/512)
229 #define RAID_UNKNOWN 6
230 static const char *raid_label
[] = {"0","4","1(1+0)","5","5+1","ADG",
233 static struct proc_dir_entry
*proc_cciss
;
235 static int cciss_proc_get_info(char *buffer
, char **start
, off_t offset
,
236 int length
, int *eof
, void *data
)
241 ctlr_info_t
*h
= (ctlr_info_t
*)data
;
242 drive_info_struct
*drv
;
244 sector_t vol_sz
, vol_sz_frac
;
248 /* prevent displaying bogus info during configuration
249 * or deconfiguration of a logical volume
251 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
252 if (h
->busy_configuring
) {
253 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
256 h
->busy_configuring
= 1;
257 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
259 size
= sprintf(buffer
, "%s: HP %s Controller\n"
260 "Board ID: 0x%08lx\n"
261 "Firmware Version: %c%c%c%c\n"
263 "Logical drives: %d\n"
264 "Current Q depth: %d\n"
265 "Current # commands on controller: %d\n"
266 "Max Q depth since init: %d\n"
267 "Max # commands on controller since init: %d\n"
268 "Max SG entries since init: %d\n\n",
271 (unsigned long)h
->board_id
,
272 h
->firm_ver
[0], h
->firm_ver
[1], h
->firm_ver
[2], h
->firm_ver
[3],
273 (unsigned int)h
->intr
,
275 h
->Qdepth
, h
->commands_outstanding
,
276 h
->maxQsinceinit
, h
->max_outstanding
, h
->maxSG
);
278 pos
+= size
; len
+= size
;
279 cciss_proc_tape_report(ctlr
, buffer
, &pos
, &len
);
280 for(i
=0; i
<=h
->highest_lun
; i
++) {
283 if (drv
->block_size
== 0)
286 vol_sz
= drv
->nr_blocks
;
287 vol_sz_frac
= sector_div(vol_sz
, ENG_GIG_FACTOR
);
289 sector_div(vol_sz_frac
, ENG_GIG_FACTOR
);
291 if (drv
->raid_level
> 5)
292 drv
->raid_level
= RAID_UNKNOWN
;
293 size
= sprintf(buffer
+len
, "cciss/c%dd%d:"
294 "\t%4u.%02uGB\tRAID %s\n",
295 ctlr
, i
, (int)vol_sz
, (int)vol_sz_frac
,
296 raid_label
[drv
->raid_level
]);
297 pos
+= size
; len
+= size
;
301 *start
= buffer
+offset
;
305 h
->busy_configuring
= 0;
310 cciss_proc_write(struct file
*file
, const char __user
*buffer
,
311 unsigned long count
, void *data
)
313 unsigned char cmd
[80];
315 #ifdef CONFIG_CISS_SCSI_TAPE
316 ctlr_info_t
*h
= (ctlr_info_t
*) data
;
320 if (count
> sizeof(cmd
)-1) return -EINVAL
;
321 if (copy_from_user(cmd
, buffer
, count
)) return -EFAULT
;
323 len
= strlen(cmd
); // above 3 lines ensure safety
324 if (len
&& cmd
[len
-1] == '\n')
326 # ifdef CONFIG_CISS_SCSI_TAPE
327 if (strcmp("engage scsi", cmd
)==0) {
328 rc
= cciss_engage_scsi(h
->ctlr
);
329 if (rc
!= 0) return -rc
;
332 /* might be nice to have "disengage" too, but it's not
333 safely possible. (only 1 module use count, lock issues.) */
339 * Get us a file in /proc/cciss that says something about each controller.
340 * Create /proc/cciss if it doesn't exist yet.
342 static void __devinit
cciss_procinit(int i
)
344 struct proc_dir_entry
*pde
;
346 if (proc_cciss
== NULL
) {
347 proc_cciss
= proc_mkdir("cciss", proc_root_driver
);
352 pde
= create_proc_read_entry(hba
[i
]->devname
,
353 S_IWUSR
| S_IRUSR
| S_IRGRP
| S_IROTH
,
354 proc_cciss
, cciss_proc_get_info
, hba
[i
]);
355 pde
->write_proc
= cciss_proc_write
;
357 #endif /* CONFIG_PROC_FS */
360 * For operations that cannot sleep, a command block is allocated at init,
361 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
362 * which ones are free or in use. For operations that can wait for kmalloc
363 * to possible sleep, this routine can be called with get_from_pool set to 0.
364 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
366 static CommandList_struct
* cmd_alloc(ctlr_info_t
*h
, int get_from_pool
)
368 CommandList_struct
*c
;
371 dma_addr_t cmd_dma_handle
, err_dma_handle
;
375 c
= (CommandList_struct
*) pci_alloc_consistent(
376 h
->pdev
, sizeof(CommandList_struct
), &cmd_dma_handle
);
379 memset(c
, 0, sizeof(CommandList_struct
));
381 c
->err_info
= (ErrorInfo_struct
*)pci_alloc_consistent(
382 h
->pdev
, sizeof(ErrorInfo_struct
),
385 if (c
->err_info
== NULL
)
387 pci_free_consistent(h
->pdev
,
388 sizeof(CommandList_struct
), c
, cmd_dma_handle
);
391 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
392 } else /* get it out of the controllers pool */
395 i
= find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
);
398 } while(test_and_set_bit(i
& (BITS_PER_LONG
- 1), h
->cmd_pool_bits
+(i
/BITS_PER_LONG
)) != 0);
400 printk(KERN_DEBUG
"cciss: using command buffer %d\n", i
);
403 memset(c
, 0, sizeof(CommandList_struct
));
404 cmd_dma_handle
= h
->cmd_pool_dhandle
405 + i
*sizeof(CommandList_struct
);
406 c
->err_info
= h
->errinfo_pool
+ i
;
407 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
408 err_dma_handle
= h
->errinfo_pool_dhandle
409 + i
*sizeof(ErrorInfo_struct
);
413 c
->busaddr
= (__u32
) cmd_dma_handle
;
414 temp64
.val
= (__u64
) err_dma_handle
;
415 c
->ErrDesc
.Addr
.lower
= temp64
.val32
.lower
;
416 c
->ErrDesc
.Addr
.upper
= temp64
.val32
.upper
;
417 c
->ErrDesc
.Len
= sizeof(ErrorInfo_struct
);
426 * Frees a command block that was previously allocated with cmd_alloc().
428 static void cmd_free(ctlr_info_t
*h
, CommandList_struct
*c
, int got_from_pool
)
435 temp64
.val32
.lower
= c
->ErrDesc
.Addr
.lower
;
436 temp64
.val32
.upper
= c
->ErrDesc
.Addr
.upper
;
437 pci_free_consistent(h
->pdev
, sizeof(ErrorInfo_struct
),
438 c
->err_info
, (dma_addr_t
) temp64
.val
);
439 pci_free_consistent(h
->pdev
, sizeof(CommandList_struct
),
440 c
, (dma_addr_t
) c
->busaddr
);
444 clear_bit(i
&(BITS_PER_LONG
-1), h
->cmd_pool_bits
+(i
/BITS_PER_LONG
));
449 static inline ctlr_info_t
*get_host(struct gendisk
*disk
)
451 return disk
->queue
->queuedata
;
454 static inline drive_info_struct
*get_drv(struct gendisk
*disk
)
456 return disk
->private_data
;
460 * Open. Make sure the device is really there.
462 static int cciss_open(struct inode
*inode
, struct file
*filep
)
464 ctlr_info_t
*host
= get_host(inode
->i_bdev
->bd_disk
);
465 drive_info_struct
*drv
= get_drv(inode
->i_bdev
->bd_disk
);
468 printk(KERN_DEBUG
"cciss_open %s\n", inode
->i_bdev
->bd_disk
->disk_name
);
469 #endif /* CCISS_DEBUG */
471 if (host
->busy_initializing
)
475 * Root is allowed to open raw volume zero even if it's not configured
476 * so array config can still work. Root is also allowed to open any
477 * volume that has a LUN ID, so it can issue IOCTL to reread the
478 * disk information. I don't think I really like this
479 * but I'm already using way to many device nodes to claim another one
480 * for "raw controller".
482 if (drv
->nr_blocks
== 0) {
483 if (iminor(inode
) != 0) { /* not node 0? */
484 /* if not node 0 make sure it is a partition = 0 */
485 if (iminor(inode
) & 0x0f) {
487 /* if it is, make sure we have a LUN ID */
488 } else if (drv
->LunID
== 0) {
492 if (!capable(CAP_SYS_ADMIN
))
502 static int cciss_release(struct inode
*inode
, struct file
*filep
)
504 ctlr_info_t
*host
= get_host(inode
->i_bdev
->bd_disk
);
505 drive_info_struct
*drv
= get_drv(inode
->i_bdev
->bd_disk
);
508 printk(KERN_DEBUG
"cciss_release %s\n", inode
->i_bdev
->bd_disk
->disk_name
);
509 #endif /* CCISS_DEBUG */
518 static int do_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
)
522 ret
= cciss_ioctl(f
->f_dentry
->d_inode
, f
, cmd
, arg
);
527 static int cciss_ioctl32_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
);
528 static int cciss_ioctl32_big_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
);
530 static long cciss_compat_ioctl(struct file
*f
, unsigned cmd
, unsigned long arg
)
533 case CCISS_GETPCIINFO
:
534 case CCISS_GETINTINFO
:
535 case CCISS_SETINTINFO
:
536 case CCISS_GETNODENAME
:
537 case CCISS_SETNODENAME
:
538 case CCISS_GETHEARTBEAT
:
539 case CCISS_GETBUSTYPES
:
540 case CCISS_GETFIRMVER
:
541 case CCISS_GETDRIVVER
:
542 case CCISS_REVALIDVOLS
:
543 case CCISS_DEREGDISK
:
544 case CCISS_REGNEWDISK
:
546 case CCISS_RESCANDISK
:
547 case CCISS_GETLUNINFO
:
548 return do_ioctl(f
, cmd
, arg
);
550 case CCISS_PASSTHRU32
:
551 return cciss_ioctl32_passthru(f
, cmd
, arg
);
552 case CCISS_BIG_PASSTHRU32
:
553 return cciss_ioctl32_big_passthru(f
, cmd
, arg
);
560 static int cciss_ioctl32_passthru(struct file
*f
, unsigned cmd
, unsigned long arg
)
562 IOCTL32_Command_struct __user
*arg32
=
563 (IOCTL32_Command_struct __user
*) arg
;
564 IOCTL_Command_struct arg64
;
565 IOCTL_Command_struct __user
*p
= compat_alloc_user_space(sizeof(arg64
));
570 err
|= copy_from_user(&arg64
.LUN_info
, &arg32
->LUN_info
, sizeof(arg64
.LUN_info
));
571 err
|= copy_from_user(&arg64
.Request
, &arg32
->Request
, sizeof(arg64
.Request
));
572 err
|= copy_from_user(&arg64
.error_info
, &arg32
->error_info
, sizeof(arg64
.error_info
));
573 err
|= get_user(arg64
.buf_size
, &arg32
->buf_size
);
574 err
|= get_user(cp
, &arg32
->buf
);
575 arg64
.buf
= compat_ptr(cp
);
576 err
|= copy_to_user(p
, &arg64
, sizeof(arg64
));
581 err
= do_ioctl(f
, CCISS_PASSTHRU
, (unsigned long) p
);
584 err
|= copy_in_user(&arg32
->error_info
, &p
->error_info
, sizeof(arg32
->error_info
));
590 static int cciss_ioctl32_big_passthru(struct file
*file
, unsigned cmd
, unsigned long arg
)
592 BIG_IOCTL32_Command_struct __user
*arg32
=
593 (BIG_IOCTL32_Command_struct __user
*) arg
;
594 BIG_IOCTL_Command_struct arg64
;
595 BIG_IOCTL_Command_struct __user
*p
= compat_alloc_user_space(sizeof(arg64
));
600 err
|= copy_from_user(&arg64
.LUN_info
, &arg32
->LUN_info
, sizeof(arg64
.LUN_info
));
601 err
|= copy_from_user(&arg64
.Request
, &arg32
->Request
, sizeof(arg64
.Request
));
602 err
|= copy_from_user(&arg64
.error_info
, &arg32
->error_info
, sizeof(arg64
.error_info
));
603 err
|= get_user(arg64
.buf_size
, &arg32
->buf_size
);
604 err
|= get_user(arg64
.malloc_size
, &arg32
->malloc_size
);
605 err
|= get_user(cp
, &arg32
->buf
);
606 arg64
.buf
= compat_ptr(cp
);
607 err
|= copy_to_user(p
, &arg64
, sizeof(arg64
));
612 err
= do_ioctl(file
, CCISS_BIG_PASSTHRU
, (unsigned long) p
);
615 err
|= copy_in_user(&arg32
->error_info
, &p
->error_info
, sizeof(arg32
->error_info
));
624 static int cciss_ioctl(struct inode
*inode
, struct file
*filep
,
625 unsigned int cmd
, unsigned long arg
)
627 struct block_device
*bdev
= inode
->i_bdev
;
628 struct gendisk
*disk
= bdev
->bd_disk
;
629 ctlr_info_t
*host
= get_host(disk
);
630 drive_info_struct
*drv
= get_drv(disk
);
631 int ctlr
= host
->ctlr
;
632 void __user
*argp
= (void __user
*)arg
;
635 printk(KERN_DEBUG
"cciss_ioctl: Called with cmd=%x %lx\n", cmd
, arg
);
636 #endif /* CCISS_DEBUG */
641 struct hd_geometry driver_geo
;
642 if (drv
->cylinders
) {
643 driver_geo
.heads
= drv
->heads
;
644 driver_geo
.sectors
= drv
->sectors
;
645 driver_geo
.cylinders
= drv
->cylinders
;
648 driver_geo
.start
= get_start_sect(inode
->i_bdev
);
649 if (copy_to_user(argp
, &driver_geo
, sizeof(struct hd_geometry
)))
654 case CCISS_GETPCIINFO
:
656 cciss_pci_info_struct pciinfo
;
658 if (!arg
) return -EINVAL
;
659 pciinfo
.domain
= pci_domain_nr(host
->pdev
->bus
);
660 pciinfo
.bus
= host
->pdev
->bus
->number
;
661 pciinfo
.dev_fn
= host
->pdev
->devfn
;
662 pciinfo
.board_id
= host
->board_id
;
663 if (copy_to_user(argp
, &pciinfo
, sizeof( cciss_pci_info_struct
)))
667 case CCISS_GETINTINFO
:
669 cciss_coalint_struct intinfo
;
670 if (!arg
) return -EINVAL
;
671 intinfo
.delay
= readl(&host
->cfgtable
->HostWrite
.CoalIntDelay
);
672 intinfo
.count
= readl(&host
->cfgtable
->HostWrite
.CoalIntCount
);
673 if (copy_to_user(argp
, &intinfo
, sizeof( cciss_coalint_struct
)))
677 case CCISS_SETINTINFO
:
679 cciss_coalint_struct intinfo
;
683 if (!arg
) return -EINVAL
;
684 if (!capable(CAP_SYS_ADMIN
)) return -EPERM
;
685 if (copy_from_user(&intinfo
, argp
, sizeof( cciss_coalint_struct
)))
687 if ( (intinfo
.delay
== 0 ) && (intinfo
.count
== 0))
690 // printk("cciss_ioctl: delay and count cannot be 0\n");
693 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
694 /* Update the field, and then ring the doorbell */
695 writel( intinfo
.delay
,
696 &(host
->cfgtable
->HostWrite
.CoalIntDelay
));
697 writel( intinfo
.count
,
698 &(host
->cfgtable
->HostWrite
.CoalIntCount
));
699 writel( CFGTBL_ChangeReq
, host
->vaddr
+ SA5_DOORBELL
);
701 for(i
=0;i
<MAX_IOCTL_CONFIG_WAIT
;i
++) {
702 if (!(readl(host
->vaddr
+ SA5_DOORBELL
)
705 /* delay and try again */
708 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
709 if (i
>= MAX_IOCTL_CONFIG_WAIT
)
713 case CCISS_GETNODENAME
:
715 NodeName_type NodeName
;
718 if (!arg
) return -EINVAL
;
720 NodeName
[i
] = readb(&host
->cfgtable
->ServerName
[i
]);
721 if (copy_to_user(argp
, NodeName
, sizeof( NodeName_type
)))
725 case CCISS_SETNODENAME
:
727 NodeName_type NodeName
;
731 if (!arg
) return -EINVAL
;
732 if (!capable(CAP_SYS_ADMIN
)) return -EPERM
;
734 if (copy_from_user(NodeName
, argp
, sizeof( NodeName_type
)))
737 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
739 /* Update the field, and then ring the doorbell */
741 writeb( NodeName
[i
], &host
->cfgtable
->ServerName
[i
]);
743 writel( CFGTBL_ChangeReq
, host
->vaddr
+ SA5_DOORBELL
);
745 for(i
=0;i
<MAX_IOCTL_CONFIG_WAIT
;i
++) {
746 if (!(readl(host
->vaddr
+ SA5_DOORBELL
)
749 /* delay and try again */
752 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
753 if (i
>= MAX_IOCTL_CONFIG_WAIT
)
758 case CCISS_GETHEARTBEAT
:
760 Heartbeat_type heartbeat
;
762 if (!arg
) return -EINVAL
;
763 heartbeat
= readl(&host
->cfgtable
->HeartBeat
);
764 if (copy_to_user(argp
, &heartbeat
, sizeof( Heartbeat_type
)))
768 case CCISS_GETBUSTYPES
:
770 BusTypes_type BusTypes
;
772 if (!arg
) return -EINVAL
;
773 BusTypes
= readl(&host
->cfgtable
->BusTypes
);
774 if (copy_to_user(argp
, &BusTypes
, sizeof( BusTypes_type
) ))
778 case CCISS_GETFIRMVER
:
780 FirmwareVer_type firmware
;
782 if (!arg
) return -EINVAL
;
783 memcpy(firmware
, host
->firm_ver
, 4);
785 if (copy_to_user(argp
, firmware
, sizeof( FirmwareVer_type
)))
789 case CCISS_GETDRIVVER
:
791 DriverVer_type DriverVer
= DRIVER_VERSION
;
793 if (!arg
) return -EINVAL
;
795 if (copy_to_user(argp
, &DriverVer
, sizeof( DriverVer_type
) ))
800 case CCISS_REVALIDVOLS
:
801 if (bdev
!= bdev
->bd_contains
|| drv
!= host
->drv
)
803 return revalidate_allvol(host
);
805 case CCISS_GETLUNINFO
: {
806 LogvolInfo_struct luninfo
;
808 luninfo
.LunID
= drv
->LunID
;
809 luninfo
.num_opens
= drv
->usage_count
;
810 luninfo
.num_parts
= 0;
811 if (copy_to_user(argp
, &luninfo
,
812 sizeof(LogvolInfo_struct
)))
816 case CCISS_DEREGDISK
:
817 return deregister_disk(disk
);
820 return register_new_disk(host
);
824 IOCTL_Command_struct iocommand
;
825 CommandList_struct
*c
;
829 DECLARE_COMPLETION(wait
);
831 if (!arg
) return -EINVAL
;
833 if (!capable(CAP_SYS_RAWIO
)) return -EPERM
;
835 if (copy_from_user(&iocommand
, argp
, sizeof( IOCTL_Command_struct
) ))
837 if((iocommand
.buf_size
< 1) &&
838 (iocommand
.Request
.Type
.Direction
!= XFER_NONE
))
842 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
843 /* Check kmalloc limits */
844 if(iocommand
.buf_size
> 128000)
847 if(iocommand
.buf_size
> 0)
849 buff
= kmalloc(iocommand
.buf_size
, GFP_KERNEL
);
853 if (iocommand
.Request
.Type
.Direction
== XFER_WRITE
)
855 /* Copy the data into the buffer we created */
856 if (copy_from_user(buff
, iocommand
.buf
, iocommand
.buf_size
))
862 memset(buff
, 0, iocommand
.buf_size
);
864 if ((c
= cmd_alloc(host
, 0)) == NULL
)
869 // Fill in the command type
870 c
->cmd_type
= CMD_IOCTL_PEND
;
871 // Fill in Command Header
872 c
->Header
.ReplyQueue
= 0; // unused in simple mode
873 if( iocommand
.buf_size
> 0) // buffer to fill
875 c
->Header
.SGList
= 1;
876 c
->Header
.SGTotal
= 1;
877 } else // no buffers to fill
879 c
->Header
.SGList
= 0;
880 c
->Header
.SGTotal
= 0;
882 c
->Header
.LUN
= iocommand
.LUN_info
;
883 c
->Header
.Tag
.lower
= c
->busaddr
; // use the kernel address the cmd block for tag
885 // Fill in Request block
886 c
->Request
= iocommand
.Request
;
888 // Fill in the scatter gather information
889 if (iocommand
.buf_size
> 0 )
891 temp64
.val
= pci_map_single( host
->pdev
, buff
,
893 PCI_DMA_BIDIRECTIONAL
);
894 c
->SG
[0].Addr
.lower
= temp64
.val32
.lower
;
895 c
->SG
[0].Addr
.upper
= temp64
.val32
.upper
;
896 c
->SG
[0].Len
= iocommand
.buf_size
;
897 c
->SG
[0].Ext
= 0; // we are not chaining
901 /* Put the request on the tail of the request queue */
902 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
903 addQ(&host
->reqQ
, c
);
906 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
908 wait_for_completion(&wait
);
910 /* unlock the buffers from DMA */
911 temp64
.val32
.lower
= c
->SG
[0].Addr
.lower
;
912 temp64
.val32
.upper
= c
->SG
[0].Addr
.upper
;
913 pci_unmap_single( host
->pdev
, (dma_addr_t
) temp64
.val
,
914 iocommand
.buf_size
, PCI_DMA_BIDIRECTIONAL
);
916 /* Copy the error information out */
917 iocommand
.error_info
= *(c
->err_info
);
918 if ( copy_to_user(argp
, &iocommand
, sizeof( IOCTL_Command_struct
) ) )
921 cmd_free(host
, c
, 0);
925 if (iocommand
.Request
.Type
.Direction
== XFER_READ
)
927 /* Copy the data out of the buffer we created */
928 if (copy_to_user(iocommand
.buf
, buff
, iocommand
.buf_size
))
931 cmd_free(host
, c
, 0);
936 cmd_free(host
, c
, 0);
939 case CCISS_BIG_PASSTHRU
: {
940 BIG_IOCTL_Command_struct
*ioc
;
941 CommandList_struct
*c
;
942 unsigned char **buff
= NULL
;
943 int *buff_size
= NULL
;
949 DECLARE_COMPLETION(wait
);
952 BYTE __user
*data_ptr
;
956 if (!capable(CAP_SYS_RAWIO
))
958 ioc
= (BIG_IOCTL_Command_struct
*)
959 kmalloc(sizeof(*ioc
), GFP_KERNEL
);
964 if (copy_from_user(ioc
, argp
, sizeof(*ioc
))) {
968 if ((ioc
->buf_size
< 1) &&
969 (ioc
->Request
.Type
.Direction
!= XFER_NONE
)) {
973 /* Check kmalloc limits using all SGs */
974 if (ioc
->malloc_size
> MAX_KMALLOC_SIZE
) {
978 if (ioc
->buf_size
> ioc
->malloc_size
* MAXSGENTRIES
) {
982 buff
= (unsigned char **) kmalloc(MAXSGENTRIES
*
983 sizeof(char *), GFP_KERNEL
);
988 memset(buff
, 0, MAXSGENTRIES
);
989 buff_size
= (int *) kmalloc(MAXSGENTRIES
* sizeof(int),
995 left
= ioc
->buf_size
;
998 sz
= (left
> ioc
->malloc_size
) ? ioc
->malloc_size
: left
;
999 buff_size
[sg_used
] = sz
;
1000 buff
[sg_used
] = kmalloc(sz
, GFP_KERNEL
);
1001 if (buff
[sg_used
] == NULL
) {
1005 if (ioc
->Request
.Type
.Direction
== XFER_WRITE
&&
1006 copy_from_user(buff
[sg_used
], data_ptr
, sz
)) {
1010 memset(buff
[sg_used
], 0, sz
);
1016 if ((c
= cmd_alloc(host
, 0)) == NULL
) {
1020 c
->cmd_type
= CMD_IOCTL_PEND
;
1021 c
->Header
.ReplyQueue
= 0;
1023 if( ioc
->buf_size
> 0) {
1024 c
->Header
.SGList
= sg_used
;
1025 c
->Header
.SGTotal
= sg_used
;
1027 c
->Header
.SGList
= 0;
1028 c
->Header
.SGTotal
= 0;
1030 c
->Header
.LUN
= ioc
->LUN_info
;
1031 c
->Header
.Tag
.lower
= c
->busaddr
;
1033 c
->Request
= ioc
->Request
;
1034 if (ioc
->buf_size
> 0 ) {
1036 for(i
=0; i
<sg_used
; i
++) {
1037 temp64
.val
= pci_map_single( host
->pdev
, buff
[i
],
1039 PCI_DMA_BIDIRECTIONAL
);
1040 c
->SG
[i
].Addr
.lower
= temp64
.val32
.lower
;
1041 c
->SG
[i
].Addr
.upper
= temp64
.val32
.upper
;
1042 c
->SG
[i
].Len
= buff_size
[i
];
1043 c
->SG
[i
].Ext
= 0; /* we are not chaining */
1047 /* Put the request on the tail of the request queue */
1048 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1049 addQ(&host
->reqQ
, c
);
1052 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1053 wait_for_completion(&wait
);
1054 /* unlock the buffers from DMA */
1055 for(i
=0; i
<sg_used
; i
++) {
1056 temp64
.val32
.lower
= c
->SG
[i
].Addr
.lower
;
1057 temp64
.val32
.upper
= c
->SG
[i
].Addr
.upper
;
1058 pci_unmap_single( host
->pdev
, (dma_addr_t
) temp64
.val
,
1059 buff_size
[i
], PCI_DMA_BIDIRECTIONAL
);
1061 /* Copy the error information out */
1062 ioc
->error_info
= *(c
->err_info
);
1063 if (copy_to_user(argp
, ioc
, sizeof(*ioc
))) {
1064 cmd_free(host
, c
, 0);
1068 if (ioc
->Request
.Type
.Direction
== XFER_READ
) {
1069 /* Copy the data out of the buffer we created */
1070 BYTE __user
*ptr
= ioc
->buf
;
1071 for(i
=0; i
< sg_used
; i
++) {
1072 if (copy_to_user(ptr
, buff
[i
], buff_size
[i
])) {
1073 cmd_free(host
, c
, 0);
1077 ptr
+= buff_size
[i
];
1080 cmd_free(host
, c
, 0);
1084 for(i
=0; i
<sg_used
; i
++)
1102 * revalidate_allvol is for online array config utilities. After a
1103 * utility reconfigures the drives in the array, it can use this function
1104 * (through an ioctl) to make the driver zap any previous disk structs for
1105 * that controller and get new ones.
1107 * Right now I'm using the getgeometry() function to do this, but this
1108 * function should probably be finer grained and allow you to revalidate one
1109 * particualar logical volume (instead of all of them on a particular
1112 static int revalidate_allvol(ctlr_info_t
*host
)
1114 int ctlr
= host
->ctlr
, i
;
1115 unsigned long flags
;
1117 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1118 if (host
->usage_count
> 1) {
1119 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1120 printk(KERN_WARNING
"cciss: Device busy for volume"
1121 " revalidation (usage=%d)\n", host
->usage_count
);
1124 host
->usage_count
++;
1125 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1127 for(i
=0; i
< NWD
; i
++) {
1128 struct gendisk
*disk
= host
->gendisk
[i
];
1129 if (disk
->flags
& GENHD_FL_UP
)
1134 * Set the partition and block size structures for all volumes
1135 * on this controller to zero. We will reread all of this data
1137 memset(host
->drv
, 0, sizeof(drive_info_struct
)
1140 * Tell the array controller not to give us any interrupts while
1141 * we check the new geometry. Then turn interrupts back on when
1144 host
->access
.set_intr_mask(host
, CCISS_INTR_OFF
);
1145 cciss_getgeometry(ctlr
);
1146 host
->access
.set_intr_mask(host
, CCISS_INTR_ON
);
1148 /* Loop through each real device */
1149 for (i
= 0; i
< NWD
; i
++) {
1150 struct gendisk
*disk
= host
->gendisk
[i
];
1151 drive_info_struct
*drv
= &(host
->drv
[i
]);
1152 /* we must register the controller even if no disks exist */
1153 /* this is for the online array utilities */
1154 if (!drv
->heads
&& i
)
1156 blk_queue_hardsect_size(drv
->queue
, drv
->block_size
);
1157 set_capacity(disk
, drv
->nr_blocks
);
1160 host
->usage_count
--;
1164 static int deregister_disk(struct gendisk
*disk
)
1166 unsigned long flags
;
1167 ctlr_info_t
*h
= get_host(disk
);
1168 drive_info_struct
*drv
= get_drv(disk
);
1171 if (!capable(CAP_SYS_RAWIO
))
1174 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1175 /* make sure logical volume is NOT is use */
1176 if( drv
->usage_count
> 1) {
1177 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1181 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1183 /* invalidate the devices and deregister the disk */
1184 if (disk
->flags
& GENHD_FL_UP
)
1186 /* check to see if it was the last disk */
1187 if (drv
== h
->drv
+ h
->highest_lun
) {
1188 /* if so, find the new hightest lun */
1189 int i
, newhighest
=-1;
1190 for(i
=0; i
<h
->highest_lun
; i
++) {
1191 /* if the disk has size > 0, it is available */
1192 if (h
->drv
[i
].nr_blocks
)
1195 h
->highest_lun
= newhighest
;
1199 /* zero out the disk size info */
1201 drv
->block_size
= 0;
1206 static int fill_cmd(CommandList_struct
*c
, __u8 cmd
, int ctlr
, void *buff
,
1208 unsigned int use_unit_num
, /* 0: address the controller,
1209 1: address logical volume log_unit,
1210 2: periph device address is scsi3addr */
1211 unsigned int log_unit
, __u8 page_code
, unsigned char *scsi3addr
,
1214 ctlr_info_t
*h
= hba
[ctlr
];
1215 u64bit buff_dma_handle
;
1218 c
->cmd_type
= CMD_IOCTL_PEND
;
1219 c
->Header
.ReplyQueue
= 0;
1221 c
->Header
.SGList
= 1;
1222 c
->Header
.SGTotal
= 1;
1224 c
->Header
.SGList
= 0;
1225 c
->Header
.SGTotal
= 0;
1227 c
->Header
.Tag
.lower
= c
->busaddr
;
1229 c
->Request
.Type
.Type
= cmd_type
;
1230 if (cmd_type
== TYPE_CMD
) {
1233 /* If the logical unit number is 0 then, this is going
1234 to controller so It's a physical command
1235 mode = 0 target = 0. So we have nothing to write.
1236 otherwise, if use_unit_num == 1,
1237 mode = 1(volume set addressing) target = LUNID
1238 otherwise, if use_unit_num == 2,
1239 mode = 0(periph dev addr) target = scsi3addr */
1240 if (use_unit_num
== 1) {
1241 c
->Header
.LUN
.LogDev
.VolId
=
1242 h
->drv
[log_unit
].LunID
;
1243 c
->Header
.LUN
.LogDev
.Mode
= 1;
1244 } else if (use_unit_num
== 2) {
1245 memcpy(c
->Header
.LUN
.LunAddrBytes
,scsi3addr
,8);
1246 c
->Header
.LUN
.LogDev
.Mode
= 0;
1248 /* are we trying to read a vital product page */
1249 if(page_code
!= 0) {
1250 c
->Request
.CDB
[1] = 0x01;
1251 c
->Request
.CDB
[2] = page_code
;
1253 c
->Request
.CDBLen
= 6;
1254 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1255 c
->Request
.Type
.Direction
= XFER_READ
;
1256 c
->Request
.Timeout
= 0;
1257 c
->Request
.CDB
[0] = CISS_INQUIRY
;
1258 c
->Request
.CDB
[4] = size
& 0xFF;
1260 case CISS_REPORT_LOG
:
1261 case CISS_REPORT_PHYS
:
1262 /* Talking to controller so It's a physical command
1263 mode = 00 target = 0. Nothing to write.
1265 c
->Request
.CDBLen
= 12;
1266 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1267 c
->Request
.Type
.Direction
= XFER_READ
;
1268 c
->Request
.Timeout
= 0;
1269 c
->Request
.CDB
[0] = cmd
;
1270 c
->Request
.CDB
[6] = (size
>> 24) & 0xFF; //MSB
1271 c
->Request
.CDB
[7] = (size
>> 16) & 0xFF;
1272 c
->Request
.CDB
[8] = (size
>> 8) & 0xFF;
1273 c
->Request
.CDB
[9] = size
& 0xFF;
1276 case CCISS_READ_CAPACITY
:
1277 c
->Header
.LUN
.LogDev
.VolId
= h
->drv
[log_unit
].LunID
;
1278 c
->Header
.LUN
.LogDev
.Mode
= 1;
1279 c
->Request
.CDBLen
= 10;
1280 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1281 c
->Request
.Type
.Direction
= XFER_READ
;
1282 c
->Request
.Timeout
= 0;
1283 c
->Request
.CDB
[0] = cmd
;
1285 case CCISS_CACHE_FLUSH
:
1286 c
->Request
.CDBLen
= 12;
1287 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1288 c
->Request
.Type
.Direction
= XFER_WRITE
;
1289 c
->Request
.Timeout
= 0;
1290 c
->Request
.CDB
[0] = BMIC_WRITE
;
1291 c
->Request
.CDB
[6] = BMIC_CACHE_FLUSH
;
1295 "cciss%d: Unknown Command 0x%c\n", ctlr
, cmd
);
1298 } else if (cmd_type
== TYPE_MSG
) {
1300 case 3: /* No-Op message */
1301 c
->Request
.CDBLen
= 1;
1302 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
1303 c
->Request
.Type
.Direction
= XFER_WRITE
;
1304 c
->Request
.Timeout
= 0;
1305 c
->Request
.CDB
[0] = cmd
;
1309 "cciss%d: unknown message type %d\n",
1315 "cciss%d: unknown command type %d\n", ctlr
, cmd_type
);
1318 /* Fill in the scatter gather information */
1320 buff_dma_handle
.val
= (__u64
) pci_map_single(h
->pdev
,
1321 buff
, size
, PCI_DMA_BIDIRECTIONAL
);
1322 c
->SG
[0].Addr
.lower
= buff_dma_handle
.val32
.lower
;
1323 c
->SG
[0].Addr
.upper
= buff_dma_handle
.val32
.upper
;
1324 c
->SG
[0].Len
= size
;
1325 c
->SG
[0].Ext
= 0; /* we are not chaining */
1329 static int sendcmd_withirq(__u8 cmd
,
1333 unsigned int use_unit_num
,
1334 unsigned int log_unit
,
1338 ctlr_info_t
*h
= hba
[ctlr
];
1339 CommandList_struct
*c
;
1340 u64bit buff_dma_handle
;
1341 unsigned long flags
;
1343 DECLARE_COMPLETION(wait
);
1345 if ((c
= cmd_alloc(h
, 0)) == NULL
)
1347 return_status
= fill_cmd(c
, cmd
, ctlr
, buff
, size
, use_unit_num
,
1348 log_unit
, page_code
, NULL
, cmd_type
);
1349 if (return_status
!= IO_OK
) {
1351 return return_status
;
1356 /* Put the request on the tail of the queue and send it */
1357 spin_lock_irqsave(CCISS_LOCK(ctlr
), flags
);
1361 spin_unlock_irqrestore(CCISS_LOCK(ctlr
), flags
);
1363 wait_for_completion(&wait
);
1365 if(c
->err_info
->CommandStatus
!= 0)
1366 { /* an error has occurred */
1367 switch(c
->err_info
->CommandStatus
)
1369 case CMD_TARGET_STATUS
:
1370 printk(KERN_WARNING
"cciss: cmd %p has "
1371 " completed with errors\n", c
);
1372 if( c
->err_info
->ScsiStatus
)
1374 printk(KERN_WARNING
"cciss: cmd %p "
1375 "has SCSI Status = %x\n",
1377 c
->err_info
->ScsiStatus
);
1381 case CMD_DATA_UNDERRUN
:
1382 case CMD_DATA_OVERRUN
:
1383 /* expected for inquire and report lun commands */
1386 printk(KERN_WARNING
"cciss: Cmd %p is "
1387 "reported invalid\n", c
);
1388 return_status
= IO_ERROR
;
1390 case CMD_PROTOCOL_ERR
:
1391 printk(KERN_WARNING
"cciss: cmd %p has "
1392 "protocol error \n", c
);
1393 return_status
= IO_ERROR
;
1395 case CMD_HARDWARE_ERR
:
1396 printk(KERN_WARNING
"cciss: cmd %p had "
1397 " hardware error\n", c
);
1398 return_status
= IO_ERROR
;
1400 case CMD_CONNECTION_LOST
:
1401 printk(KERN_WARNING
"cciss: cmd %p had "
1402 "connection lost\n", c
);
1403 return_status
= IO_ERROR
;
1406 printk(KERN_WARNING
"cciss: cmd %p was "
1408 return_status
= IO_ERROR
;
1410 case CMD_ABORT_FAILED
:
1411 printk(KERN_WARNING
"cciss: cmd %p reports "
1412 "abort failed\n", c
);
1413 return_status
= IO_ERROR
;
1415 case CMD_UNSOLICITED_ABORT
:
1417 "cciss%d: unsolicited abort %p\n",
1419 if (c
->retry_count
< MAX_CMD_RETRIES
) {
1421 "cciss%d: retrying %p\n",
1424 /* erase the old error information */
1425 memset(c
->err_info
, 0,
1426 sizeof(ErrorInfo_struct
));
1427 return_status
= IO_OK
;
1428 INIT_COMPLETION(wait
);
1431 return_status
= IO_ERROR
;
1434 printk(KERN_WARNING
"cciss: cmd %p returned "
1435 "unknown status %x\n", c
,
1436 c
->err_info
->CommandStatus
);
1437 return_status
= IO_ERROR
;
1440 /* unlock the buffers from DMA */
1441 pci_unmap_single( h
->pdev
, (dma_addr_t
) buff_dma_handle
.val
,
1442 size
, PCI_DMA_BIDIRECTIONAL
);
1444 return(return_status
);
1447 static void cciss_geometry_inquiry(int ctlr
, int logvol
,
1448 int withirq
, unsigned int total_size
,
1449 unsigned int block_size
, InquiryData_struct
*inq_buff
,
1450 drive_info_struct
*drv
)
1453 memset(inq_buff
, 0, sizeof(InquiryData_struct
));
1455 return_code
= sendcmd_withirq(CISS_INQUIRY
, ctlr
,
1456 inq_buff
, sizeof(*inq_buff
), 1, logvol
,0xC1, TYPE_CMD
);
1458 return_code
= sendcmd(CISS_INQUIRY
, ctlr
, inq_buff
,
1459 sizeof(*inq_buff
), 1, logvol
,0xC1, NULL
, TYPE_CMD
);
1460 if (return_code
== IO_OK
) {
1461 if(inq_buff
->data_byte
[8] == 0xFF) {
1463 "cciss: reading geometry failed, volume "
1464 "does not support reading geometry\n");
1465 drv
->block_size
= block_size
;
1466 drv
->nr_blocks
= total_size
;
1468 drv
->sectors
= 32; // Sectors per track
1469 drv
->cylinders
= total_size
/ 255 / 32;
1473 drv
->block_size
= block_size
;
1474 drv
->nr_blocks
= total_size
;
1475 drv
->heads
= inq_buff
->data_byte
[6];
1476 drv
->sectors
= inq_buff
->data_byte
[7];
1477 drv
->cylinders
= (inq_buff
->data_byte
[4] & 0xff) << 8;
1478 drv
->cylinders
+= inq_buff
->data_byte
[5];
1479 drv
->raid_level
= inq_buff
->data_byte
[8];
1480 t
= drv
->heads
* drv
->sectors
;
1482 drv
->cylinders
= total_size
/t
;
1485 } else { /* Get geometry failed */
1486 printk(KERN_WARNING
"cciss: reading geometry failed\n");
1488 printk(KERN_INFO
" heads= %d, sectors= %d, cylinders= %d\n\n",
1489 drv
->heads
, drv
->sectors
, drv
->cylinders
);
1492 cciss_read_capacity(int ctlr
, int logvol
, ReadCapdata_struct
*buf
,
1493 int withirq
, unsigned int *total_size
, unsigned int *block_size
)
1496 memset(buf
, 0, sizeof(*buf
));
1498 return_code
= sendcmd_withirq(CCISS_READ_CAPACITY
,
1499 ctlr
, buf
, sizeof(*buf
), 1, logvol
, 0, TYPE_CMD
);
1501 return_code
= sendcmd(CCISS_READ_CAPACITY
,
1502 ctlr
, buf
, sizeof(*buf
), 1, logvol
, 0, NULL
, TYPE_CMD
);
1503 if (return_code
== IO_OK
) {
1504 *total_size
= be32_to_cpu(*((__be32
*) &buf
->total_size
[0]))+1;
1505 *block_size
= be32_to_cpu(*((__be32
*) &buf
->block_size
[0]));
1506 } else { /* read capacity command failed */
1507 printk(KERN_WARNING
"cciss: read capacity failed\n");
1509 *block_size
= BLOCK_SIZE
;
1511 printk(KERN_INFO
" blocks= %u block_size= %d\n",
1512 *total_size
, *block_size
);
1516 static int register_new_disk(ctlr_info_t
*h
)
1518 struct gendisk
*disk
;
1523 int new_lun_found
= 0;
1524 int new_lun_index
= 0;
1525 int free_index_found
= 0;
1527 ReportLunData_struct
*ld_buff
= NULL
;
1528 ReadCapdata_struct
*size_buff
= NULL
;
1529 InquiryData_struct
*inq_buff
= NULL
;
1533 unsigned int block_size
;
1534 unsigned int total_size
;
1536 if (!capable(CAP_SYS_RAWIO
))
1538 /* if we have no space in our disk array left to add anything */
1539 if( h
->num_luns
>= CISS_MAX_LUN
)
1542 ld_buff
= kmalloc(sizeof(ReportLunData_struct
), GFP_KERNEL
);
1543 if (ld_buff
== NULL
)
1545 memset(ld_buff
, 0, sizeof(ReportLunData_struct
));
1546 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
1547 if (size_buff
== NULL
)
1549 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
1550 if (inq_buff
== NULL
)
1553 return_code
= sendcmd_withirq(CISS_REPORT_LOG
, ctlr
, ld_buff
,
1554 sizeof(ReportLunData_struct
), 0, 0, 0, TYPE_CMD
);
1556 if( return_code
== IO_OK
)
1559 // printk("LUN Data\n--------------------------\n");
1561 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[0])) << 24;
1562 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[1])) << 16;
1563 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[2])) << 8;
1564 listlength
|= 0xff & (unsigned int)(ld_buff
->LUNListLength
[3]);
1565 } else /* reading number of logical volumes failed */
1567 printk(KERN_WARNING
"cciss: report logical volume"
1568 " command failed\n");
1572 num_luns
= listlength
/ 8; // 8 bytes pre entry
1573 if (num_luns
> CISS_MAX_LUN
)
1575 num_luns
= CISS_MAX_LUN
;
1578 printk(KERN_DEBUG
"Length = %x %x %x %x = %d\n", ld_buff
->LUNListLength
[0],
1579 ld_buff
->LUNListLength
[1], ld_buff
->LUNListLength
[2],
1580 ld_buff
->LUNListLength
[3], num_luns
);
1582 for(i
=0; i
< num_luns
; i
++)
1585 int lunID_found
= 0;
1587 lunid
= (0xff & (unsigned int)(ld_buff
->LUN
[i
][3])) << 24;
1588 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][2])) << 16;
1589 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][1])) << 8;
1590 lunid
|= 0xff & (unsigned int)(ld_buff
->LUN
[i
][0]);
1592 /* check to see if this is a new lun */
1593 for(j
=0; j
<= h
->highest_lun
; j
++)
1596 printk("Checking %d %x against %x\n", j
,h
->drv
[j
].LunID
,
1598 #endif /* CCISS_DEBUG */
1599 if (h
->drv
[j
].LunID
== lunid
)
1606 if( lunID_found
== 1)
1609 { /* It is the new lun we have been looking for */
1611 printk("new lun found at %d\n", i
);
1612 #endif /* CCISS_DEBUG */
1620 printk(KERN_WARNING
"cciss: New Logical Volume not found\n");
1623 /* Now find the free index */
1624 for(i
=0; i
<CISS_MAX_LUN
; i
++)
1627 printk("Checking Index %d\n", i
);
1628 #endif /* CCISS_DEBUG */
1629 if(h
->drv
[i
].LunID
== 0)
1632 printk("free index found at %d\n", i
);
1633 #endif /* CCISS_DEBUG */
1634 free_index_found
= 1;
1639 if (!free_index_found
)
1641 printk(KERN_WARNING
"cciss: unable to find free slot for disk\n");
1645 logvol
= free_index
;
1646 h
->drv
[logvol
].LunID
= lunid
;
1647 /* there could be gaps in lun numbers, track hightest */
1648 if(h
->highest_lun
< lunid
)
1649 h
->highest_lun
= logvol
;
1650 cciss_read_capacity(ctlr
, logvol
, size_buff
, 1,
1651 &total_size
, &block_size
);
1652 cciss_geometry_inquiry(ctlr
, logvol
, 1, total_size
, block_size
,
1653 inq_buff
, &h
->drv
[logvol
]);
1654 h
->drv
[logvol
].usage_count
= 0;
1656 /* setup partitions per disk */
1657 disk
= h
->gendisk
[logvol
];
1658 set_capacity(disk
, h
->drv
[logvol
].nr_blocks
);
1659 /* if it's the controller it's already added */
1668 printk(KERN_ERR
"cciss: out of memory\n");
1674 static int cciss_revalidate(struct gendisk
*disk
)
1676 ctlr_info_t
*h
= get_host(disk
);
1677 drive_info_struct
*drv
= get_drv(disk
);
1680 unsigned int block_size
;
1681 unsigned int total_size
;
1682 ReadCapdata_struct
*size_buff
= NULL
;
1683 InquiryData_struct
*inq_buff
= NULL
;
1685 for(logvol
=0; logvol
< CISS_MAX_LUN
; logvol
++)
1687 if(h
->drv
[logvol
].LunID
== drv
->LunID
) {
1693 if (!FOUND
) return 1;
1695 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
1696 if (size_buff
== NULL
)
1698 printk(KERN_WARNING
"cciss: out of memory\n");
1701 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
1702 if (inq_buff
== NULL
)
1704 printk(KERN_WARNING
"cciss: out of memory\n");
1709 cciss_read_capacity(h
->ctlr
, logvol
, size_buff
, 1, &total_size
, &block_size
);
1710 cciss_geometry_inquiry(h
->ctlr
, logvol
, 1, total_size
, block_size
, inq_buff
, drv
);
1712 blk_queue_hardsect_size(drv
->queue
, drv
->block_size
);
1713 set_capacity(disk
, drv
->nr_blocks
);
1721 * Wait polling for a command to complete.
1722 * The memory mapped FIFO is polled for the completion.
1723 * Used only at init time, interrupts from the HBA are disabled.
1725 static unsigned long pollcomplete(int ctlr
)
1730 /* Wait (up to 20 seconds) for a command to complete */
1732 for (i
= 20 * HZ
; i
> 0; i
--) {
1733 done
= hba
[ctlr
]->access
.command_completed(hba
[ctlr
]);
1734 if (done
== FIFO_EMPTY
)
1735 schedule_timeout_uninterruptible(1);
1739 /* Invalid address to tell caller we ran out of time */
1743 * Send a command to the controller, and wait for it to complete.
1744 * Only used at init time.
1751 unsigned int use_unit_num
, /* 0: address the controller,
1752 1: address logical volume log_unit,
1753 2: periph device address is scsi3addr */
1754 unsigned int log_unit
,
1756 unsigned char *scsi3addr
,
1759 CommandList_struct
*c
;
1761 unsigned long complete
;
1762 ctlr_info_t
*info_p
= hba
[ctlr
];
1763 u64bit buff_dma_handle
;
1766 if ((c
= cmd_alloc(info_p
, 1)) == NULL
) {
1767 printk(KERN_WARNING
"cciss: unable to get memory");
1770 status
= fill_cmd(c
, cmd
, ctlr
, buff
, size
, use_unit_num
,
1771 log_unit
, page_code
, scsi3addr
, cmd_type
);
1772 if (status
!= IO_OK
) {
1773 cmd_free(info_p
, c
, 1);
1781 printk(KERN_DEBUG
"cciss: turning intr off\n");
1782 #endif /* CCISS_DEBUG */
1783 info_p
->access
.set_intr_mask(info_p
, CCISS_INTR_OFF
);
1785 /* Make sure there is room in the command FIFO */
1786 /* Actually it should be completely empty at this time. */
1787 for (i
= 200000; i
> 0; i
--)
1789 /* if fifo isn't full go */
1790 if (!(info_p
->access
.fifo_full(info_p
)))
1796 printk(KERN_WARNING
"cciss cciss%d: SendCmd FIFO full,"
1797 " waiting!\n", ctlr
);
1802 info_p
->access
.submit_command(info_p
, c
);
1803 complete
= pollcomplete(ctlr
);
1806 printk(KERN_DEBUG
"cciss: command completed\n");
1807 #endif /* CCISS_DEBUG */
1809 if (complete
!= 1) {
1810 if ( (complete
& CISS_ERROR_BIT
)
1811 && (complete
& ~CISS_ERROR_BIT
) == c
->busaddr
)
1813 /* if data overrun or underun on Report command
1816 if (((c
->Request
.CDB
[0] == CISS_REPORT_LOG
) ||
1817 (c
->Request
.CDB
[0] == CISS_REPORT_PHYS
) ||
1818 (c
->Request
.CDB
[0] == CISS_INQUIRY
)) &&
1819 ((c
->err_info
->CommandStatus
==
1820 CMD_DATA_OVERRUN
) ||
1821 (c
->err_info
->CommandStatus
==
1825 complete
= c
->busaddr
;
1827 if (c
->err_info
->CommandStatus
==
1828 CMD_UNSOLICITED_ABORT
) {
1829 printk(KERN_WARNING
"cciss%d: "
1830 "unsolicited abort %p\n",
1832 if (c
->retry_count
< MAX_CMD_RETRIES
) {
1834 "cciss%d: retrying %p\n",
1837 /* erase the old error */
1839 memset(c
->err_info
, 0,
1840 sizeof(ErrorInfo_struct
));
1844 "cciss%d: retried %p too "
1845 "many times\n", ctlr
, c
);
1850 printk(KERN_WARNING
"ciss ciss%d: sendcmd"
1851 " Error %x \n", ctlr
,
1852 c
->err_info
->CommandStatus
);
1853 printk(KERN_WARNING
"ciss ciss%d: sendcmd"
1855 " size %x\n num %x value %x\n", ctlr
,
1856 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_size
,
1857 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_num
,
1858 c
->err_info
->MoreErrInfo
.Invalid_Cmd
.offense_value
);
1863 if (complete
!= c
->busaddr
) {
1864 printk( KERN_WARNING
"cciss cciss%d: SendCmd "
1865 "Invalid command list address returned! (%lx)\n",
1871 printk( KERN_WARNING
1872 "cciss cciss%d: SendCmd Timeout out, "
1873 "No command list address returned!\n",
1879 /* unlock the data buffer from DMA */
1880 pci_unmap_single(info_p
->pdev
, (dma_addr_t
) buff_dma_handle
.val
,
1881 size
, PCI_DMA_BIDIRECTIONAL
);
1882 cmd_free(info_p
, c
, 1);
1886 * Map (physical) PCI mem into (virtual) kernel space
1888 static void __iomem
*remap_pci_mem(ulong base
, ulong size
)
1890 ulong page_base
= ((ulong
) base
) & PAGE_MASK
;
1891 ulong page_offs
= ((ulong
) base
) - page_base
;
1892 void __iomem
*page_remapped
= ioremap(page_base
, page_offs
+size
);
1894 return page_remapped
? (page_remapped
+ page_offs
) : NULL
;
1898 * Takes jobs of the Q and sends them to the hardware, then puts it on
1899 * the Q to wait for completion.
1901 static void start_io( ctlr_info_t
*h
)
1903 CommandList_struct
*c
;
1905 while(( c
= h
->reqQ
) != NULL
)
1907 /* can't do anything if fifo is full */
1908 if ((h
->access
.fifo_full(h
))) {
1909 printk(KERN_WARNING
"cciss: fifo full\n");
1913 /* Get the frist entry from the Request Q */
1914 removeQ(&(h
->reqQ
), c
);
1917 /* Tell the controller execute command */
1918 h
->access
.submit_command(h
, c
);
1920 /* Put job onto the completed Q */
1921 addQ (&(h
->cmpQ
), c
);
1925 static inline void complete_buffers(struct bio
*bio
, int status
)
1928 struct bio
*xbh
= bio
->bi_next
;
1929 int nr_sectors
= bio_sectors(bio
);
1931 bio
->bi_next
= NULL
;
1932 blk_finished_io(len
);
1933 bio_endio(bio
, nr_sectors
<< 9, status
? 0 : -EIO
);
1938 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
1939 /* Zeros out the error record and then resends the command back */
1940 /* to the controller */
1941 static inline void resend_cciss_cmd( ctlr_info_t
*h
, CommandList_struct
*c
)
1943 /* erase the old error information */
1944 memset(c
->err_info
, 0, sizeof(ErrorInfo_struct
));
1946 /* add it to software queue and then send it to the controller */
1949 if(h
->Qdepth
> h
->maxQsinceinit
)
1950 h
->maxQsinceinit
= h
->Qdepth
;
1954 /* checks the status of the job and calls complete buffers to mark all
1955 * buffers for the completed job.
1957 static inline void complete_command( ctlr_info_t
*h
, CommandList_struct
*cmd
,
1968 if(cmd
->err_info
->CommandStatus
!= 0)
1969 { /* an error has occurred */
1970 switch(cmd
->err_info
->CommandStatus
)
1972 unsigned char sense_key
;
1973 case CMD_TARGET_STATUS
:
1976 if( cmd
->err_info
->ScsiStatus
== 0x02)
1978 printk(KERN_WARNING
"cciss: cmd %p "
1979 "has CHECK CONDITION "
1980 " byte 2 = 0x%x\n", cmd
,
1981 cmd
->err_info
->SenseInfo
[2]
1983 /* check the sense key */
1985 cmd
->err_info
->SenseInfo
[2];
1986 /* no status or recovered error */
1987 if((sense_key
== 0x0) ||
1994 printk(KERN_WARNING
"cciss: cmd %p "
1995 "has SCSI Status 0x%x\n",
1996 cmd
, cmd
->err_info
->ScsiStatus
);
1999 case CMD_DATA_UNDERRUN
:
2000 printk(KERN_WARNING
"cciss: cmd %p has"
2001 " completed with data underrun "
2004 case CMD_DATA_OVERRUN
:
2005 printk(KERN_WARNING
"cciss: cmd %p has"
2006 " completed with data overrun "
2010 printk(KERN_WARNING
"cciss: cmd %p is "
2011 "reported invalid\n", cmd
);
2014 case CMD_PROTOCOL_ERR
:
2015 printk(KERN_WARNING
"cciss: cmd %p has "
2016 "protocol error \n", cmd
);
2019 case CMD_HARDWARE_ERR
:
2020 printk(KERN_WARNING
"cciss: cmd %p had "
2021 " hardware error\n", cmd
);
2024 case CMD_CONNECTION_LOST
:
2025 printk(KERN_WARNING
"cciss: cmd %p had "
2026 "connection lost\n", cmd
);
2030 printk(KERN_WARNING
"cciss: cmd %p was "
2034 case CMD_ABORT_FAILED
:
2035 printk(KERN_WARNING
"cciss: cmd %p reports "
2036 "abort failed\n", cmd
);
2039 case CMD_UNSOLICITED_ABORT
:
2040 printk(KERN_WARNING
"cciss%d: unsolicited "
2041 "abort %p\n", h
->ctlr
, cmd
);
2042 if (cmd
->retry_count
< MAX_CMD_RETRIES
) {
2045 "cciss%d: retrying %p\n",
2050 "cciss%d: %p retried too "
2051 "many times\n", h
->ctlr
, cmd
);
2055 printk(KERN_WARNING
"cciss: cmd %p timedout\n",
2060 printk(KERN_WARNING
"cciss: cmd %p returned "
2061 "unknown status %x\n", cmd
,
2062 cmd
->err_info
->CommandStatus
);
2066 /* We need to return this command */
2068 resend_cciss_cmd(h
,cmd
);
2071 /* command did not need to be retried */
2072 /* unmap the DMA mapping for all the scatter gather elements */
2073 for(i
=0; i
<cmd
->Header
.SGList
; i
++) {
2074 temp64
.val32
.lower
= cmd
->SG
[i
].Addr
.lower
;
2075 temp64
.val32
.upper
= cmd
->SG
[i
].Addr
.upper
;
2076 pci_unmap_page(hba
[cmd
->ctlr
]->pdev
,
2077 temp64
.val
, cmd
->SG
[i
].Len
,
2078 (cmd
->Request
.Type
.Direction
== XFER_READ
) ?
2079 PCI_DMA_FROMDEVICE
: PCI_DMA_TODEVICE
);
2081 complete_buffers(cmd
->rq
->bio
, status
);
2084 printk("Done with %p\n", cmd
->rq
);
2085 #endif /* CCISS_DEBUG */
2087 end_that_request_last(cmd
->rq
);
2092 * Get a request and submit it to the controller.
2094 static void do_cciss_request(request_queue_t
*q
)
2096 ctlr_info_t
*h
= q
->queuedata
;
2097 CommandList_struct
*c
;
2099 struct request
*creq
;
2101 struct scatterlist tmp_sg
[MAXSGENTRIES
];
2102 drive_info_struct
*drv
;
2105 /* We call start_io here in case there is a command waiting on the
2106 * queue that has not been sent.
2108 if (blk_queue_plugged(q
))
2112 creq
= elv_next_request(q
);
2116 if (creq
->nr_phys_segments
> MAXSGENTRIES
)
2119 if (( c
= cmd_alloc(h
, 1)) == NULL
)
2122 blkdev_dequeue_request(creq
);
2124 spin_unlock_irq(q
->queue_lock
);
2126 c
->cmd_type
= CMD_RWREQ
;
2129 /* fill in the request */
2130 drv
= creq
->rq_disk
->private_data
;
2131 c
->Header
.ReplyQueue
= 0; // unused in simple mode
2132 c
->Header
.Tag
.lower
= c
->busaddr
; // use the physical address the cmd block for tag
2133 c
->Header
.LUN
.LogDev
.VolId
= drv
->LunID
;
2134 c
->Header
.LUN
.LogDev
.Mode
= 1;
2135 c
->Request
.CDBLen
= 10; // 12 byte commands not in FW yet;
2136 c
->Request
.Type
.Type
= TYPE_CMD
; // It is a command.
2137 c
->Request
.Type
.Attribute
= ATTR_SIMPLE
;
2138 c
->Request
.Type
.Direction
=
2139 (rq_data_dir(creq
) == READ
) ? XFER_READ
: XFER_WRITE
;
2140 c
->Request
.Timeout
= 0; // Don't time out
2141 c
->Request
.CDB
[0] = (rq_data_dir(creq
) == READ
) ? CCISS_READ
: CCISS_WRITE
;
2142 start_blk
= creq
->sector
;
2144 printk(KERN_DEBUG
"ciss: sector =%d nr_sectors=%d\n",(int) creq
->sector
,
2145 (int) creq
->nr_sectors
);
2146 #endif /* CCISS_DEBUG */
2148 seg
= blk_rq_map_sg(q
, creq
, tmp_sg
);
2150 /* get the DMA records for the setup */
2151 if (c
->Request
.Type
.Direction
== XFER_READ
)
2152 dir
= PCI_DMA_FROMDEVICE
;
2154 dir
= PCI_DMA_TODEVICE
;
2156 for (i
=0; i
<seg
; i
++)
2158 c
->SG
[i
].Len
= tmp_sg
[i
].length
;
2159 temp64
.val
= (__u64
) pci_map_page(h
->pdev
, tmp_sg
[i
].page
,
2160 tmp_sg
[i
].offset
, tmp_sg
[i
].length
,
2162 c
->SG
[i
].Addr
.lower
= temp64
.val32
.lower
;
2163 c
->SG
[i
].Addr
.upper
= temp64
.val32
.upper
;
2164 c
->SG
[i
].Ext
= 0; // we are not chaining
2166 /* track how many SG entries we are using */
2171 printk(KERN_DEBUG
"cciss: Submitting %d sectors in %d segments\n", creq
->nr_sectors
, seg
);
2172 #endif /* CCISS_DEBUG */
2174 c
->Header
.SGList
= c
->Header
.SGTotal
= seg
;
2175 c
->Request
.CDB
[1]= 0;
2176 c
->Request
.CDB
[2]= (start_blk
>> 24) & 0xff; //MSB
2177 c
->Request
.CDB
[3]= (start_blk
>> 16) & 0xff;
2178 c
->Request
.CDB
[4]= (start_blk
>> 8) & 0xff;
2179 c
->Request
.CDB
[5]= start_blk
& 0xff;
2180 c
->Request
.CDB
[6]= 0; // (sect >> 24) & 0xff; MSB
2181 c
->Request
.CDB
[7]= (creq
->nr_sectors
>> 8) & 0xff;
2182 c
->Request
.CDB
[8]= creq
->nr_sectors
& 0xff;
2183 c
->Request
.CDB
[9] = c
->Request
.CDB
[11] = c
->Request
.CDB
[12] = 0;
2185 spin_lock_irq(q
->queue_lock
);
2189 if(h
->Qdepth
> h
->maxQsinceinit
)
2190 h
->maxQsinceinit
= h
->Qdepth
;
2196 /* We will already have the driver lock here so not need
2202 static irqreturn_t
do_cciss_intr(int irq
, void *dev_id
, struct pt_regs
*regs
)
2204 ctlr_info_t
*h
= dev_id
;
2205 CommandList_struct
*c
;
2206 unsigned long flags
;
2209 int start_queue
= h
->next_to_run
;
2211 /* Is this interrupt for us? */
2212 if (( h
->access
.intr_pending(h
) == 0) || (h
->interrupts_enabled
== 0))
2216 * If there are completed commands in the completion queue,
2217 * we had better do something about it.
2219 spin_lock_irqsave(CCISS_LOCK(h
->ctlr
), flags
);
2220 while( h
->access
.intr_pending(h
))
2222 while((a
= h
->access
.command_completed(h
)) != FIFO_EMPTY
)
2226 if ((c
= h
->cmpQ
) == NULL
)
2228 printk(KERN_WARNING
"cciss: Completion of %08lx ignored\n", (unsigned long)a1
);
2231 while(c
->busaddr
!= a
) {
2237 * If we've found the command, take it off the
2238 * completion Q and free it
2240 if (c
->busaddr
== a
) {
2241 removeQ(&h
->cmpQ
, c
);
2242 if (c
->cmd_type
== CMD_RWREQ
) {
2243 complete_command(h
, c
, 0);
2244 } else if (c
->cmd_type
== CMD_IOCTL_PEND
) {
2245 complete(c
->waiting
);
2247 # ifdef CONFIG_CISS_SCSI_TAPE
2248 else if (c
->cmd_type
== CMD_SCSI
)
2249 complete_scsi_command(c
, 0, a1
);
2256 /* check to see if we have maxed out the number of commands that can
2257 * be placed on the queue. If so then exit. We do this check here
2258 * in case the interrupt we serviced was from an ioctl and did not
2259 * free any new commands.
2261 if ((find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
)) == NR_CMDS
)
2264 /* We have room on the queue for more commands. Now we need to queue
2265 * them up. We will also keep track of the next queue to run so
2266 * that every queue gets a chance to be started first.
2268 for (j
=0; j
< h
->highest_lun
+ 1; j
++){
2269 int curr_queue
= (start_queue
+ j
) % (h
->highest_lun
+ 1);
2270 /* make sure the disk has been added and the drive is real
2271 * because this can be called from the middle of init_one.
2273 if(!(h
->drv
[curr_queue
].queue
) ||
2274 !(h
->drv
[curr_queue
].heads
))
2276 blk_start_queue(h
->gendisk
[curr_queue
]->queue
);
2278 /* check to see if we have maxed out the number of commands
2279 * that can be placed on the queue.
2281 if ((find_first_zero_bit(h
->cmd_pool_bits
, NR_CMDS
)) == NR_CMDS
)
2283 if (curr_queue
== start_queue
){
2284 h
->next_to_run
= (start_queue
+ 1) % (h
->highest_lun
+ 1);
2287 h
->next_to_run
= curr_queue
;
2291 curr_queue
= (curr_queue
+ 1) % (h
->highest_lun
+ 1);
2296 spin_unlock_irqrestore(CCISS_LOCK(h
->ctlr
), flags
);
2300 * We cannot read the structure directly, for portablity we must use
2302 * This is for debug only.
2305 static void print_cfg_table( CfgTable_struct
*tb
)
2310 printk("Controller Configuration information\n");
2311 printk("------------------------------------\n");
2313 temp_name
[i
] = readb(&(tb
->Signature
[i
]));
2315 printk(" Signature = %s\n", temp_name
);
2316 printk(" Spec Number = %d\n", readl(&(tb
->SpecValence
)));
2317 printk(" Transport methods supported = 0x%x\n",
2318 readl(&(tb
-> TransportSupport
)));
2319 printk(" Transport methods active = 0x%x\n",
2320 readl(&(tb
->TransportActive
)));
2321 printk(" Requested transport Method = 0x%x\n",
2322 readl(&(tb
->HostWrite
.TransportRequest
)));
2323 printk(" Coalese Interrupt Delay = 0x%x\n",
2324 readl(&(tb
->HostWrite
.CoalIntDelay
)));
2325 printk(" Coalese Interrupt Count = 0x%x\n",
2326 readl(&(tb
->HostWrite
.CoalIntCount
)));
2327 printk(" Max outstanding commands = 0x%d\n",
2328 readl(&(tb
->CmdsOutMax
)));
2329 printk(" Bus Types = 0x%x\n", readl(&(tb
-> BusTypes
)));
2331 temp_name
[i
] = readb(&(tb
->ServerName
[i
]));
2332 temp_name
[16] = '\0';
2333 printk(" Server Name = %s\n", temp_name
);
2334 printk(" Heartbeat Counter = 0x%x\n\n\n",
2335 readl(&(tb
->HeartBeat
)));
2337 #endif /* CCISS_DEBUG */
2339 static void release_io_mem(ctlr_info_t
*c
)
2341 /* if IO mem was not protected do nothing */
2342 if( c
->io_mem_addr
== 0)
2344 release_region(c
->io_mem_addr
, c
->io_mem_length
);
2346 c
->io_mem_length
= 0;
2349 static int find_PCI_BAR_index(struct pci_dev
*pdev
,
2350 unsigned long pci_bar_addr
)
2352 int i
, offset
, mem_type
, bar_type
;
2353 if (pci_bar_addr
== PCI_BASE_ADDRESS_0
) /* looking for BAR zero? */
2356 for (i
=0; i
<DEVICE_COUNT_RESOURCE
; i
++) {
2357 bar_type
= pci_resource_flags(pdev
, i
) &
2358 PCI_BASE_ADDRESS_SPACE
;
2359 if (bar_type
== PCI_BASE_ADDRESS_SPACE_IO
)
2362 mem_type
= pci_resource_flags(pdev
, i
) &
2363 PCI_BASE_ADDRESS_MEM_TYPE_MASK
;
2365 case PCI_BASE_ADDRESS_MEM_TYPE_32
:
2366 case PCI_BASE_ADDRESS_MEM_TYPE_1M
:
2367 offset
+= 4; /* 32 bit */
2369 case PCI_BASE_ADDRESS_MEM_TYPE_64
:
2372 default: /* reserved in PCI 2.2 */
2373 printk(KERN_WARNING
"Base address is invalid\n");
2378 if (offset
== pci_bar_addr
- PCI_BASE_ADDRESS_0
)
2384 static int cciss_pci_init(ctlr_info_t
*c
, struct pci_dev
*pdev
)
2386 ushort subsystem_vendor_id
, subsystem_device_id
, command
;
2387 __u32 board_id
, scratchpad
= 0;
2389 __u32 cfg_base_addr
;
2390 __u64 cfg_base_addr_index
;
2393 /* check to see if controller has been disabled */
2394 /* BEFORE trying to enable it */
2395 (void) pci_read_config_word(pdev
, PCI_COMMAND
,&command
);
2396 if(!(command
& 0x02))
2398 printk(KERN_WARNING
"cciss: controller appears to be disabled\n");
2402 if (pci_enable_device(pdev
))
2404 printk(KERN_ERR
"cciss: Unable to Enable PCI device\n");
2408 subsystem_vendor_id
= pdev
->subsystem_vendor
;
2409 subsystem_device_id
= pdev
->subsystem_device
;
2410 board_id
= (((__u32
) (subsystem_device_id
<< 16) & 0xffff0000) |
2411 subsystem_vendor_id
);
2413 /* search for our IO range so we can protect it */
2414 for(i
=0; i
<DEVICE_COUNT_RESOURCE
; i
++)
2416 /* is this an IO range */
2417 if( pci_resource_flags(pdev
, i
) & 0x01 ) {
2418 c
->io_mem_addr
= pci_resource_start(pdev
, i
);
2419 c
->io_mem_length
= pci_resource_end(pdev
, i
) -
2420 pci_resource_start(pdev
, i
) +1;
2422 printk("IO value found base_addr[%d] %lx %lx\n", i
,
2423 c
->io_mem_addr
, c
->io_mem_length
);
2424 #endif /* CCISS_DEBUG */
2425 /* register the IO range */
2426 if(!request_region( c
->io_mem_addr
,
2427 c
->io_mem_length
, "cciss"))
2429 printk(KERN_WARNING
"cciss I/O memory range already in use addr=%lx length=%ld\n",
2430 c
->io_mem_addr
, c
->io_mem_length
);
2432 c
->io_mem_length
= 0;
2439 printk("command = %x\n", command
);
2440 printk("irq = %x\n", pdev
->irq
);
2441 printk("board_id = %x\n", board_id
);
2442 #endif /* CCISS_DEBUG */
2444 c
->intr
= pdev
->irq
;
2447 * Memory base addr is first addr , the second points to the config
2451 c
->paddr
= pci_resource_start(pdev
, 0); /* addressing mode bits already removed */
2453 printk("address 0 = %x\n", c
->paddr
);
2454 #endif /* CCISS_DEBUG */
2455 c
->vaddr
= remap_pci_mem(c
->paddr
, 200);
2457 /* Wait for the board to become ready. (PCI hotplug needs this.)
2458 * We poll for up to 120 secs, once per 100ms. */
2459 for (i
=0; i
< 1200; i
++) {
2460 scratchpad
= readl(c
->vaddr
+ SA5_SCRATCHPAD_OFFSET
);
2461 if (scratchpad
== CCISS_FIRMWARE_READY
)
2463 set_current_state(TASK_INTERRUPTIBLE
);
2464 schedule_timeout(HZ
/ 10); /* wait 100ms */
2466 if (scratchpad
!= CCISS_FIRMWARE_READY
) {
2467 printk(KERN_WARNING
"cciss: Board not ready. Timed out.\n");
2471 /* get the address index number */
2472 cfg_base_addr
= readl(c
->vaddr
+ SA5_CTCFG_OFFSET
);
2473 cfg_base_addr
&= (__u32
) 0x0000ffff;
2475 printk("cfg base address = %x\n", cfg_base_addr
);
2476 #endif /* CCISS_DEBUG */
2477 cfg_base_addr_index
=
2478 find_PCI_BAR_index(pdev
, cfg_base_addr
);
2480 printk("cfg base address index = %x\n", cfg_base_addr_index
);
2481 #endif /* CCISS_DEBUG */
2482 if (cfg_base_addr_index
== -1) {
2483 printk(KERN_WARNING
"cciss: Cannot find cfg_base_addr_index\n");
2488 cfg_offset
= readl(c
->vaddr
+ SA5_CTMEM_OFFSET
);
2490 printk("cfg offset = %x\n", cfg_offset
);
2491 #endif /* CCISS_DEBUG */
2492 c
->cfgtable
= remap_pci_mem(pci_resource_start(pdev
,
2493 cfg_base_addr_index
) + cfg_offset
,
2494 sizeof(CfgTable_struct
));
2495 c
->board_id
= board_id
;
2498 print_cfg_table(c
->cfgtable
);
2499 #endif /* CCISS_DEBUG */
2501 for(i
=0; i
<NR_PRODUCTS
; i
++) {
2502 if (board_id
== products
[i
].board_id
) {
2503 c
->product_name
= products
[i
].product_name
;
2504 c
->access
= *(products
[i
].access
);
2508 if (i
== NR_PRODUCTS
) {
2509 printk(KERN_WARNING
"cciss: Sorry, I don't know how"
2510 " to access the Smart Array controller %08lx\n",
2511 (unsigned long)board_id
);
2514 if ( (readb(&c
->cfgtable
->Signature
[0]) != 'C') ||
2515 (readb(&c
->cfgtable
->Signature
[1]) != 'I') ||
2516 (readb(&c
->cfgtable
->Signature
[2]) != 'S') ||
2517 (readb(&c
->cfgtable
->Signature
[3]) != 'S') )
2519 printk("Does not appear to be a valid CISS config table\n");
2525 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2527 prefetch
= readl(&(c
->cfgtable
->SCSI_Prefetch
));
2529 writel(prefetch
, &(c
->cfgtable
->SCSI_Prefetch
));
2534 printk("Trying to put board into Simple mode\n");
2535 #endif /* CCISS_DEBUG */
2536 c
->max_commands
= readl(&(c
->cfgtable
->CmdsOutMax
));
2537 /* Update the field, and then ring the doorbell */
2538 writel( CFGTBL_Trans_Simple
,
2539 &(c
->cfgtable
->HostWrite
.TransportRequest
));
2540 writel( CFGTBL_ChangeReq
, c
->vaddr
+ SA5_DOORBELL
);
2542 /* under certain very rare conditions, this can take awhile.
2543 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2544 * as we enter this code.) */
2545 for(i
=0;i
<MAX_CONFIG_WAIT
;i
++) {
2546 if (!(readl(c
->vaddr
+ SA5_DOORBELL
) & CFGTBL_ChangeReq
))
2548 /* delay and try again */
2549 set_current_state(TASK_INTERRUPTIBLE
);
2550 schedule_timeout(10);
2554 printk(KERN_DEBUG
"I counter got to %d %x\n", i
, readl(c
->vaddr
+ SA5_DOORBELL
));
2555 #endif /* CCISS_DEBUG */
2557 print_cfg_table(c
->cfgtable
);
2558 #endif /* CCISS_DEBUG */
2560 if (!(readl(&(c
->cfgtable
->TransportActive
)) & CFGTBL_Trans_Simple
))
2562 printk(KERN_WARNING
"cciss: unable to get board into"
2571 * Gets information about the local volumes attached to the controller.
2573 static void cciss_getgeometry(int cntl_num
)
2575 ReportLunData_struct
*ld_buff
;
2576 ReadCapdata_struct
*size_buff
;
2577 InquiryData_struct
*inq_buff
;
2585 ld_buff
= kmalloc(sizeof(ReportLunData_struct
), GFP_KERNEL
);
2586 if (ld_buff
== NULL
)
2588 printk(KERN_ERR
"cciss: out of memory\n");
2591 memset(ld_buff
, 0, sizeof(ReportLunData_struct
));
2592 size_buff
= kmalloc(sizeof( ReadCapdata_struct
), GFP_KERNEL
);
2593 if (size_buff
== NULL
)
2595 printk(KERN_ERR
"cciss: out of memory\n");
2599 inq_buff
= kmalloc(sizeof( InquiryData_struct
), GFP_KERNEL
);
2600 if (inq_buff
== NULL
)
2602 printk(KERN_ERR
"cciss: out of memory\n");
2607 /* Get the firmware version */
2608 return_code
= sendcmd(CISS_INQUIRY
, cntl_num
, inq_buff
,
2609 sizeof(InquiryData_struct
), 0, 0 ,0, NULL
, TYPE_CMD
);
2610 if (return_code
== IO_OK
)
2612 hba
[cntl_num
]->firm_ver
[0] = inq_buff
->data_byte
[32];
2613 hba
[cntl_num
]->firm_ver
[1] = inq_buff
->data_byte
[33];
2614 hba
[cntl_num
]->firm_ver
[2] = inq_buff
->data_byte
[34];
2615 hba
[cntl_num
]->firm_ver
[3] = inq_buff
->data_byte
[35];
2616 } else /* send command failed */
2618 printk(KERN_WARNING
"cciss: unable to determine firmware"
2619 " version of controller\n");
2621 /* Get the number of logical volumes */
2622 return_code
= sendcmd(CISS_REPORT_LOG
, cntl_num
, ld_buff
,
2623 sizeof(ReportLunData_struct
), 0, 0, 0, NULL
, TYPE_CMD
);
2625 if( return_code
== IO_OK
)
2628 printk("LUN Data\n--------------------------\n");
2629 #endif /* CCISS_DEBUG */
2631 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[0])) << 24;
2632 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[1])) << 16;
2633 listlength
|= (0xff & (unsigned int)(ld_buff
->LUNListLength
[2])) << 8;
2634 listlength
|= 0xff & (unsigned int)(ld_buff
->LUNListLength
[3]);
2635 } else /* reading number of logical volumes failed */
2637 printk(KERN_WARNING
"cciss: report logical volume"
2638 " command failed\n");
2641 hba
[cntl_num
]->num_luns
= listlength
/ 8; // 8 bytes pre entry
2642 if (hba
[cntl_num
]->num_luns
> CISS_MAX_LUN
)
2644 printk(KERN_ERR
"ciss: only %d number of logical volumes supported\n",
2646 hba
[cntl_num
]->num_luns
= CISS_MAX_LUN
;
2649 printk(KERN_DEBUG
"Length = %x %x %x %x = %d\n", ld_buff
->LUNListLength
[0],
2650 ld_buff
->LUNListLength
[1], ld_buff
->LUNListLength
[2],
2651 ld_buff
->LUNListLength
[3], hba
[cntl_num
]->num_luns
);
2652 #endif /* CCISS_DEBUG */
2654 hba
[cntl_num
]->highest_lun
= hba
[cntl_num
]->num_luns
-1;
2655 for(i
=0; i
< hba
[cntl_num
]->num_luns
; i
++)
2658 lunid
= (0xff & (unsigned int)(ld_buff
->LUN
[i
][3])) << 24;
2659 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][2])) << 16;
2660 lunid
|= (0xff & (unsigned int)(ld_buff
->LUN
[i
][1])) << 8;
2661 lunid
|= 0xff & (unsigned int)(ld_buff
->LUN
[i
][0]);
2663 hba
[cntl_num
]->drv
[i
].LunID
= lunid
;
2667 printk(KERN_DEBUG
"LUN[%d]: %x %x %x %x = %x\n", i
,
2668 ld_buff
->LUN
[i
][0], ld_buff
->LUN
[i
][1],ld_buff
->LUN
[i
][2],
2669 ld_buff
->LUN
[i
][3], hba
[cntl_num
]->drv
[i
].LunID
);
2670 #endif /* CCISS_DEBUG */
2671 cciss_read_capacity(cntl_num
, i
, size_buff
, 0,
2672 &total_size
, &block_size
);
2673 cciss_geometry_inquiry(cntl_num
, i
, 0, total_size
, block_size
,
2674 inq_buff
, &hba
[cntl_num
]->drv
[i
]);
2681 /* Function to find the first free pointer into our hba[] array */
2682 /* Returns -1 if no free entries are left. */
2683 static int alloc_cciss_hba(void)
2685 struct gendisk
*disk
[NWD
];
2687 for (n
= 0; n
< NWD
; n
++) {
2688 disk
[n
] = alloc_disk(1 << NWD_SHIFT
);
2693 for(i
=0; i
< MAX_CTLR
; i
++) {
2696 p
= kmalloc(sizeof(ctlr_info_t
), GFP_KERNEL
);
2699 memset(p
, 0, sizeof(ctlr_info_t
));
2700 for (n
= 0; n
< NWD
; n
++)
2701 p
->gendisk
[n
] = disk
[n
];
2706 printk(KERN_WARNING
"cciss: This driver supports a maximum"
2707 " of %d controllers.\n", MAX_CTLR
);
2710 printk(KERN_ERR
"cciss: out of memory.\n");
2717 static void free_hba(int i
)
2719 ctlr_info_t
*p
= hba
[i
];
2723 for (n
= 0; n
< NWD
; n
++)
2724 put_disk(p
->gendisk
[n
]);
2729 * This is it. Find all the controllers and register them. I really hate
2730 * stealing all these major device numbers.
2731 * returns the number of block devices registered.
2733 static int __devinit
cciss_init_one(struct pci_dev
*pdev
,
2734 const struct pci_device_id
*ent
)
2741 printk(KERN_DEBUG
"cciss: Device 0x%x has been found at"
2742 " bus %d dev %d func %d\n",
2743 pdev
->device
, pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
),
2744 PCI_FUNC(pdev
->devfn
));
2745 i
= alloc_cciss_hba();
2749 hba
[i
]->busy_initializing
= 1;
2751 if (cciss_pci_init(hba
[i
], pdev
) != 0)
2754 sprintf(hba
[i
]->devname
, "cciss%d", i
);
2756 hba
[i
]->pdev
= pdev
;
2758 /* configure PCI DMA stuff */
2759 if (!pci_set_dma_mask(pdev
, DMA_64BIT_MASK
))
2760 printk("cciss: using DAC cycles\n");
2761 else if (!pci_set_dma_mask(pdev
, DMA_32BIT_MASK
))
2762 printk("cciss: not using DAC cycles\n");
2764 printk("cciss: no suitable DMA available\n");
2769 * register with the major number, or get a dynamic major number
2770 * by passing 0 as argument. This is done for greater than
2771 * 8 controller support.
2773 if (i
< MAX_CTLR_ORIG
)
2774 hba
[i
]->major
= MAJOR_NR
+ i
;
2775 rc
= register_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
2776 if(rc
== -EBUSY
|| rc
== -EINVAL
) {
2778 "cciss: Unable to get major number %d for %s "
2779 "on hba %d\n", hba
[i
]->major
, hba
[i
]->devname
, i
);
2783 if (i
>= MAX_CTLR_ORIG
)
2787 /* make sure the board interrupts are off */
2788 hba
[i
]->access
.set_intr_mask(hba
[i
], CCISS_INTR_OFF
);
2789 if( request_irq(hba
[i
]->intr
, do_cciss_intr
,
2790 SA_INTERRUPT
| SA_SHIRQ
| SA_SAMPLE_RANDOM
,
2791 hba
[i
]->devname
, hba
[i
])) {
2792 printk(KERN_ERR
"cciss: Unable to get irq %d for %s\n",
2793 hba
[i
]->intr
, hba
[i
]->devname
);
2796 hba
[i
]->cmd_pool_bits
= kmalloc(((NR_CMDS
+BITS_PER_LONG
-1)/BITS_PER_LONG
)*sizeof(unsigned long), GFP_KERNEL
);
2797 hba
[i
]->cmd_pool
= (CommandList_struct
*)pci_alloc_consistent(
2798 hba
[i
]->pdev
, NR_CMDS
* sizeof(CommandList_struct
),
2799 &(hba
[i
]->cmd_pool_dhandle
));
2800 hba
[i
]->errinfo_pool
= (ErrorInfo_struct
*)pci_alloc_consistent(
2801 hba
[i
]->pdev
, NR_CMDS
* sizeof( ErrorInfo_struct
),
2802 &(hba
[i
]->errinfo_pool_dhandle
));
2803 if((hba
[i
]->cmd_pool_bits
== NULL
)
2804 || (hba
[i
]->cmd_pool
== NULL
)
2805 || (hba
[i
]->errinfo_pool
== NULL
)) {
2806 printk( KERN_ERR
"cciss: out of memory");
2810 spin_lock_init(&hba
[i
]->lock
);
2812 /* Initialize the pdev driver private data.
2813 have it point to hba[i]. */
2814 pci_set_drvdata(pdev
, hba
[i
]);
2815 /* command and error info recs zeroed out before
2817 memset(hba
[i
]->cmd_pool_bits
, 0, ((NR_CMDS
+BITS_PER_LONG
-1)/BITS_PER_LONG
)*sizeof(unsigned long));
2820 printk(KERN_DEBUG
"Scanning for drives on controller cciss%d\n",i
);
2821 #endif /* CCISS_DEBUG */
2823 cciss_getgeometry(i
);
2825 cciss_scsi_setup(i
);
2827 /* Turn the interrupts on so we can service requests */
2828 hba
[i
]->access
.set_intr_mask(hba
[i
], CCISS_INTR_ON
);
2832 for(j
=0; j
< NWD
; j
++) { /* mfm */
2833 drive_info_struct
*drv
= &(hba
[i
]->drv
[j
]);
2834 struct gendisk
*disk
= hba
[i
]->gendisk
[j
];
2836 q
= blk_init_queue(do_cciss_request
, &hba
[i
]->lock
);
2839 "cciss: unable to allocate queue for disk %d\n",
2845 q
->backing_dev_info
.ra_pages
= READ_AHEAD
;
2846 blk_queue_bounce_limit(q
, hba
[i
]->pdev
->dma_mask
);
2848 /* This is a hardware imposed limit. */
2849 blk_queue_max_hw_segments(q
, MAXSGENTRIES
);
2851 /* This is a limit in the driver and could be eliminated. */
2852 blk_queue_max_phys_segments(q
, MAXSGENTRIES
);
2854 blk_queue_max_sectors(q
, 512);
2856 q
->queuedata
= hba
[i
];
2857 sprintf(disk
->disk_name
, "cciss/c%dd%d", i
, j
);
2858 sprintf(disk
->devfs_name
, "cciss/host%d/target%d", i
, j
);
2859 disk
->major
= hba
[i
]->major
;
2860 disk
->first_minor
= j
<< NWD_SHIFT
;
2861 disk
->fops
= &cciss_fops
;
2863 disk
->private_data
= drv
;
2864 /* we must register the controller even if no disks exist */
2865 /* this is for the online array utilities */
2866 if(!drv
->heads
&& j
)
2868 blk_queue_hardsect_size(q
, drv
->block_size
);
2869 set_capacity(disk
, drv
->nr_blocks
);
2873 hba
[i
]->busy_initializing
= 0;
2877 if(hba
[i
]->cmd_pool_bits
)
2878 kfree(hba
[i
]->cmd_pool_bits
);
2879 if(hba
[i
]->cmd_pool
)
2880 pci_free_consistent(hba
[i
]->pdev
,
2881 NR_CMDS
* sizeof(CommandList_struct
),
2882 hba
[i
]->cmd_pool
, hba
[i
]->cmd_pool_dhandle
);
2883 if(hba
[i
]->errinfo_pool
)
2884 pci_free_consistent(hba
[i
]->pdev
,
2885 NR_CMDS
* sizeof( ErrorInfo_struct
),
2886 hba
[i
]->errinfo_pool
,
2887 hba
[i
]->errinfo_pool_dhandle
);
2888 free_irq(hba
[i
]->intr
, hba
[i
]);
2890 unregister_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
2892 release_io_mem(hba
[i
]);
2894 hba
[i
]->busy_initializing
= 0;
2898 static void __devexit
cciss_remove_one (struct pci_dev
*pdev
)
2900 ctlr_info_t
*tmp_ptr
;
2905 if (pci_get_drvdata(pdev
) == NULL
)
2907 printk( KERN_ERR
"cciss: Unable to remove device \n");
2910 tmp_ptr
= pci_get_drvdata(pdev
);
2914 printk(KERN_ERR
"cciss: device appears to "
2915 "already be removed \n");
2918 /* Turn board interrupts off and send the flush cache command */
2919 /* sendcmd will turn off interrupt, and send the flush...
2920 * To write all data in the battery backed cache to disks */
2921 memset(flush_buf
, 0, 4);
2922 return_code
= sendcmd(CCISS_CACHE_FLUSH
, i
, flush_buf
, 4, 0, 0, 0, NULL
,
2924 if(return_code
!= IO_OK
)
2926 printk(KERN_WARNING
"Error Flushing cache on controller %d\n",
2929 free_irq(hba
[i
]->intr
, hba
[i
]);
2930 pci_set_drvdata(pdev
, NULL
);
2931 iounmap(hba
[i
]->vaddr
);
2932 cciss_unregister_scsi(i
); /* unhook from SCSI subsystem */
2933 unregister_blkdev(hba
[i
]->major
, hba
[i
]->devname
);
2934 remove_proc_entry(hba
[i
]->devname
, proc_cciss
);
2936 /* remove it from the disk list */
2937 for (j
= 0; j
< NWD
; j
++) {
2938 struct gendisk
*disk
= hba
[i
]->gendisk
[j
];
2939 if (disk
->flags
& GENHD_FL_UP
)
2940 blk_cleanup_queue(disk
->queue
);
2944 pci_free_consistent(hba
[i
]->pdev
, NR_CMDS
* sizeof(CommandList_struct
),
2945 hba
[i
]->cmd_pool
, hba
[i
]->cmd_pool_dhandle
);
2946 pci_free_consistent(hba
[i
]->pdev
, NR_CMDS
* sizeof( ErrorInfo_struct
),
2947 hba
[i
]->errinfo_pool
, hba
[i
]->errinfo_pool_dhandle
);
2948 kfree(hba
[i
]->cmd_pool_bits
);
2949 release_io_mem(hba
[i
]);
2953 static struct pci_driver cciss_pci_driver
= {
2955 .probe
= cciss_init_one
,
2956 .remove
= __devexit_p(cciss_remove_one
),
2957 .id_table
= cciss_pci_device_id
, /* id_table */
2961 * This is it. Register the PCI driver information for the cards we control
2962 * the OS will call our registered routines when it finds one of our cards.
2964 static int __init
cciss_init(void)
2966 printk(KERN_INFO DRIVER_NAME
"\n");
2968 /* Register for our PCI devices */
2969 return pci_module_init(&cciss_pci_driver
);
2972 static void __exit
cciss_cleanup(void)
2976 pci_unregister_driver(&cciss_pci_driver
);
2977 /* double check that all controller entrys have been removed */
2978 for (i
=0; i
< MAX_CTLR
; i
++)
2982 printk(KERN_WARNING
"cciss: had to remove"
2983 " controller %d\n", i
);
2984 cciss_remove_one(hba
[i
]->pdev
);
2987 remove_proc_entry("cciss", proc_root_driver
);
2990 module_init(cciss_init
);
2991 module_exit(cciss_cleanup
);