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