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