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