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