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