blob: 1be82d544dc3866d15f8819e3f1b2a5859152531 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
Mike Millerfb86a352006-01-08 01:03:50 -08003 * Copyright 2000, 2006 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/module.h>
24#include <linux/interrupt.h>
25#include <linux/types.h>
26#include <linux/pci.h>
27#include <linux/kernel.h>
28#include <linux/slab.h>
29#include <linux/delay.h>
30#include <linux/major.h>
31#include <linux/fs.h>
32#include <linux/bio.h>
33#include <linux/blkpg.h>
34#include <linux/timer.h>
35#include <linux/proc_fs.h>
Bjorn Helgaas7c832832006-06-25 05:49:06 -070036#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/hdreg.h>
38#include <linux/spinlock.h>
39#include <linux/compat.h>
Jens Axboe2056a782006-03-23 20:00:26 +010040#include <linux/blktrace_api.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#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>
Stephen Camerond5d3b732007-05-08 00:30:02 -070048#include <scsi/scsi.h>
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -070049#include <scsi/sg.h>
50#include <scsi/scsi_ioctl.h>
51#include <linux/cdrom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53#define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
Mike Miller9d827c92006-12-06 20:34:58 -080054#define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
55#define DRIVER_VERSION CCISS_DRIVER_VERSION(3,6,14)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57/* Embedded module documentation macros - see modules.h */
58MODULE_AUTHOR("Hewlett-Packard Company");
Mike Miller9d827c92006-12-06 20:34:58 -080059MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 3.6.14");
Linus Torvalds1da177e2005-04-16 15:20:36 -070060MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
Mike Miller1883c5a2006-09-12 20:36:07 -070061 " SA6i P600 P800 P400 P400i E200 E200i E500");
Mike Miller9d827c92006-12-06 20:34:58 -080062MODULE_VERSION("3.6.14");
Linus Torvalds1da177e2005-04-16 15:20:36 -070063MODULE_LICENSE("GPL");
64
65#include "cciss_cmd.h"
66#include "cciss.h"
67#include <linux/cciss_ioctl.h>
68
69/* define the PCI info for the cards we can control */
70static const struct pci_device_id cciss_pci_device_id[] = {
Bjorn Helgaasf82ccdb2006-06-25 05:49:07 -070071 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS, 0x0E11, 0x4070},
72 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
73 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
74 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
75 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
76 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
77 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
78 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
79 {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
80 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA, 0x103C, 0x3225},
81 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3223},
82 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3234},
83 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3235},
84 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3211},
85 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3212},
86 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3213},
87 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3214},
88 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD, 0x103C, 0x3215},
Mike Millerde923912006-12-06 20:35:03 -080089 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x3237},
Mike Miller (OS Dev9cff3b32007-06-19 20:52:18 +020090 {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC, 0x103C, 0x323D},
Mike Miller4ff9a9a2006-12-06 20:35:00 -080091 {PCI_VENDOR_ID_HP, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
92 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 {0,}
94};
Bjorn Helgaas7c832832006-06-25 05:49:06 -070095
Linus Torvalds1da177e2005-04-16 15:20:36 -070096MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098/* board_id = Subsystem Device ID & Vendor ID
99 * product = Marketing Name for the board
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700100 * access = Address of the struct of function pointers
Mike Millerf8806322006-12-06 20:35:01 -0800101 * nr_cmds = Number of commands supported by controller
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 */
103static struct board_type products[] = {
Mike Millerf8806322006-12-06 20:35:01 -0800104 {0x40700E11, "Smart Array 5300", &SA5_access, 512},
105 {0x40800E11, "Smart Array 5i", &SA5B_access, 512},
106 {0x40820E11, "Smart Array 532", &SA5B_access, 512},
107 {0x40830E11, "Smart Array 5312", &SA5B_access, 512},
108 {0x409A0E11, "Smart Array 641", &SA5_access, 512},
109 {0x409B0E11, "Smart Array 642", &SA5_access, 512},
110 {0x409C0E11, "Smart Array 6400", &SA5_access, 512},
111 {0x409D0E11, "Smart Array 6400 EM", &SA5_access, 512},
112 {0x40910E11, "Smart Array 6i", &SA5_access, 512},
113 {0x3225103C, "Smart Array P600", &SA5_access, 512},
114 {0x3223103C, "Smart Array P800", &SA5_access, 512},
115 {0x3234103C, "Smart Array P400", &SA5_access, 512},
116 {0x3235103C, "Smart Array P400i", &SA5_access, 512},
117 {0x3211103C, "Smart Array E200i", &SA5_access, 120},
118 {0x3212103C, "Smart Array E200", &SA5_access, 120},
119 {0x3213103C, "Smart Array E200i", &SA5_access, 120},
120 {0x3214103C, "Smart Array E200i", &SA5_access, 120},
121 {0x3215103C, "Smart Array E200i", &SA5_access, 120},
Mike Millerde923912006-12-06 20:35:03 -0800122 {0x3237103C, "Smart Array E500", &SA5_access, 512},
Mike Miller (OS Dev9cff3b32007-06-19 20:52:18 +0200123 {0x323D103C, "Smart Array P700m", &SA5_access, 512},
Mike Millerf8806322006-12-06 20:35:01 -0800124 {0xFFFF103C, "Unknown Smart Array", &SA5_access, 120},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125};
126
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -0700127/* How long to wait (in milliseconds) for board to go into simple mode */
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700128#define MAX_CONFIG_WAIT 30000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#define MAX_IOCTL_CONFIG_WAIT 1000
130
131/*define how many times we will try a command because of bus resets */
132#define MAX_CMD_RETRIES 3
133
134#define READ_AHEAD 1024
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#define MAX_CTLR 32
136
137/* Originally cciss driver only supports 8 major numbers */
138#define MAX_CTLR_ORIG 8
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static ctlr_info_t *hba[MAX_CTLR];
141
Jens Axboe165125e2007-07-24 09:28:11 +0200142static void do_cciss_request(struct request_queue *q);
David Howells7d12e782006-10-05 14:55:46 +0100143static irqreturn_t do_cciss_intr(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static int cciss_open(struct inode *inode, struct file *filep);
145static int cciss_release(struct inode *inode, struct file *filep);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700146static int cciss_ioctl(struct inode *inode, struct file *filep,
147 unsigned int cmd, unsigned long arg);
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800148static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150static int cciss_revalidate(struct gendisk *disk);
Mike Millerddd47442005-09-13 01:25:22 -0700151static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700152static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
153 int clear_all);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -0700155static void cciss_read_capacity(int ctlr, int logvol, int withirq,
156 sector_t *total_size, unsigned int *block_size);
157static void cciss_read_capacity_16(int ctlr, int logvol, int withirq,
158 sector_t *total_size, unsigned int *block_size);
159static void cciss_geometry_inquiry(int ctlr, int logvol,
160 int withirq, sector_t total_size,
161 unsigned int block_size, InquiryData_struct *inq_buff,
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700162 drive_info_struct *drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163static void cciss_getgeometry(int cntl_num);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700164static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
165 __u32);
166static void start_io(ctlr_info_t *h);
167static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
168 unsigned int use_unit_num, unsigned int log_unit,
169 __u8 page_code, unsigned char *scsi3addr, int cmd_type);
170static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
171 unsigned int use_unit_num, unsigned int log_unit,
172 __u8 page_code, int cmd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Mike Miller33079b22005-09-13 01:25:22 -0700174static void fail_all_cmds(unsigned long ctlr);
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176#ifdef CONFIG_PROC_FS
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700177static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
178 int length, int *eof, void *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179static void cciss_procinit(int i);
180#else
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700181static void cciss_procinit(int i)
182{
183}
184#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
186#ifdef CONFIG_COMPAT
187static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
188#endif
189
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700190static struct block_device_operations cciss_fops = {
191 .owner = THIS_MODULE,
192 .open = cciss_open,
193 .release = cciss_release,
194 .ioctl = cciss_ioctl,
195 .getgeo = cciss_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196#ifdef CONFIG_COMPAT
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700197 .compat_ioctl = cciss_compat_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#endif
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700199 .revalidate_disk = cciss_revalidate,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200};
201
202/*
203 * Enqueuing and dequeuing functions for cmdlists.
204 */
205static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
206{
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700207 if (*Qptr == NULL) {
208 *Qptr = c;
209 c->next = c->prev = c;
210 } else {
211 c->prev = (*Qptr)->prev;
212 c->next = (*Qptr);
213 (*Qptr)->prev->next = c;
214 (*Qptr)->prev = c;
215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700218static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
219 CommandList_struct *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700221 if (c && c->next != c) {
222 if (*Qptr == c)
223 *Qptr = c->next;
224 c->prev->next = c->next;
225 c->next->prev = c->prev;
226 } else {
227 *Qptr = NULL;
228 }
229 return c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
231
232#include "cciss_scsi.c" /* For SCSI tape support */
233
Randy Dunlap0f5486e2006-12-29 16:48:31 -0800234#define RAID_UNKNOWN 6
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236#ifdef CONFIG_PROC_FS
237
238/*
239 * Report information about this controller.
240 */
241#define ENG_GIG 1000000000
242#define ENG_GIG_FACTOR (ENG_GIG/512)
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700243static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
244 "UNKNOWN"
245};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247static struct proc_dir_entry *proc_cciss;
248
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700249static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
250 int length, int *eof, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251{
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700252 off_t pos = 0;
253 off_t len = 0;
254 int size, i, ctlr;
255 ctlr_info_t *h = (ctlr_info_t *) data;
256 drive_info_struct *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 unsigned long flags;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700258 sector_t vol_sz, vol_sz_frac;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700260 ctlr = h->ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
262 /* prevent displaying bogus info during configuration
263 * or deconfiguration of a logical volume
264 */
265 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
266 if (h->busy_configuring) {
267 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700268 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 }
270 h->busy_configuring = 1;
271 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
272
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700273 size = sprintf(buffer, "%s: HP %s Controller\n"
274 "Board ID: 0x%08lx\n"
275 "Firmware Version: %c%c%c%c\n"
276 "IRQ: %d\n"
277 "Logical drives: %d\n"
Mike Miller92c4231a2006-12-06 20:35:06 -0800278 "Max sectors: %d\n"
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700279 "Current Q depth: %d\n"
280 "Current # commands on controller: %d\n"
281 "Max Q depth since init: %d\n"
282 "Max # commands on controller since init: %d\n"
283 "Max SG entries since init: %d\n\n",
284 h->devname,
285 h->product_name,
286 (unsigned long)h->board_id,
287 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
288 h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
Mike Miller92c4231a2006-12-06 20:35:06 -0800289 h->num_luns,
290 h->cciss_max_sectors,
291 h->Qdepth, h->commands_outstanding,
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700292 h->maxQsinceinit, h->max_outstanding, h->maxSG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700294 pos += size;
295 len += size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700297 for (i = 0; i <= h->highest_lun; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700299 drv = &h->drv[i];
Mike Millerddd47442005-09-13 01:25:22 -0700300 if (drv->heads == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 continue;
302
303 vol_sz = drv->nr_blocks;
304 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
305 vol_sz_frac *= 100;
306 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
307
308 if (drv->raid_level > 5)
309 drv->raid_level = RAID_UNKNOWN;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700310 size = sprintf(buffer + len, "cciss/c%dd%d:"
311 "\t%4u.%02uGB\tRAID %s\n",
312 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
313 raid_label[drv->raid_level]);
314 pos += size;
315 len += size;
316 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700318 *eof = 1;
319 *start = buffer + offset;
320 len -= offset;
321 if (len > length)
322 len = length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 h->busy_configuring = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700324 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700327static int
328cciss_proc_write(struct file *file, const char __user *buffer,
329 unsigned long count, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 unsigned char cmd[80];
332 int len;
333#ifdef CONFIG_CISS_SCSI_TAPE
334 ctlr_info_t *h = (ctlr_info_t *) data;
335 int rc;
336#endif
337
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700338 if (count > sizeof(cmd) - 1)
339 return -EINVAL;
340 if (copy_from_user(cmd, buffer, count))
341 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 cmd[count] = '\0';
343 len = strlen(cmd); // above 3 lines ensure safety
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700344 if (len && cmd[len - 1] == '\n')
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 cmd[--len] = '\0';
346# ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700347 if (strcmp("engage scsi", cmd) == 0) {
348 rc = cciss_engage_scsi(h->ctlr);
349 if (rc != 0)
350 return -rc;
351 return count;
352 }
353 /* might be nice to have "disengage" too, but it's not
354 safely possible. (only 1 module use count, lock issues.) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355# endif
356 return -EINVAL;
357}
358
359/*
360 * Get us a file in /proc/cciss that says something about each controller.
361 * Create /proc/cciss if it doesn't exist yet.
362 */
363static void __devinit cciss_procinit(int i)
364{
365 struct proc_dir_entry *pde;
366
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700367 if (proc_cciss == NULL) {
368 proc_cciss = proc_mkdir("cciss", proc_root_driver);
369 if (!proc_cciss)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 return;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700371 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700373 pde = create_proc_read_entry(hba[i]->devname,
374 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
375 proc_cciss, cciss_proc_get_info, hba[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 pde->write_proc = cciss_proc_write;
377}
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700378#endif /* CONFIG_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700380/*
381 * For operations that cannot sleep, a command block is allocated at init,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700383 * which ones are free or in use. For operations that can wait for kmalloc
384 * to possible sleep, this routine can be called with get_from_pool set to 0.
385 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
386 */
387static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
389 CommandList_struct *c;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700390 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 u64bit temp64;
392 dma_addr_t cmd_dma_handle, err_dma_handle;
393
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700394 if (!get_from_pool) {
395 c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
396 sizeof(CommandList_struct), &cmd_dma_handle);
397 if (c == NULL)
398 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 memset(c, 0, sizeof(CommandList_struct));
400
Mike Miller33079b22005-09-13 01:25:22 -0700401 c->cmdindex = -1;
402
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700403 c->err_info = (ErrorInfo_struct *)
404 pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
405 &err_dma_handle);
406
407 if (c->err_info == NULL) {
408 pci_free_consistent(h->pdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 sizeof(CommandList_struct), c, cmd_dma_handle);
410 return NULL;
411 }
412 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700413 } else { /* get it out of the controllers pool */
414
415 do {
Mike Millerf8806322006-12-06 20:35:01 -0800416 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
417 if (i == h->nr_cmds)
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700418 return NULL;
419 } while (test_and_set_bit
420 (i & (BITS_PER_LONG - 1),
421 h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422#ifdef CCISS_DEBUG
423 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
424#endif
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700425 c = h->cmd_pool + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 memset(c, 0, sizeof(CommandList_struct));
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700427 cmd_dma_handle = h->cmd_pool_dhandle
428 + i * sizeof(CommandList_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 c->err_info = h->errinfo_pool + i;
430 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700431 err_dma_handle = h->errinfo_pool_dhandle
432 + i * sizeof(ErrorInfo_struct);
433 h->nr_allocs++;
Mike Miller33079b22005-09-13 01:25:22 -0700434
435 c->cmdindex = i;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700436 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
438 c->busaddr = (__u32) cmd_dma_handle;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700439 temp64.val = (__u64) err_dma_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 c->ErrDesc.Addr.lower = temp64.val32.lower;
441 c->ErrDesc.Addr.upper = temp64.val32.upper;
442 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 c->ctlr = h->ctlr;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700445 return c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446}
447
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700448/*
449 * Frees a command block that was previously allocated with cmd_alloc().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 */
451static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
452{
453 int i;
454 u64bit temp64;
455
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700456 if (!got_from_pool) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 temp64.val32.lower = c->ErrDesc.Addr.lower;
458 temp64.val32.upper = c->ErrDesc.Addr.upper;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700459 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
460 c->err_info, (dma_addr_t) temp64.val);
461 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
462 c, (dma_addr_t) c->busaddr);
463 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 i = c - h->cmd_pool;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700465 clear_bit(i & (BITS_PER_LONG - 1),
466 h->cmd_pool_bits + (i / BITS_PER_LONG));
467 h->nr_frees++;
468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
471static inline ctlr_info_t *get_host(struct gendisk *disk)
472{
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700473 return disk->queue->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474}
475
476static inline drive_info_struct *get_drv(struct gendisk *disk)
477{
478 return disk->private_data;
479}
480
481/*
482 * Open. Make sure the device is really there.
483 */
484static int cciss_open(struct inode *inode, struct file *filep)
485{
486 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
487 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
488
489#ifdef CCISS_DEBUG
490 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700491#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Mike Millerddd47442005-09-13 01:25:22 -0700493 if (host->busy_initializing || drv->busy_configuring)
494 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 /*
496 * Root is allowed to open raw volume zero even if it's not configured
497 * so array config can still work. Root is also allowed to open any
498 * volume that has a LUN ID, so it can issue IOCTL to reread the
499 * disk information. I don't think I really like this
500 * but I'm already using way to many device nodes to claim another one
501 * for "raw controller".
502 */
Mike Miller7a06f782006-12-06 20:35:08 -0800503 if (drv->heads == 0) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700504 if (iminor(inode) != 0) { /* not node 0? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 /* if not node 0 make sure it is a partition = 0 */
506 if (iminor(inode) & 0x0f) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700507 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 /* if it is, make sure we have a LUN ID */
509 } else if (drv->LunID == 0) {
510 return -ENXIO;
511 }
512 }
513 if (!capable(CAP_SYS_ADMIN))
514 return -EPERM;
515 }
516 drv->usage_count++;
517 host->usage_count++;
518 return 0;
519}
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521/*
522 * Close. Sync first.
523 */
524static int cciss_release(struct inode *inode, struct file *filep)
525{
526 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
527 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
528
529#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700530 printk(KERN_DEBUG "cciss_release %s\n",
531 inode->i_bdev->bd_disk->disk_name);
532#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 drv->usage_count--;
535 host->usage_count--;
536 return 0;
537}
538
539#ifdef CONFIG_COMPAT
540
541static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
542{
543 int ret;
544 lock_kernel();
Josef Sipek6c648be2006-12-08 02:36:55 -0800545 ret = cciss_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 unlock_kernel();
547 return ret;
548}
549
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700550static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
551 unsigned long arg);
552static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
553 unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
556{
557 switch (cmd) {
558 case CCISS_GETPCIINFO:
559 case CCISS_GETINTINFO:
560 case CCISS_SETINTINFO:
561 case CCISS_GETNODENAME:
562 case CCISS_SETNODENAME:
563 case CCISS_GETHEARTBEAT:
564 case CCISS_GETBUSTYPES:
565 case CCISS_GETFIRMVER:
566 case CCISS_GETDRIVVER:
567 case CCISS_REVALIDVOLS:
568 case CCISS_DEREGDISK:
569 case CCISS_REGNEWDISK:
570 case CCISS_REGNEWD:
571 case CCISS_RESCANDISK:
572 case CCISS_GETLUNINFO:
573 return do_ioctl(f, cmd, arg);
574
575 case CCISS_PASSTHRU32:
576 return cciss_ioctl32_passthru(f, cmd, arg);
577 case CCISS_BIG_PASSTHRU32:
578 return cciss_ioctl32_big_passthru(f, cmd, arg);
579
580 default:
581 return -ENOIOCTLCMD;
582 }
583}
584
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700585static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
586 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 IOCTL32_Command_struct __user *arg32 =
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700589 (IOCTL32_Command_struct __user *) arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 IOCTL_Command_struct arg64;
591 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
592 int err;
593 u32 cp;
594
595 err = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700596 err |=
597 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
598 sizeof(arg64.LUN_info));
599 err |=
600 copy_from_user(&arg64.Request, &arg32->Request,
601 sizeof(arg64.Request));
602 err |=
603 copy_from_user(&arg64.error_info, &arg32->error_info,
604 sizeof(arg64.error_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 err |= get_user(arg64.buf_size, &arg32->buf_size);
606 err |= get_user(cp, &arg32->buf);
607 arg64.buf = compat_ptr(cp);
608 err |= copy_to_user(p, &arg64, sizeof(arg64));
609
610 if (err)
611 return -EFAULT;
612
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700613 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 if (err)
615 return err;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700616 err |=
617 copy_in_user(&arg32->error_info, &p->error_info,
618 sizeof(arg32->error_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 if (err)
620 return -EFAULT;
621 return err;
622}
623
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700624static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
625 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626{
627 BIG_IOCTL32_Command_struct __user *arg32 =
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700628 (BIG_IOCTL32_Command_struct __user *) arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 BIG_IOCTL_Command_struct arg64;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700630 BIG_IOCTL_Command_struct __user *p =
631 compat_alloc_user_space(sizeof(arg64));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 int err;
633 u32 cp;
634
635 err = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700636 err |=
637 copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
638 sizeof(arg64.LUN_info));
639 err |=
640 copy_from_user(&arg64.Request, &arg32->Request,
641 sizeof(arg64.Request));
642 err |=
643 copy_from_user(&arg64.error_info, &arg32->error_info,
644 sizeof(arg64.error_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 err |= get_user(arg64.buf_size, &arg32->buf_size);
646 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
647 err |= get_user(cp, &arg32->buf);
648 arg64.buf = compat_ptr(cp);
649 err |= copy_to_user(p, &arg64, sizeof(arg64));
650
651 if (err)
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700652 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700654 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (err)
656 return err;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700657 err |=
658 copy_in_user(&arg32->error_info, &p->error_info,
659 sizeof(arg32->error_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (err)
661 return -EFAULT;
662 return err;
663}
664#endif
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800665
666static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
667{
668 drive_info_struct *drv = get_drv(bdev->bd_disk);
669
670 if (!drv->cylinders)
671 return -ENXIO;
672
673 geo->heads = drv->heads;
674 geo->sectors = drv->sectors;
675 geo->cylinders = drv->cylinders;
676 return 0;
677}
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679/*
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700680 * ioctl
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 */
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700682static int cciss_ioctl(struct inode *inode, struct file *filep,
683 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684{
685 struct block_device *bdev = inode->i_bdev;
686 struct gendisk *disk = bdev->bd_disk;
687 ctlr_info_t *host = get_host(disk);
688 drive_info_struct *drv = get_drv(disk);
689 int ctlr = host->ctlr;
690 void __user *argp = (void __user *)arg;
691
692#ifdef CCISS_DEBUG
693 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700694#endif /* CCISS_DEBUG */
695
696 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 case CCISS_GETPCIINFO:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 {
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700699 cciss_pci_info_struct pciinfo;
700
701 if (!arg)
702 return -EINVAL;
703 pciinfo.domain = pci_domain_nr(host->pdev->bus);
704 pciinfo.bus = host->pdev->bus->number;
705 pciinfo.dev_fn = host->pdev->devfn;
706 pciinfo.board_id = host->board_id;
707 if (copy_to_user
708 (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
709 return -EFAULT;
710 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700712 case CCISS_GETINTINFO:
713 {
714 cciss_coalint_struct intinfo;
715 if (!arg)
716 return -EINVAL;
717 intinfo.delay =
718 readl(&host->cfgtable->HostWrite.CoalIntDelay);
719 intinfo.count =
720 readl(&host->cfgtable->HostWrite.CoalIntCount);
721 if (copy_to_user
722 (argp, &intinfo, sizeof(cciss_coalint_struct)))
723 return -EFAULT;
724 return 0;
725 }
726 case CCISS_SETINTINFO:
727 {
728 cciss_coalint_struct intinfo;
729 unsigned long flags;
730 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700732 if (!arg)
733 return -EINVAL;
734 if (!capable(CAP_SYS_ADMIN))
735 return -EPERM;
736 if (copy_from_user
737 (&intinfo, argp, sizeof(cciss_coalint_struct)))
738 return -EFAULT;
739 if ((intinfo.delay == 0) && (intinfo.count == 0))
740 {
741// printk("cciss_ioctl: delay and count cannot be 0\n");
742 return -EINVAL;
743 }
744 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
745 /* Update the field, and then ring the doorbell */
746 writel(intinfo.delay,
747 &(host->cfgtable->HostWrite.CoalIntDelay));
748 writel(intinfo.count,
749 &(host->cfgtable->HostWrite.CoalIntCount));
750 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
751
752 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
753 if (!(readl(host->vaddr + SA5_DOORBELL)
754 & CFGTBL_ChangeReq))
755 break;
756 /* delay and try again */
757 udelay(1000);
758 }
759 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
760 if (i >= MAX_IOCTL_CONFIG_WAIT)
761 return -EAGAIN;
762 return 0;
763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 case CCISS_GETNODENAME:
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700765 {
766 NodeName_type NodeName;
767 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700769 if (!arg)
770 return -EINVAL;
771 for (i = 0; i < 16; i++)
772 NodeName[i] =
773 readb(&host->cfgtable->ServerName[i]);
774 if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
775 return -EFAULT;
776 return 0;
777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 case CCISS_SETNODENAME:
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700779 {
780 NodeName_type NodeName;
781 unsigned long flags;
782 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700784 if (!arg)
785 return -EINVAL;
786 if (!capable(CAP_SYS_ADMIN))
787 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700789 if (copy_from_user
790 (NodeName, argp, sizeof(NodeName_type)))
791 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700793 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700795 /* Update the field, and then ring the doorbell */
796 for (i = 0; i < 16; i++)
797 writeb(NodeName[i],
798 &host->cfgtable->ServerName[i]);
799
800 writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
801
802 for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
803 if (!(readl(host->vaddr + SA5_DOORBELL)
804 & CFGTBL_ChangeReq))
805 break;
806 /* delay and try again */
807 udelay(1000);
808 }
809 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
810 if (i >= MAX_IOCTL_CONFIG_WAIT)
811 return -EAGAIN;
812 return 0;
813 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 case CCISS_GETHEARTBEAT:
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700816 {
817 Heartbeat_type heartbeat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700819 if (!arg)
820 return -EINVAL;
821 heartbeat = readl(&host->cfgtable->HeartBeat);
822 if (copy_to_user
823 (argp, &heartbeat, sizeof(Heartbeat_type)))
824 return -EFAULT;
825 return 0;
826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 case CCISS_GETBUSTYPES:
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700828 {
829 BusTypes_type BusTypes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700831 if (!arg)
832 return -EINVAL;
833 BusTypes = readl(&host->cfgtable->BusTypes);
834 if (copy_to_user
835 (argp, &BusTypes, sizeof(BusTypes_type)))
836 return -EFAULT;
837 return 0;
838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 case CCISS_GETFIRMVER:
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700840 {
841 FirmwareVer_type firmware;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700843 if (!arg)
844 return -EINVAL;
845 memcpy(firmware, host->firm_ver, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700847 if (copy_to_user
848 (argp, firmware, sizeof(FirmwareVer_type)))
849 return -EFAULT;
850 return 0;
851 }
852 case CCISS_GETDRIVVER:
853 {
854 DriverVer_type DriverVer = DRIVER_VERSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700856 if (!arg)
857 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700859 if (copy_to_user
860 (argp, &DriverVer, sizeof(DriverVer_type)))
861 return -EFAULT;
862 return 0;
863 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
865 case CCISS_REVALIDVOLS:
Mike Miller3833a742006-12-06 20:35:10 -0800866 return rebuild_lun_table(host, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700868 case CCISS_GETLUNINFO:{
869 LogvolInfo_struct luninfo;
870
871 luninfo.LunID = drv->LunID;
872 luninfo.num_opens = drv->usage_count;
873 luninfo.num_parts = 0;
874 if (copy_to_user(argp, &luninfo,
875 sizeof(LogvolInfo_struct)))
876 return -EFAULT;
877 return 0;
878 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 case CCISS_DEREGDISK:
Mike Millerddd47442005-09-13 01:25:22 -0700880 return rebuild_lun_table(host, disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 case CCISS_REGNEWD:
Mike Millerddd47442005-09-13 01:25:22 -0700883 return rebuild_lun_table(host, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
885 case CCISS_PASSTHRU:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 {
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700887 IOCTL_Command_struct iocommand;
888 CommandList_struct *c;
889 char *buff = NULL;
890 u64bit temp64;
891 unsigned long flags;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -0700892 DECLARE_COMPLETION_ONSTACK(wait);
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700893
894 if (!arg)
895 return -EINVAL;
896
897 if (!capable(CAP_SYS_RAWIO))
898 return -EPERM;
899
900 if (copy_from_user
901 (&iocommand, argp, sizeof(IOCTL_Command_struct)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 return -EFAULT;
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700903 if ((iocommand.buf_size < 1) &&
904 (iocommand.Request.Type.Direction != XFER_NONE)) {
905 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700907#if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
908 /* Check kmalloc limits */
909 if (iocommand.buf_size > 128000)
910 return -EINVAL;
911#endif
912 if (iocommand.buf_size > 0) {
913 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
914 if (buff == NULL)
915 return -EFAULT;
916 }
917 if (iocommand.Request.Type.Direction == XFER_WRITE) {
918 /* Copy the data into the buffer we created */
919 if (copy_from_user
920 (buff, iocommand.buf, iocommand.buf_size)) {
921 kfree(buff);
922 return -EFAULT;
923 }
924 } else {
925 memset(buff, 0, iocommand.buf_size);
926 }
927 if ((c = cmd_alloc(host, 0)) == NULL) {
928 kfree(buff);
929 return -ENOMEM;
930 }
931 // Fill in the command type
932 c->cmd_type = CMD_IOCTL_PEND;
933 // Fill in Command Header
934 c->Header.ReplyQueue = 0; // unused in simple mode
935 if (iocommand.buf_size > 0) // buffer to fill
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 {
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700937 c->Header.SGList = 1;
938 c->Header.SGTotal = 1;
939 } else // no buffers to fill
940 {
941 c->Header.SGList = 0;
942 c->Header.SGTotal = 0;
943 }
944 c->Header.LUN = iocommand.LUN_info;
945 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
946
947 // Fill in Request block
948 c->Request = iocommand.Request;
949
950 // Fill in the scatter gather information
951 if (iocommand.buf_size > 0) {
952 temp64.val = pci_map_single(host->pdev, buff,
953 iocommand.buf_size,
954 PCI_DMA_BIDIRECTIONAL);
955 c->SG[0].Addr.lower = temp64.val32.lower;
956 c->SG[0].Addr.upper = temp64.val32.upper;
957 c->SG[0].Len = iocommand.buf_size;
958 c->SG[0].Ext = 0; // we are not chaining
959 }
960 c->waiting = &wait;
961
962 /* Put the request on the tail of the request queue */
963 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
964 addQ(&host->reqQ, c);
965 host->Qdepth++;
966 start_io(host);
967 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
968
969 wait_for_completion(&wait);
970
971 /* unlock the buffers from DMA */
972 temp64.val32.lower = c->SG[0].Addr.lower;
973 temp64.val32.upper = c->SG[0].Addr.upper;
974 pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
975 iocommand.buf_size,
976 PCI_DMA_BIDIRECTIONAL);
977
978 /* Copy the error information out */
979 iocommand.error_info = *(c->err_info);
980 if (copy_to_user
981 (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
982 kfree(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 cmd_free(host, c, 0);
984 return -EFAULT;
985 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Bjorn Helgaas7c832832006-06-25 05:49:06 -0700987 if (iocommand.Request.Type.Direction == XFER_READ) {
988 /* Copy the data out of the buffer we created */
989 if (copy_to_user
990 (iocommand.buf, buff, iocommand.buf_size)) {
991 kfree(buff);
992 cmd_free(host, c, 0);
993 return -EFAULT;
994 }
995 }
996 kfree(buff);
997 cmd_free(host, c, 0);
998 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001000 case CCISS_BIG_PASSTHRU:{
1001 BIG_IOCTL_Command_struct *ioc;
1002 CommandList_struct *c;
1003 unsigned char **buff = NULL;
1004 int *buff_size = NULL;
1005 u64bit temp64;
1006 unsigned long flags;
1007 BYTE sg_used = 0;
1008 int status = 0;
1009 int i;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -07001010 DECLARE_COMPLETION_ONSTACK(wait);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001011 __u32 left;
1012 __u32 sz;
1013 BYTE __user *data_ptr;
1014
1015 if (!arg)
1016 return -EINVAL;
1017 if (!capable(CAP_SYS_RAWIO))
1018 return -EPERM;
1019 ioc = (BIG_IOCTL_Command_struct *)
1020 kmalloc(sizeof(*ioc), GFP_KERNEL);
1021 if (!ioc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 status = -ENOMEM;
1023 goto cleanup1;
1024 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001025 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
1026 status = -EFAULT;
1027 goto cleanup1;
1028 }
1029 if ((ioc->buf_size < 1) &&
1030 (ioc->Request.Type.Direction != XFER_NONE)) {
1031 status = -EINVAL;
1032 goto cleanup1;
1033 }
1034 /* Check kmalloc limits using all SGs */
1035 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
1036 status = -EINVAL;
1037 goto cleanup1;
1038 }
1039 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
1040 status = -EINVAL;
1041 goto cleanup1;
1042 }
1043 buff =
1044 kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
1045 if (!buff) {
1046 status = -ENOMEM;
1047 goto cleanup1;
1048 }
Robert P. J. Day5cbded52006-12-13 00:35:56 -08001049 buff_size = kmalloc(MAXSGENTRIES * sizeof(int),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001050 GFP_KERNEL);
1051 if (!buff_size) {
1052 status = -ENOMEM;
1053 goto cleanup1;
1054 }
1055 left = ioc->buf_size;
1056 data_ptr = ioc->buf;
1057 while (left) {
1058 sz = (left >
1059 ioc->malloc_size) ? ioc->
1060 malloc_size : left;
1061 buff_size[sg_used] = sz;
1062 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1063 if (buff[sg_used] == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 status = -ENOMEM;
Jens Axboe15534d32005-11-18 22:02:44 +01001065 goto cleanup1;
1066 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001067 if (ioc->Request.Type.Direction == XFER_WRITE) {
1068 if (copy_from_user
1069 (buff[sg_used], data_ptr, sz)) {
1070 status = -ENOMEM;
1071 goto cleanup1;
1072 }
1073 } else {
1074 memset(buff[sg_used], 0, sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001076 left -= sz;
1077 data_ptr += sz;
1078 sg_used++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001080 if ((c = cmd_alloc(host, 0)) == NULL) {
1081 status = -ENOMEM;
1082 goto cleanup1;
1083 }
1084 c->cmd_type = CMD_IOCTL_PEND;
1085 c->Header.ReplyQueue = 0;
1086
1087 if (ioc->buf_size > 0) {
1088 c->Header.SGList = sg_used;
1089 c->Header.SGTotal = sg_used;
1090 } else {
1091 c->Header.SGList = 0;
1092 c->Header.SGTotal = 0;
1093 }
1094 c->Header.LUN = ioc->LUN_info;
1095 c->Header.Tag.lower = c->busaddr;
1096
1097 c->Request = ioc->Request;
1098 if (ioc->buf_size > 0) {
1099 int i;
1100 for (i = 0; i < sg_used; i++) {
1101 temp64.val =
1102 pci_map_single(host->pdev, buff[i],
1103 buff_size[i],
1104 PCI_DMA_BIDIRECTIONAL);
1105 c->SG[i].Addr.lower =
1106 temp64.val32.lower;
1107 c->SG[i].Addr.upper =
1108 temp64.val32.upper;
1109 c->SG[i].Len = buff_size[i];
1110 c->SG[i].Ext = 0; /* we are not chaining */
1111 }
1112 }
1113 c->waiting = &wait;
1114 /* Put the request on the tail of the request queue */
1115 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1116 addQ(&host->reqQ, c);
1117 host->Qdepth++;
1118 start_io(host);
1119 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1120 wait_for_completion(&wait);
1121 /* unlock the buffers from DMA */
1122 for (i = 0; i < sg_used; i++) {
1123 temp64.val32.lower = c->SG[i].Addr.lower;
1124 temp64.val32.upper = c->SG[i].Addr.upper;
1125 pci_unmap_single(host->pdev,
1126 (dma_addr_t) temp64.val, buff_size[i],
1127 PCI_DMA_BIDIRECTIONAL);
1128 }
1129 /* Copy the error information out */
1130 ioc->error_info = *(c->err_info);
1131 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1132 cmd_free(host, c, 0);
1133 status = -EFAULT;
1134 goto cleanup1;
1135 }
1136 if (ioc->Request.Type.Direction == XFER_READ) {
1137 /* Copy the data out of the buffer we created */
1138 BYTE __user *ptr = ioc->buf;
1139 for (i = 0; i < sg_used; i++) {
1140 if (copy_to_user
1141 (ptr, buff[i], buff_size[i])) {
1142 cmd_free(host, c, 0);
1143 status = -EFAULT;
1144 goto cleanup1;
1145 }
1146 ptr += buff_size[i];
1147 }
1148 }
1149 cmd_free(host, c, 0);
1150 status = 0;
1151 cleanup1:
1152 if (buff) {
1153 for (i = 0; i < sg_used; i++)
1154 kfree(buff[i]);
1155 kfree(buff);
1156 }
1157 kfree(buff_size);
1158 kfree(ioc);
1159 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 }
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07001161
1162 /* scsi_cmd_ioctl handles these, below, though some are not */
1163 /* very meaningful for cciss. SG_IO is the main one people want. */
1164
1165 case SG_GET_VERSION_NUM:
1166 case SG_SET_TIMEOUT:
1167 case SG_GET_TIMEOUT:
1168 case SG_GET_RESERVED_SIZE:
1169 case SG_SET_RESERVED_SIZE:
1170 case SG_EMULATED_HOST:
1171 case SG_IO:
1172 case SCSI_IOCTL_SEND_COMMAND:
S.Çağlar Onur9793c322007-07-16 21:56:51 +03001173 return scsi_cmd_ioctl(filep, disk->queue, disk, cmd, argp);
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07001174
1175 /* scsi_cmd_ioctl would normally handle these, below, but */
1176 /* they aren't a good fit for cciss, as CD-ROMs are */
1177 /* not supported, and we don't have any bus/target/lun */
1178 /* which we present to the kernel. */
1179
1180 case CDROM_SEND_PACKET:
1181 case CDROMCLOSETRAY:
1182 case CDROMEJECT:
1183 case SCSI_IOCTL_GET_IDLUN:
1184 case SCSI_IOCTL_GET_BUS_NUMBER:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 default:
1186 return -ENOTTY;
1187 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
Mike Millerca1e0482006-04-10 15:38:07 -07001190static inline void complete_buffers(struct bio *bio, int status)
1191{
1192 while (bio) {
1193 struct bio *xbh = bio->bi_next;
1194 int nr_sectors = bio_sectors(bio);
1195
1196 bio->bi_next = NULL;
Mike Millerca1e0482006-04-10 15:38:07 -07001197 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
1198 bio = xbh;
1199 }
Mike Millerca1e0482006-04-10 15:38:07 -07001200}
1201
Jens Axboe7b30f092006-07-25 15:02:48 +02001202static void cciss_check_queues(ctlr_info_t *h)
1203{
1204 int start_queue = h->next_to_run;
1205 int i;
1206
1207 /* check to see if we have maxed out the number of commands that can
1208 * be placed on the queue. If so then exit. We do this check here
1209 * in case the interrupt we serviced was from an ioctl and did not
1210 * free any new commands.
1211 */
Mike Millerf8806322006-12-06 20:35:01 -08001212 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds)
Jens Axboe7b30f092006-07-25 15:02:48 +02001213 return;
1214
1215 /* We have room on the queue for more commands. Now we need to queue
1216 * them up. We will also keep track of the next queue to run so
1217 * that every queue gets a chance to be started first.
1218 */
1219 for (i = 0; i < h->highest_lun + 1; i++) {
1220 int curr_queue = (start_queue + i) % (h->highest_lun + 1);
1221 /* make sure the disk has been added and the drive is real
1222 * because this can be called from the middle of init_one.
1223 */
1224 if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
1225 continue;
1226 blk_start_queue(h->gendisk[curr_queue]->queue);
1227
1228 /* check to see if we have maxed out the number of commands
1229 * that can be placed on the queue.
1230 */
Mike Millerf8806322006-12-06 20:35:01 -08001231 if ((find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds)) == h->nr_cmds) {
Jens Axboe7b30f092006-07-25 15:02:48 +02001232 if (curr_queue == start_queue) {
1233 h->next_to_run =
1234 (start_queue + 1) % (h->highest_lun + 1);
1235 break;
1236 } else {
1237 h->next_to_run = curr_queue;
1238 break;
1239 }
1240 } else {
1241 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
1242 }
1243 }
1244}
1245
Mike Millerca1e0482006-04-10 15:38:07 -07001246static void cciss_softirq_done(struct request *rq)
1247{
1248 CommandList_struct *cmd = rq->completion_data;
1249 ctlr_info_t *h = hba[cmd->ctlr];
1250 unsigned long flags;
1251 u64bit temp64;
1252 int i, ddir;
1253
1254 if (cmd->Request.Type.Direction == XFER_READ)
1255 ddir = PCI_DMA_FROMDEVICE;
1256 else
1257 ddir = PCI_DMA_TODEVICE;
1258
1259 /* command did not need to be retried */
1260 /* unmap the DMA mapping for all the scatter gather elements */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001261 for (i = 0; i < cmd->Header.SGList; i++) {
Mike Millerca1e0482006-04-10 15:38:07 -07001262 temp64.val32.lower = cmd->SG[i].Addr.lower;
1263 temp64.val32.upper = cmd->SG[i].Addr.upper;
1264 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
1265 }
1266
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07001267 complete_buffers(rq->bio, (rq->errors == 0));
Mike Millerca1e0482006-04-10 15:38:07 -07001268
Jens Axboeb369c2c2006-11-14 12:36:03 +01001269 if (blk_fs_request(rq)) {
1270 const int rw = rq_data_dir(rq);
1271
1272 disk_stat_add(rq->rq_disk, sectors[rw], rq->nr_sectors);
1273 }
1274
Mike Millerca1e0482006-04-10 15:38:07 -07001275#ifdef CCISS_DEBUG
1276 printk("Done with %p\n", rq);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001277#endif /* CCISS_DEBUG */
Mike Millerca1e0482006-04-10 15:38:07 -07001278
Matt Mackall8bd0b972006-06-25 05:47:11 -07001279 add_disk_randomness(rq->rq_disk);
Mike Millerca1e0482006-04-10 15:38:07 -07001280 spin_lock_irqsave(&h->lock, flags);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07001281 end_that_request_last(rq, (rq->errors == 0));
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001282 cmd_free(h, cmd, 1);
Jens Axboe7b30f092006-07-25 15:02:48 +02001283 cciss_check_queues(h);
Mike Millerca1e0482006-04-10 15:38:07 -07001284 spin_unlock_irqrestore(&h->lock, flags);
1285}
1286
Mike Millerddd47442005-09-13 01:25:22 -07001287/* This function will check the usage_count of the drive to be updated/added.
1288 * If the usage_count is zero then the drive information will be updated and
1289 * the disk will be re-registered with the kernel. If not then it will be
1290 * left alone for the next reboot. The exception to this is disk 0 which
1291 * will always be left registered with the kernel since it is also the
1292 * controller node. Any changes to disk 0 will show up on the next
1293 * reboot.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001294 */
Mike Millerddd47442005-09-13 01:25:22 -07001295static void cciss_update_drive_info(int ctlr, int drv_index)
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001296{
Mike Millerddd47442005-09-13 01:25:22 -07001297 ctlr_info_t *h = hba[ctlr];
1298 struct gendisk *disk;
Mike Millerddd47442005-09-13 01:25:22 -07001299 InquiryData_struct *inq_buff = NULL;
1300 unsigned int block_size;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001301 sector_t total_size;
Mike Millerddd47442005-09-13 01:25:22 -07001302 unsigned long flags = 0;
1303 int ret = 0;
1304
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001305 /* if the disk already exists then deregister it before proceeding */
1306 if (h->drv[drv_index].raid_level != -1) {
Mike Millerddd47442005-09-13 01:25:22 -07001307 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1308 h->drv[drv_index].busy_configuring = 1;
1309 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1310 ret = deregister_disk(h->gendisk[drv_index],
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001311 &h->drv[drv_index], 0);
Mike Millerddd47442005-09-13 01:25:22 -07001312 h->drv[drv_index].busy_configuring = 0;
1313 }
1314
1315 /* If the disk is in use return */
1316 if (ret)
1317 return;
1318
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07001319 /* Get information about the disk and modify the driver structure */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001320 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
Mike Millerddd47442005-09-13 01:25:22 -07001321 if (inq_buff == NULL)
1322 goto mem_msg;
1323
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001324 /* testing to see if 16-byte CDBs are already being used */
1325 if (h->cciss_read == CCISS_READ_16) {
1326 cciss_read_capacity_16(h->ctlr, drv_index, 1,
1327 &total_size, &block_size);
1328 goto geo_inq;
1329 }
1330
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001331 cciss_read_capacity(ctlr, drv_index, 1,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001332 &total_size, &block_size);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001333
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001334 /* if read_capacity returns all F's this volume is >2TB in size */
1335 /* so we switch to 16-byte CDB's for all read/write ops */
1336 if (total_size == 0xFFFFFFFFULL) {
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001337 cciss_read_capacity_16(ctlr, drv_index, 1,
1338 &total_size, &block_size);
1339 h->cciss_read = CCISS_READ_16;
1340 h->cciss_write = CCISS_WRITE_16;
1341 } else {
1342 h->cciss_read = CCISS_READ_10;
1343 h->cciss_write = CCISS_WRITE_10;
1344 }
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001345geo_inq:
Mike Millerddd47442005-09-13 01:25:22 -07001346 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001347 inq_buff, &h->drv[drv_index]);
Mike Millerddd47442005-09-13 01:25:22 -07001348
1349 ++h->num_luns;
1350 disk = h->gendisk[drv_index];
1351 set_capacity(disk, h->drv[drv_index].nr_blocks);
1352
Mike Millerddd47442005-09-13 01:25:22 -07001353 /* if it's the controller it's already added */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001354 if (drv_index) {
Mike Millerddd47442005-09-13 01:25:22 -07001355 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
Mike Miller799202c2006-12-06 20:35:12 -08001356 sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
1357 disk->major = h->major;
1358 disk->first_minor = drv_index << NWD_SHIFT;
1359 disk->fops = &cciss_fops;
1360 disk->private_data = &h->drv[drv_index];
Mike Millerddd47442005-09-13 01:25:22 -07001361
1362 /* Set up queue information */
1363 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1364 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1365
1366 /* This is a hardware imposed limit. */
1367 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1368
1369 /* This is a limit in the driver and could be eliminated. */
1370 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1371
Mike Miller92c4231a2006-12-06 20:35:06 -08001372 blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
Mike Millerddd47442005-09-13 01:25:22 -07001373
Mike Millerca1e0482006-04-10 15:38:07 -07001374 blk_queue_softirq_done(disk->queue, cciss_softirq_done);
1375
Mike Millerddd47442005-09-13 01:25:22 -07001376 disk->queue->queuedata = hba[ctlr];
1377
1378 blk_queue_hardsect_size(disk->queue,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001379 hba[ctlr]->drv[drv_index].block_size);
Mike Millerddd47442005-09-13 01:25:22 -07001380
1381 h->drv[drv_index].queue = disk->queue;
1382 add_disk(disk);
1383 }
1384
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001385 freeret:
Mike Millerddd47442005-09-13 01:25:22 -07001386 kfree(inq_buff);
1387 return;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001388 mem_msg:
Mike Millerddd47442005-09-13 01:25:22 -07001389 printk(KERN_ERR "cciss: out of memory\n");
1390 goto freeret;
1391}
1392
1393/* This function will find the first index of the controllers drive array
1394 * that has a -1 for the raid_level and will return that index. This is
1395 * where new drives will be added. If the index to be returned is greater
1396 * than the highest_lun index for the controller then highest_lun is set
1397 * to this new index. If there are no available indexes then -1 is returned.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001398 */
Mike Millerddd47442005-09-13 01:25:22 -07001399static int cciss_find_free_drive_index(int ctlr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400{
Mike Millerddd47442005-09-13 01:25:22 -07001401 int i;
1402
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001403 for (i = 0; i < CISS_MAX_LUN; i++) {
1404 if (hba[ctlr]->drv[i].raid_level == -1) {
Mike Millerddd47442005-09-13 01:25:22 -07001405 if (i > hba[ctlr]->highest_lun)
1406 hba[ctlr]->highest_lun = i;
1407 return i;
1408 }
1409 }
1410 return -1;
1411}
1412
1413/* This function will add and remove logical drives from the Logical
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07001414 * drive array of the controller and maintain persistency of ordering
Mike Millerddd47442005-09-13 01:25:22 -07001415 * so that mount points are preserved until the next reboot. This allows
1416 * for the removal of logical drives in the middle of the drive array
1417 * without a re-ordering of those drives.
1418 * INPUT
1419 * h = The controller to perform the operations on
1420 * del_disk = The disk to remove if specified. If the value given
1421 * is NULL then no disk is removed.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001422 */
Mike Millerddd47442005-09-13 01:25:22 -07001423static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1424{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 int ctlr = h->ctlr;
Mike Millerddd47442005-09-13 01:25:22 -07001426 int num_luns;
1427 ReportLunData_struct *ld_buff = NULL;
1428 drive_info_struct *drv = NULL;
1429 int return_code;
1430 int listlength = 0;
1431 int i;
1432 int drv_found;
1433 int drv_index = 0;
1434 __u32 lunid = 0;
1435 unsigned long flags;
1436
1437 /* Set busy_configuring flag for this operation */
1438 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001439 if (h->busy_configuring) {
Mike Millerddd47442005-09-13 01:25:22 -07001440 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1441 return -EBUSY;
1442 }
1443 h->busy_configuring = 1;
1444
1445 /* if del_disk is NULL then we are being called to add a new disk
1446 * and update the logical drive table. If it is not NULL then
1447 * we will check if the disk is in use or not.
1448 */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001449 if (del_disk != NULL) {
Mike Millerddd47442005-09-13 01:25:22 -07001450 drv = get_drv(del_disk);
1451 drv->busy_configuring = 1;
1452 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1453 return_code = deregister_disk(del_disk, drv, 1);
1454 drv->busy_configuring = 0;
1455 h->busy_configuring = 0;
1456 return return_code;
1457 } else {
1458 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1459 if (!capable(CAP_SYS_RAWIO))
1460 return -EPERM;
1461
1462 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1463 if (ld_buff == NULL)
1464 goto mem_msg;
1465
1466 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001467 sizeof(ReportLunData_struct), 0,
1468 0, 0, TYPE_CMD);
Mike Millerddd47442005-09-13 01:25:22 -07001469
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001470 if (return_code == IO_OK) {
Mike Miller799202c2006-12-06 20:35:12 -08001471 listlength =
Al Viro4c1f2b32007-03-14 09:19:10 +00001472 be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001473 } else { /* reading number of logical volumes failed */
Mike Millerddd47442005-09-13 01:25:22 -07001474 printk(KERN_WARNING "cciss: report logical volume"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001475 " command failed\n");
Mike Millerddd47442005-09-13 01:25:22 -07001476 listlength = 0;
1477 goto freeret;
1478 }
1479
1480 num_luns = listlength / 8; /* 8 bytes per entry */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001481 if (num_luns > CISS_MAX_LUN) {
Mike Millerddd47442005-09-13 01:25:22 -07001482 num_luns = CISS_MAX_LUN;
1483 printk(KERN_WARNING "cciss: more luns configured"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001484 " on controller than can be handled by"
1485 " this driver.\n");
Mike Millerddd47442005-09-13 01:25:22 -07001486 }
1487
1488 /* Compare controller drive array to drivers drive array.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001489 * Check for updates in the drive information and any new drives
1490 * on the controller.
1491 */
1492 for (i = 0; i < num_luns; i++) {
Mike Millerddd47442005-09-13 01:25:22 -07001493 int j;
1494
1495 drv_found = 0;
1496
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001497 lunid = (0xff &
1498 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1499 lunid |= (0xff &
1500 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1501 lunid |= (0xff &
1502 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1503 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
Mike Millerddd47442005-09-13 01:25:22 -07001504
1505 /* Find if the LUN is already in the drive array
1506 * of the controller. If so then update its info
1507 * if not is use. If it does not exist then find
1508 * the first free index and add it.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001509 */
1510 for (j = 0; j <= h->highest_lun; j++) {
1511 if (h->drv[j].LunID == lunid) {
Mike Millerddd47442005-09-13 01:25:22 -07001512 drv_index = j;
1513 drv_found = 1;
1514 }
1515 }
1516
1517 /* check if the drive was found already in the array */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001518 if (!drv_found) {
Mike Millerddd47442005-09-13 01:25:22 -07001519 drv_index = cciss_find_free_drive_index(ctlr);
1520 if (drv_index == -1)
1521 goto freeret;
1522
Mike Miller799202c2006-12-06 20:35:12 -08001523 /*Check if the gendisk needs to be allocated */
1524 if (!h->gendisk[drv_index]){
1525 h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
1526 if (!h->gendisk[drv_index]){
1527 printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
1528 goto mem_msg;
1529 }
1530 }
Mike Millerddd47442005-09-13 01:25:22 -07001531 }
1532 h->drv[drv_index].LunID = lunid;
1533 cciss_update_drive_info(ctlr, drv_index);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001534 } /* end for */
1535 } /* end else */
Mike Millerddd47442005-09-13 01:25:22 -07001536
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001537 freeret:
Mike Millerddd47442005-09-13 01:25:22 -07001538 kfree(ld_buff);
1539 h->busy_configuring = 0;
1540 /* We return -1 here to tell the ACU that we have registered/updated
1541 * all of the drives that we can and to keep it from calling us
1542 * additional times.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001543 */
Mike Millerddd47442005-09-13 01:25:22 -07001544 return -1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001545 mem_msg:
Mike Millerddd47442005-09-13 01:25:22 -07001546 printk(KERN_ERR "cciss: out of memory\n");
1547 goto freeret;
1548}
1549
1550/* This function will deregister the disk and it's queue from the
1551 * kernel. It must be called with the controller lock held and the
1552 * drv structures busy_configuring flag set. It's parameters are:
1553 *
1554 * disk = This is the disk to be deregistered
1555 * drv = This is the drive_info_struct associated with the disk to be
1556 * deregistered. It contains information about the disk used
1557 * by the driver.
1558 * clear_all = This flag determines whether or not the disk information
1559 * is going to be completely cleared out and the highest_lun
1560 * reset. Sometimes we want to clear out information about
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07001561 * the disk in preparation for re-adding it. In this case
Mike Millerddd47442005-09-13 01:25:22 -07001562 * the highest_lun should be left unchanged and the LunID
1563 * should not be cleared.
1564*/
1565static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1566 int clear_all)
1567{
Mike Miller799202c2006-12-06 20:35:12 -08001568 int i;
Mike Millerddd47442005-09-13 01:25:22 -07001569 ctlr_info_t *h = get_host(disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
1571 if (!capable(CAP_SYS_RAWIO))
1572 return -EPERM;
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 /* make sure logical volume is NOT is use */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001575 if (clear_all || (h->gendisk[0] == disk)) {
1576 if (drv->usage_count > 1)
1577 return -EBUSY;
1578 } else if (drv->usage_count > 0)
1579 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
Mike Millerddd47442005-09-13 01:25:22 -07001581 /* invalidate the devices and deregister the disk. If it is disk
1582 * zero do not deregister it but just zero out it's values. This
1583 * allows us to delete disk zero but keep the controller registered.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001584 */
1585 if (h->gendisk[0] != disk) {
mikem6f5a0f72005-11-18 22:05:36 +01001586 if (disk) {
Jens Axboe165125e2007-07-24 09:28:11 +02001587 struct request_queue *q = disk->queue;
mikem6f5a0f72005-11-18 22:05:36 +01001588 if (disk->flags & GENHD_FL_UP)
1589 del_gendisk(disk);
Mike Miller2f6331f2005-12-12 22:17:14 -08001590 if (q) {
mikem6f5a0f72005-11-18 22:05:36 +01001591 blk_cleanup_queue(q);
Mike Miller799202c2006-12-06 20:35:12 -08001592 /* Set drv->queue to NULL so that we do not try
1593 * to call blk_start_queue on this queue in the
1594 * interrupt handler
1595 */
Mike Miller2f6331f2005-12-12 22:17:14 -08001596 drv->queue = NULL;
1597 }
Mike Miller799202c2006-12-06 20:35:12 -08001598 /* If clear_all is set then we are deleting the logical
1599 * drive, not just refreshing its info. For drives
1600 * other than disk 0 we will call put_disk. We do not
1601 * do this for disk 0 as we need it to be able to
1602 * configure the controller.
1603 */
1604 if (clear_all){
1605 /* This isn't pretty, but we need to find the
1606 * disk in our array and NULL our the pointer.
1607 * This is so that we will call alloc_disk if
1608 * this index is used again later.
1609 */
1610 for (i=0; i < CISS_MAX_LUN; i++){
1611 if(h->gendisk[i] == disk){
1612 h->gendisk[i] = NULL;
1613 break;
1614 }
1615 }
1616 put_disk(disk);
1617 }
Mike Millerddd47442005-09-13 01:25:22 -07001618 }
Mike Miller799202c2006-12-06 20:35:12 -08001619 } else {
1620 set_capacity(disk, 0);
Mike Millerddd47442005-09-13 01:25:22 -07001621 }
1622
1623 --h->num_luns;
1624 /* zero out the disk size info */
1625 drv->nr_blocks = 0;
1626 drv->block_size = 0;
1627 drv->heads = 0;
1628 drv->sectors = 0;
1629 drv->cylinders = 0;
1630 drv->raid_level = -1; /* This can be used as a flag variable to
1631 * indicate that this element of the drive
1632 * array is free.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001633 */
Mike Millerddd47442005-09-13 01:25:22 -07001634
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001635 if (clear_all) {
1636 /* check to see if it was the last disk */
1637 if (drv == h->drv + h->highest_lun) {
1638 /* if so, find the new hightest lun */
1639 int i, newhighest = -1;
1640 for (i = 0; i < h->highest_lun; i++) {
1641 /* if the disk has size > 0, it is available */
Mike Millerddd47442005-09-13 01:25:22 -07001642 if (h->drv[i].heads)
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001643 newhighest = i;
1644 }
1645 h->highest_lun = newhighest;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
Mike Millerddd47442005-09-13 01:25:22 -07001647
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001648 drv->LunID = 0;
Mike Millerddd47442005-09-13 01:25:22 -07001649 }
Bjorn Helgaase2019b52006-06-25 05:49:05 -07001650 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651}
Mike Millerddd47442005-09-13 01:25:22 -07001652
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001653static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
1654 1: address logical volume log_unit,
1655 2: periph device address is scsi3addr */
1656 unsigned int log_unit, __u8 page_code,
1657 unsigned char *scsi3addr, int cmd_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658{
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001659 ctlr_info_t *h = hba[ctlr];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 u64bit buff_dma_handle;
1661 int status = IO_OK;
1662
1663 c->cmd_type = CMD_IOCTL_PEND;
1664 c->Header.ReplyQueue = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001665 if (buff != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 c->Header.SGList = 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001667 c->Header.SGTotal = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 } else {
1669 c->Header.SGList = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001670 c->Header.SGTotal = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 }
1672 c->Header.Tag.lower = c->busaddr;
1673
1674 c->Request.Type.Type = cmd_type;
1675 if (cmd_type == TYPE_CMD) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001676 switch (cmd) {
1677 case CISS_INQUIRY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 /* If the logical unit number is 0 then, this is going
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001679 to controller so It's a physical command
1680 mode = 0 target = 0. So we have nothing to write.
1681 otherwise, if use_unit_num == 1,
1682 mode = 1(volume set addressing) target = LUNID
1683 otherwise, if use_unit_num == 2,
1684 mode = 0(periph dev addr) target = scsi3addr */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 if (use_unit_num == 1) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001686 c->Header.LUN.LogDev.VolId =
1687 h->drv[log_unit].LunID;
1688 c->Header.LUN.LogDev.Mode = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 } else if (use_unit_num == 2) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001690 memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
1691 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 c->Header.LUN.LogDev.Mode = 0;
1693 }
1694 /* are we trying to read a vital product page */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001695 if (page_code != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 c->Request.CDB[1] = 0x01;
1697 c->Request.CDB[2] = page_code;
1698 }
1699 c->Request.CDBLen = 6;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001700 c->Request.Type.Attribute = ATTR_SIMPLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 c->Request.Type.Direction = XFER_READ;
1702 c->Request.Timeout = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001703 c->Request.CDB[0] = CISS_INQUIRY;
1704 c->Request.CDB[4] = size & 0xFF;
1705 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 case CISS_REPORT_LOG:
1707 case CISS_REPORT_PHYS:
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001708 /* Talking to controller so It's a physical command
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 mode = 00 target = 0. Nothing to write.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001710 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 c->Request.CDBLen = 12;
1712 c->Request.Type.Attribute = ATTR_SIMPLE;
1713 c->Request.Type.Direction = XFER_READ;
1714 c->Request.Timeout = 0;
1715 c->Request.CDB[0] = cmd;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001716 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 c->Request.CDB[7] = (size >> 16) & 0xFF;
1718 c->Request.CDB[8] = (size >> 8) & 0xFF;
1719 c->Request.CDB[9] = size & 0xFF;
1720 break;
1721
1722 case CCISS_READ_CAPACITY:
1723 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1724 c->Header.LUN.LogDev.Mode = 1;
1725 c->Request.CDBLen = 10;
1726 c->Request.Type.Attribute = ATTR_SIMPLE;
1727 c->Request.Type.Direction = XFER_READ;
1728 c->Request.Timeout = 0;
1729 c->Request.CDB[0] = cmd;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001730 break;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001731 case CCISS_READ_CAPACITY_16:
1732 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1733 c->Header.LUN.LogDev.Mode = 1;
1734 c->Request.CDBLen = 16;
1735 c->Request.Type.Attribute = ATTR_SIMPLE;
1736 c->Request.Type.Direction = XFER_READ;
1737 c->Request.Timeout = 0;
1738 c->Request.CDB[0] = cmd;
1739 c->Request.CDB[1] = 0x10;
1740 c->Request.CDB[10] = (size >> 24) & 0xFF;
1741 c->Request.CDB[11] = (size >> 16) & 0xFF;
1742 c->Request.CDB[12] = (size >> 8) & 0xFF;
1743 c->Request.CDB[13] = size & 0xFF;
1744 c->Request.Timeout = 0;
1745 c->Request.CDB[0] = cmd;
1746 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 case CCISS_CACHE_FLUSH:
1748 c->Request.CDBLen = 12;
1749 c->Request.Type.Attribute = ATTR_SIMPLE;
1750 c->Request.Type.Direction = XFER_WRITE;
1751 c->Request.Timeout = 0;
1752 c->Request.CDB[0] = BMIC_WRITE;
1753 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001754 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 default:
1756 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001757 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
Bjorn Helgaase2019b52006-06-25 05:49:05 -07001758 return IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
1760 } else if (cmd_type == TYPE_MSG) {
1761 switch (cmd) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001762 case 0: /* ABORT message */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001763 c->Request.CDBLen = 12;
1764 c->Request.Type.Attribute = ATTR_SIMPLE;
1765 c->Request.Type.Direction = XFER_WRITE;
1766 c->Request.Timeout = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001767 c->Request.CDB[0] = cmd; /* abort */
1768 c->Request.CDB[1] = 0; /* abort a command */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001769 /* buff contains the tag of the command to abort */
1770 memcpy(&c->Request.CDB[4], buff, 8);
1771 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001772 case 1: /* RESET message */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001773 c->Request.CDBLen = 12;
1774 c->Request.Type.Attribute = ATTR_SIMPLE;
1775 c->Request.Type.Direction = XFER_WRITE;
1776 c->Request.Timeout = 0;
1777 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001778 c->Request.CDB[0] = cmd; /* reset */
1779 c->Request.CDB[1] = 0x04; /* reset a LUN */
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001780 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 case 3: /* No-Op message */
1782 c->Request.CDBLen = 1;
1783 c->Request.Type.Attribute = ATTR_SIMPLE;
1784 c->Request.Type.Direction = XFER_WRITE;
1785 c->Request.Timeout = 0;
1786 c->Request.CDB[0] = cmd;
1787 break;
1788 default:
1789 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001790 "cciss%d: unknown message type %d\n", ctlr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 return IO_ERROR;
1792 }
1793 } else {
1794 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001795 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 return IO_ERROR;
1797 }
1798 /* Fill in the scatter gather information */
1799 if (size > 0) {
1800 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001801 buff, size,
1802 PCI_DMA_BIDIRECTIONAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1804 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1805 c->SG[0].Len = size;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001806 c->SG[0].Ext = 0; /* we are not chaining */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 }
1808 return status;
1809}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001810
1811static int sendcmd_withirq(__u8 cmd,
1812 int ctlr,
1813 void *buff,
1814 size_t size,
1815 unsigned int use_unit_num,
1816 unsigned int log_unit, __u8 page_code, int cmd_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817{
1818 ctlr_info_t *h = hba[ctlr];
1819 CommandList_struct *c;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001820 u64bit buff_dma_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 unsigned long flags;
1822 int return_status;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -07001823 DECLARE_COMPLETION_ONSTACK(wait);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001824
1825 if ((c = cmd_alloc(h, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 return -ENOMEM;
1827 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001828 log_unit, page_code, NULL, cmd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 if (return_status != IO_OK) {
1830 cmd_free(h, c, 0);
1831 return return_status;
1832 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001833 resend_cmd2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 c->waiting = &wait;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001835
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 /* Put the request on the tail of the queue and send it */
1837 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1838 addQ(&h->reqQ, c);
1839 h->Qdepth++;
1840 start_io(h);
1841 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001842
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 wait_for_completion(&wait);
1844
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001845 if (c->err_info->CommandStatus != 0) { /* an error has occurred */
1846 switch (c->err_info->CommandStatus) {
1847 case CMD_TARGET_STATUS:
1848 printk(KERN_WARNING "cciss: cmd %p has "
1849 " completed with errors\n", c);
1850 if (c->err_info->ScsiStatus) {
1851 printk(KERN_WARNING "cciss: cmd %p "
1852 "has SCSI Status = %x\n",
1853 c, c->err_info->ScsiStatus);
1854 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001857 case CMD_DATA_UNDERRUN:
1858 case CMD_DATA_OVERRUN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 /* expected for inquire and report lun commands */
1860 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001861 case CMD_INVALID:
1862 printk(KERN_WARNING "cciss: Cmd %p is "
1863 "reported invalid\n", c);
1864 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001866 case CMD_PROTOCOL_ERR:
1867 printk(KERN_WARNING "cciss: cmd %p has "
1868 "protocol error \n", c);
1869 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001871 case CMD_HARDWARE_ERR:
1872 printk(KERN_WARNING "cciss: cmd %p had "
1873 " hardware error\n", c);
1874 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001876 case CMD_CONNECTION_LOST:
1877 printk(KERN_WARNING "cciss: cmd %p had "
1878 "connection lost\n", c);
1879 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001881 case CMD_ABORTED:
1882 printk(KERN_WARNING "cciss: cmd %p was "
1883 "aborted\n", c);
1884 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 break;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001886 case CMD_ABORT_FAILED:
1887 printk(KERN_WARNING "cciss: cmd %p reports "
1888 "abort failed\n", c);
1889 return_status = IO_ERROR;
1890 break;
1891 case CMD_UNSOLICITED_ABORT:
1892 printk(KERN_WARNING
1893 "cciss%d: unsolicited abort %p\n", ctlr, c);
1894 if (c->retry_count < MAX_CMD_RETRIES) {
1895 printk(KERN_WARNING
1896 "cciss%d: retrying %p\n", ctlr, c);
1897 c->retry_count++;
1898 /* erase the old error information */
1899 memset(c->err_info, 0,
1900 sizeof(ErrorInfo_struct));
1901 return_status = IO_OK;
1902 INIT_COMPLETION(wait);
1903 goto resend_cmd2;
1904 }
1905 return_status = IO_ERROR;
1906 break;
1907 default:
1908 printk(KERN_WARNING "cciss: cmd %p returned "
1909 "unknown status %x\n", c,
1910 c->err_info->CommandStatus);
1911 return_status = IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001913 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 /* unlock the buffers from DMA */
Mike Millerbb2a37b2005-09-13 01:25:24 -07001915 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1916 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001917 pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
1918 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 cmd_free(h, c, 0);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001920 return return_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923static void cciss_geometry_inquiry(int ctlr, int logvol,
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001924 int withirq, sector_t total_size,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001925 unsigned int block_size,
1926 InquiryData_struct *inq_buff,
1927 drive_info_struct *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928{
1929 int return_code;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001930 unsigned long t;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001931
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 memset(inq_buff, 0, sizeof(InquiryData_struct));
1933 if (withirq)
1934 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001935 inq_buff, sizeof(*inq_buff), 1,
1936 logvol, 0xC1, TYPE_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 else
1938 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001939 sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
1940 TYPE_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 if (return_code == IO_OK) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001942 if (inq_buff->data_byte[8] == 0xFF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001944 "cciss: reading geometry failed, volume "
1945 "does not support reading geometry\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 drv->heads = 255;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001947 drv->sectors = 32; // Sectors per track
Mike Miller (OS Dev)7f42d3b2007-04-04 19:08:23 -07001948 drv->cylinders = total_size + 1;
Mike Miller89f97ad2006-12-18 10:59:39 +01001949 drv->raid_level = RAID_UNKNOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 drv->heads = inq_buff->data_byte[6];
1952 drv->sectors = inq_buff->data_byte[7];
1953 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1954 drv->cylinders += inq_buff->data_byte[5];
1955 drv->raid_level = inq_buff->data_byte[8];
Matthew Wilcox3f7705e2006-10-21 10:24:19 -07001956 }
1957 drv->block_size = block_size;
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001958 drv->nr_blocks = total_size + 1;
Matthew Wilcox3f7705e2006-10-21 10:24:19 -07001959 t = drv->heads * drv->sectors;
1960 if (t > 1) {
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001961 sector_t real_size = total_size + 1;
1962 unsigned long rem = sector_div(real_size, t);
Matthew Wilcox3f7705e2006-10-21 10:24:19 -07001963 if (rem)
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08001964 real_size++;
1965 drv->cylinders = real_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001967 } else { /* Get geometry failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 printk(KERN_WARNING "cciss: reading geometry failed\n");
1969 }
Metathronius Galabantcc088d12006-09-30 23:27:47 -07001970 printk(KERN_INFO " heads=%d, sectors=%d, cylinders=%d\n\n",
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001971 drv->heads, drv->sectors, drv->cylinders);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001973
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974static void
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001975cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001976 unsigned int *block_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977{
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001978 ReadCapdata_struct *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 int return_code;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001980 buf = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
1981 if (buf == NULL) {
1982 printk(KERN_WARNING "cciss: out of memory\n");
1983 return;
1984 }
1985 memset(buf, 0, sizeof(ReadCapdata_struct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 if (withirq)
1987 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001988 ctlr, buf, sizeof(ReadCapdata_struct),
1989 1, logvol, 0, TYPE_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 else
1991 return_code = sendcmd(CCISS_READ_CAPACITY,
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07001992 ctlr, buf, sizeof(ReadCapdata_struct),
1993 1, logvol, 0, NULL, TYPE_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 if (return_code == IO_OK) {
Al Viro4c1f2b32007-03-14 09:19:10 +00001995 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
1996 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07001997 } else { /* read capacity command failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 printk(KERN_WARNING "cciss: read capacity failed\n");
1999 *total_size = 0;
2000 *block_size = BLOCK_SIZE;
2001 }
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08002002 if (*total_size != 0)
Randy Dunlap7b92aad2006-10-28 10:38:40 -07002003 printk(KERN_INFO " blocks= %llu block_size= %d\n",
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08002004 (unsigned long long)*total_size+1, *block_size);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002005 kfree(buf);
2006 return;
2007}
2008
2009static void
2010cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size, unsigned int *block_size)
2011{
2012 ReadCapdata_struct_16 *buf;
2013 int return_code;
2014 buf = kmalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
2015 if (buf == NULL) {
2016 printk(KERN_WARNING "cciss: out of memory\n");
2017 return;
2018 }
2019 memset(buf, 0, sizeof(ReadCapdata_struct_16));
2020 if (withirq) {
2021 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
2022 ctlr, buf, sizeof(ReadCapdata_struct_16),
2023 1, logvol, 0, TYPE_CMD);
2024 }
2025 else {
2026 return_code = sendcmd(CCISS_READ_CAPACITY_16,
2027 ctlr, buf, sizeof(ReadCapdata_struct_16),
2028 1, logvol, 0, NULL, TYPE_CMD);
2029 }
2030 if (return_code == IO_OK) {
Al Viro4c1f2b32007-03-14 09:19:10 +00002031 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
2032 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002033 } else { /* read capacity command failed */
2034 printk(KERN_WARNING "cciss: read capacity failed\n");
2035 *total_size = 0;
2036 *block_size = BLOCK_SIZE;
2037 }
Randy Dunlap7b92aad2006-10-28 10:38:40 -07002038 printk(KERN_INFO " blocks= %llu block_size= %d\n",
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08002039 (unsigned long long)*total_size+1, *block_size);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002040 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 return;
2042}
2043
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044static int cciss_revalidate(struct gendisk *disk)
2045{
2046 ctlr_info_t *h = get_host(disk);
2047 drive_info_struct *drv = get_drv(disk);
2048 int logvol;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002049 int FOUND = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 unsigned int block_size;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002051 sector_t total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 InquiryData_struct *inq_buff = NULL;
2053
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002054 for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
2055 if (h->drv[logvol].LunID == drv->LunID) {
2056 FOUND = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 break;
2058 }
2059 }
2060
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002061 if (!FOUND)
2062 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002064 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
2065 if (inq_buff == NULL) {
2066 printk(KERN_WARNING "cciss: out of memory\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002067 return 1;
2068 }
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002069 if (h->cciss_read == CCISS_READ_10) {
2070 cciss_read_capacity(h->ctlr, logvol, 1,
2071 &total_size, &block_size);
2072 } else {
2073 cciss_read_capacity_16(h->ctlr, logvol, 1,
2074 &total_size, &block_size);
2075 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002076 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
2077 inq_buff, drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078
Mike Millerad2b9312005-07-28 01:07:31 -07002079 blk_queue_hardsect_size(drv->queue, drv->block_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 set_capacity(disk, drv->nr_blocks);
2081
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 kfree(inq_buff);
2083 return 0;
2084}
2085
2086/*
2087 * Wait polling for a command to complete.
2088 * The memory mapped FIFO is polled for the completion.
2089 * Used only at init time, interrupts from the HBA are disabled.
2090 */
2091static unsigned long pollcomplete(int ctlr)
2092{
2093 unsigned long done;
2094 int i;
2095
2096 /* Wait (up to 20 seconds) for a command to complete */
2097
2098 for (i = 20 * HZ; i > 0; i--) {
2099 done = hba[ctlr]->access.command_completed(hba[ctlr]);
Nishanth Aravamudan86e84862005-09-10 00:27:28 -07002100 if (done == FIFO_EMPTY)
2101 schedule_timeout_uninterruptible(1);
2102 else
Bjorn Helgaase2019b52006-06-25 05:49:05 -07002103 return done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 }
2105 /* Invalid address to tell caller we ran out of time */
2106 return 1;
2107}
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002108
2109static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
2110{
2111 /* We get in here if sendcmd() is polling for completions
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002112 and gets some command back that it wasn't expecting --
2113 something other than that which it just sent down.
2114 Ordinarily, that shouldn't happen, but it can happen when
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002115 the scsi tape stuff gets into error handling mode, and
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002116 starts using sendcmd() to try to abort commands and
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002117 reset tape drives. In that case, sendcmd may pick up
2118 completions of commands that were sent to logical drives
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002119 through the block i/o system, or cciss ioctls completing, etc.
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002120 In that case, we need to save those completions for later
2121 processing by the interrupt handler.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002122 */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002123
2124#ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002125 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002126
2127 /* If it's not the scsi tape stuff doing error handling, (abort */
2128 /* or reset) then we don't expect anything weird. */
2129 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
2130#endif
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002131 printk(KERN_WARNING "cciss cciss%d: SendCmd "
2132 "Invalid command list address returned! (%lx)\n",
2133 ctlr, complete);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002134 /* not much we can do. */
2135#ifdef CONFIG_CISS_SCSI_TAPE
2136 return 1;
2137 }
2138
2139 /* We've sent down an abort or reset, but something else
2140 has completed */
Mike Millerf8806322006-12-06 20:35:01 -08002141 if (srl->ncompletions >= (hba[ctlr]->nr_cmds + 2)) {
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002142 /* Uh oh. No room to save it for later... */
2143 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002144 "reject list overflow, command lost!\n", ctlr);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002145 return 1;
2146 }
2147 /* Save it for later */
2148 srl->complete[srl->ncompletions] = complete;
2149 srl->ncompletions++;
2150#endif
2151 return 0;
2152}
2153
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154/*
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002155 * Send a command to the controller, and wait for it to complete.
2156 * Only used at init time.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002158static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, /* 0: address the controller,
2159 1: address logical volume log_unit,
2160 2: periph device address is scsi3addr */
2161 unsigned int log_unit,
2162 __u8 page_code, unsigned char *scsi3addr, int cmd_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163{
2164 CommandList_struct *c;
2165 int i;
2166 unsigned long complete;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002167 ctlr_info_t *info_p = hba[ctlr];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 u64bit buff_dma_handle;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002169 int status, done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170
2171 if ((c = cmd_alloc(info_p, 1)) == NULL) {
2172 printk(KERN_WARNING "cciss: unable to get memory");
Bjorn Helgaase2019b52006-06-25 05:49:05 -07002173 return IO_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 }
2175 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002176 log_unit, page_code, scsi3addr, cmd_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 if (status != IO_OK) {
2178 cmd_free(info_p, c, 1);
2179 return status;
2180 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002181 resend_cmd1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 /*
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002183 * Disable interrupt
2184 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185#ifdef CCISS_DEBUG
2186 printk(KERN_DEBUG "cciss: turning intr off\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002187#endif /* CCISS_DEBUG */
2188 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
2189
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 /* Make sure there is room in the command FIFO */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002191 /* Actually it should be completely empty at this time */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002192 /* unless we are in here doing error handling for the scsi */
2193 /* tape side of the driver. */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002194 for (i = 200000; i > 0; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 /* if fifo isn't full go */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002196 if (!(info_p->access.fifo_full(info_p))) {
2197
2198 break;
2199 }
2200 udelay(10);
2201 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2202 " waiting!\n", ctlr);
2203 }
2204 /*
2205 * Send the cmd
2206 */
2207 info_p->access.submit_command(info_p, c);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002208 done = 0;
2209 do {
2210 complete = pollcomplete(ctlr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
2212#ifdef CCISS_DEBUG
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002213 printk(KERN_DEBUG "cciss: command completed\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002214#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002216 if (complete == 1) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002217 printk(KERN_WARNING
2218 "cciss cciss%d: SendCmd Timeout out, "
2219 "No command list address returned!\n", ctlr);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002220 status = IO_ERROR;
2221 done = 1;
2222 break;
2223 }
2224
2225 /* This will need to change for direct lookup completions */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002226 if ((complete & CISS_ERROR_BIT)
2227 && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
2228 /* if data overrun or underun on Report command
2229 ignore it
2230 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2232 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2233 (c->Request.CDB[0] == CISS_INQUIRY)) &&
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002234 ((c->err_info->CommandStatus ==
2235 CMD_DATA_OVERRUN) ||
2236 (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
2237 )) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 complete = c->busaddr;
2239 } else {
2240 if (c->err_info->CommandStatus ==
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002241 CMD_UNSOLICITED_ABORT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 printk(KERN_WARNING "cciss%d: "
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002243 "unsolicited abort %p\n",
2244 ctlr, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 if (c->retry_count < MAX_CMD_RETRIES) {
2246 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002247 "cciss%d: retrying %p\n",
2248 ctlr, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 c->retry_count++;
2250 /* erase the old error */
2251 /* information */
2252 memset(c->err_info, 0,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002253 sizeof
2254 (ErrorInfo_struct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 goto resend_cmd1;
2256 } else {
2257 printk(KERN_WARNING
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002258 "cciss%d: retried %p too "
2259 "many times\n", ctlr, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 status = IO_ERROR;
2261 goto cleanup1;
2262 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002263 } else if (c->err_info->CommandStatus ==
2264 CMD_UNABORTABLE) {
2265 printk(KERN_WARNING
2266 "cciss%d: command could not be aborted.\n",
2267 ctlr);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002268 status = IO_ERROR;
2269 goto cleanup1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 }
2271 printk(KERN_WARNING "ciss ciss%d: sendcmd"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002272 " Error %x \n", ctlr,
2273 c->err_info->CommandStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 printk(KERN_WARNING "ciss ciss%d: sendcmd"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002275 " offensive info\n"
2276 " size %x\n num %x value %x\n",
2277 ctlr,
2278 c->err_info->MoreErrInfo.Invalid_Cmd.
2279 offense_size,
2280 c->err_info->MoreErrInfo.Invalid_Cmd.
2281 offense_num,
2282 c->err_info->MoreErrInfo.Invalid_Cmd.
2283 offense_value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284 status = IO_ERROR;
2285 goto cleanup1;
2286 }
2287 }
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002288 /* This will need changing for direct lookup completions */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002289 if (complete != c->busaddr) {
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002290 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002291 BUG(); /* we are pretty much hosed if we get here. */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002292 }
2293 continue;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002294 } else
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002295 done = 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002296 } while (!done);
2297
2298 cleanup1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 /* unlock the data buffer from DMA */
Mike Millerbb2a37b2005-09-13 01:25:24 -07002300 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2301 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002303 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002304#ifdef CONFIG_CISS_SCSI_TAPE
2305 /* if we saved some commands for later, process them now. */
2306 if (info_p->scsi_rejects.ncompletions > 0)
David Howells7d12e782006-10-05 14:55:46 +01002307 do_cciss_intr(0, info_p);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002308#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 cmd_free(info_p, c, 1);
Bjorn Helgaase2019b52006-06-25 05:49:05 -07002310 return status;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002311}
2312
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313/*
2314 * Map (physical) PCI mem into (virtual) kernel space
2315 */
2316static void __iomem *remap_pci_mem(ulong base, ulong size)
2317{
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002318 ulong page_base = ((ulong) base) & PAGE_MASK;
2319 ulong page_offs = ((ulong) base) - page_base;
2320 void __iomem *page_remapped = ioremap(page_base, page_offs + size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002322 return page_remapped ? (page_remapped + page_offs) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323}
2324
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002325/*
2326 * Takes jobs of the Q and sends them to the hardware, then puts it on
2327 * the Q to wait for completion.
2328 */
2329static void start_io(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330{
2331 CommandList_struct *c;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002332
2333 while ((c = h->reqQ) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 /* can't do anything if fifo is full */
2335 if ((h->access.fifo_full(h))) {
2336 printk(KERN_WARNING "cciss: fifo full\n");
2337 break;
2338 }
2339
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002340 /* Get the first entry from the Request Q */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 removeQ(&(h->reqQ), c);
2342 h->Qdepth--;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002343
2344 /* Tell the controller execute command */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 h->access.submit_command(h, c);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002346
2347 /* Put job onto the completed Q */
2348 addQ(&(h->cmpQ), c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 }
2350}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352/* Assumes that CCISS_LOCK(h->ctlr) is held. */
2353/* Zeros out the error record and then resends the command back */
2354/* to the controller */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002355static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356{
2357 /* erase the old error information */
2358 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2359
2360 /* add it to software queue and then send it to the controller */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002361 addQ(&(h->reqQ), c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 h->Qdepth++;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002363 if (h->Qdepth > h->maxQsinceinit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 h->maxQsinceinit = h->Qdepth;
2365
2366 start_io(h);
2367}
Jens Axboea9925a02006-01-09 16:04:06 +01002368
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002369static inline int evaluate_target_status(CommandList_struct *cmd)
2370{
2371 unsigned char sense_key;
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002372 int error_count = 1;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002373
2374 if (cmd->err_info->ScsiStatus != 0x02) { /* not check condition? */
2375 if (!blk_pc_request(cmd->rq))
2376 printk(KERN_WARNING "cciss: cmd %p "
2377 "has SCSI Status 0x%x\n",
2378 cmd, cmd->err_info->ScsiStatus);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002379 return error_count;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002380 }
2381
2382 /* check the sense key */
2383 sense_key = 0xf & cmd->err_info->SenseInfo[2];
2384 /* no status or recovered error */
2385 if ((sense_key == 0x0) || (sense_key == 0x1))
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002386 error_count = 0;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002387
2388 if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002389 if (error_count != 0)
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002390 printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
2391 " sense key = 0x%x\n", cmd, sense_key);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002392 return error_count;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002393 }
2394
2395 /* SG_IO or similar, copy sense data back */
2396 if (cmd->rq->sense) {
2397 if (cmd->rq->sense_len > cmd->err_info->SenseLen)
2398 cmd->rq->sense_len = cmd->err_info->SenseLen;
2399 memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
2400 cmd->rq->sense_len);
2401 } else
2402 cmd->rq->sense_len = 0;
2403
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002404 return error_count;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002405}
2406
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002407/* checks the status of the job and calls complete buffers to mark all
Jens Axboea9925a02006-01-09 16:04:06 +01002408 * buffers for the completed job. Note that this function does not need
2409 * to hold the hba/queue lock.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002410 */
2411static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
2412 int timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 int retry_cmd = 0;
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002415 struct request *rq = cmd->rq;
2416
2417 rq->errors = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002419 if (timeout)
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002420 rq->errors = 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002421
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002422 if (cmd->err_info->CommandStatus == 0) /* no error has occurred */
2423 goto after_error_processing;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002424
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002425 switch (cmd->err_info->CommandStatus) {
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002426 case CMD_TARGET_STATUS:
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002427 rq->errors = evaluate_target_status(cmd);
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002428 break;
2429 case CMD_DATA_UNDERRUN:
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002430 if (blk_fs_request(cmd->rq)) {
2431 printk(KERN_WARNING "cciss: cmd %p has"
2432 " completed with data underrun "
2433 "reported\n", cmd);
2434 cmd->rq->data_len = cmd->err_info->ResidualCnt;
2435 }
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002436 break;
2437 case CMD_DATA_OVERRUN:
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002438 if (blk_fs_request(cmd->rq))
2439 printk(KERN_WARNING "cciss: cmd %p has"
2440 " completed with data overrun "
2441 "reported\n", cmd);
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002442 break;
2443 case CMD_INVALID:
2444 printk(KERN_WARNING "cciss: cmd %p is "
2445 "reported invalid\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002446 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002447 break;
2448 case CMD_PROTOCOL_ERR:
2449 printk(KERN_WARNING "cciss: cmd %p has "
2450 "protocol error \n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002451 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002452 break;
2453 case CMD_HARDWARE_ERR:
2454 printk(KERN_WARNING "cciss: cmd %p had "
2455 " hardware error\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002456 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002457 break;
2458 case CMD_CONNECTION_LOST:
2459 printk(KERN_WARNING "cciss: cmd %p had "
2460 "connection lost\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002461 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002462 break;
2463 case CMD_ABORTED:
2464 printk(KERN_WARNING "cciss: cmd %p was "
2465 "aborted\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002466 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002467 break;
2468 case CMD_ABORT_FAILED:
2469 printk(KERN_WARNING "cciss: cmd %p reports "
2470 "abort failed\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002471 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002472 break;
2473 case CMD_UNSOLICITED_ABORT:
2474 printk(KERN_WARNING "cciss%d: unsolicited "
2475 "abort %p\n", h->ctlr, cmd);
2476 if (cmd->retry_count < MAX_CMD_RETRIES) {
2477 retry_cmd = 1;
2478 printk(KERN_WARNING
2479 "cciss%d: retrying %p\n", h->ctlr, cmd);
2480 cmd->retry_count++;
2481 } else
2482 printk(KERN_WARNING
2483 "cciss%d: %p retried too "
2484 "many times\n", h->ctlr, cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002485 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002486 break;
2487 case CMD_TIMEOUT:
2488 printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002489 rq->errors = 1;
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002490 break;
2491 default:
2492 printk(KERN_WARNING "cciss: cmd %p returned "
2493 "unknown status %x\n", cmd,
2494 cmd->err_info->CommandStatus);
Mike Miller (OS Dev)198b7662007-05-08 00:29:34 -07002495 rq->errors = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 }
Mike Miller (OS Dev)d38ae162007-05-08 00:29:29 -07002497
2498after_error_processing:
2499
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 /* We need to return this command */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002501 if (retry_cmd) {
2502 resend_cciss_cmd(h, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 return;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002504 }
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002505 cmd->rq->data_len = 0;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002506 cmd->rq->completion_data = cmd;
Jens Axboe2056a782006-03-23 20:00:26 +01002507 blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
Jens Axboea9925a02006-01-09 16:04:06 +01002508 blk_complete_request(cmd->rq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509}
2510
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002511/*
2512 * Get a request and submit it to the controller.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 */
Jens Axboe165125e2007-07-24 09:28:11 +02002514static void do_cciss_request(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515{
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002516 ctlr_info_t *h = q->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 CommandList_struct *c;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002518 sector_t start_blk;
2519 int seg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 struct request *creq;
2521 u64bit temp64;
2522 struct scatterlist tmp_sg[MAXSGENTRIES];
2523 drive_info_struct *drv;
2524 int i, dir;
2525
2526 /* We call start_io here in case there is a command waiting on the
2527 * queue that has not been sent.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002528 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 if (blk_queue_plugged(q))
2530 goto startio;
2531
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002532 queue:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533 creq = elv_next_request(q);
2534 if (!creq)
2535 goto startio;
2536
Eric Sesterhenn089fe1b2006-03-24 18:50:27 +01002537 BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002539 if ((c = cmd_alloc(h, 1)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 goto full;
2541
2542 blkdev_dequeue_request(creq);
2543
2544 spin_unlock_irq(q->queue_lock);
2545
2546 c->cmd_type = CMD_RWREQ;
2547 c->rq = creq;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002548
2549 /* fill in the request */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 drv = creq->rq_disk->private_data;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002551 c->Header.ReplyQueue = 0; // unused in simple mode
Mike Miller33079b22005-09-13 01:25:22 -07002552 /* got command from pool, so use the command block index instead */
2553 /* for direct lookups. */
2554 /* The first 2 bits are reserved for controller error reporting. */
2555 c->Header.Tag.lower = (c->cmdindex << 3);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002556 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2557 c->Header.LUN.LogDev.VolId = drv->LunID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 c->Header.LUN.LogDev.Mode = 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002559 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2560 c->Request.Type.Type = TYPE_CMD; // It is a command.
2561 c->Request.Type.Attribute = ATTR_SIMPLE;
2562 c->Request.Type.Direction =
Mike Millera52de242006-12-18 11:00:14 +01002563 (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002564 c->Request.Timeout = 0; // Don't time out
2565 c->Request.CDB[0] =
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002566 (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 start_blk = creq->sector;
2568#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002569 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
2570 (int)creq->nr_sectors);
2571#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572
2573 seg = blk_rq_map_sg(q, creq, tmp_sg);
2574
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002575 /* get the DMA records for the setup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 if (c->Request.Type.Direction == XFER_READ)
2577 dir = PCI_DMA_FROMDEVICE;
2578 else
2579 dir = PCI_DMA_TODEVICE;
2580
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002581 for (i = 0; i < seg; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 c->SG[i].Len = tmp_sg[i].length;
2583 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002584 tmp_sg[i].offset,
2585 tmp_sg[i].length, dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 c->SG[i].Addr.lower = temp64.val32.lower;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002587 c->SG[i].Addr.upper = temp64.val32.upper;
2588 c->SG[i].Ext = 0; // we are not chaining
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002590 /* track how many SG entries we are using */
2591 if (seg > h->maxSG)
2592 h->maxSG = seg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593
2594#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002595 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
2596 creq->nr_sectors, seg);
2597#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598
2599 c->Header.SGList = c->Header.SGTotal = seg;
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002600 if (likely(blk_fs_request(creq))) {
2601 if(h->cciss_read == CCISS_READ_10) {
2602 c->Request.CDB[1] = 0;
2603 c->Request.CDB[2] = (start_blk >> 24) & 0xff; //MSB
2604 c->Request.CDB[3] = (start_blk >> 16) & 0xff;
2605 c->Request.CDB[4] = (start_blk >> 8) & 0xff;
2606 c->Request.CDB[5] = start_blk & 0xff;
2607 c->Request.CDB[6] = 0; // (sect >> 24) & 0xff; MSB
2608 c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
2609 c->Request.CDB[8] = creq->nr_sectors & 0xff;
2610 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2611 } else {
2612 c->Request.CDBLen = 16;
2613 c->Request.CDB[1]= 0;
2614 c->Request.CDB[2]= (start_blk >> 56) & 0xff; //MSB
2615 c->Request.CDB[3]= (start_blk >> 48) & 0xff;
2616 c->Request.CDB[4]= (start_blk >> 40) & 0xff;
2617 c->Request.CDB[5]= (start_blk >> 32) & 0xff;
2618 c->Request.CDB[6]= (start_blk >> 24) & 0xff;
2619 c->Request.CDB[7]= (start_blk >> 16) & 0xff;
2620 c->Request.CDB[8]= (start_blk >> 8) & 0xff;
2621 c->Request.CDB[9]= start_blk & 0xff;
2622 c->Request.CDB[10]= (creq->nr_sectors >> 24) & 0xff;
2623 c->Request.CDB[11]= (creq->nr_sectors >> 16) & 0xff;
2624 c->Request.CDB[12]= (creq->nr_sectors >> 8) & 0xff;
2625 c->Request.CDB[13]= creq->nr_sectors & 0xff;
2626 c->Request.CDB[14] = c->Request.CDB[15] = 0;
2627 }
2628 } else if (blk_pc_request(creq)) {
2629 c->Request.CDBLen = creq->cmd_len;
2630 memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002631 } else {
Mike Miller (OS Dev)03bbfee2007-05-08 00:29:32 -07002632 printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
2633 BUG();
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002634 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635
2636 spin_lock_irq(q->queue_lock);
2637
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002638 addQ(&(h->reqQ), c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 h->Qdepth++;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002640 if (h->Qdepth > h->maxQsinceinit)
2641 h->maxQsinceinit = h->Qdepth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642
2643 goto queue;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002644full:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 blk_stop_queue(q);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07002646startio:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 /* We will already have the driver lock here so not need
2648 * to lock it.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002649 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 start_io(h);
2651}
2652
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002653static inline unsigned long get_next_completion(ctlr_info_t *h)
2654{
2655#ifdef CONFIG_CISS_SCSI_TAPE
2656 /* Any rejects from sendcmd() lying around? Process them first */
2657 if (h->scsi_rejects.ncompletions == 0)
2658 return h->access.command_completed(h);
2659 else {
2660 struct sendcmd_reject_list *srl;
2661 int n;
2662 srl = &h->scsi_rejects;
2663 n = --srl->ncompletions;
2664 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2665 printk("p");
2666 return srl->complete[n];
2667 }
2668#else
2669 return h->access.command_completed(h);
2670#endif
2671}
2672
2673static inline int interrupt_pending(ctlr_info_t *h)
2674{
2675#ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002676 return (h->access.intr_pending(h)
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002677 || (h->scsi_rejects.ncompletions > 0));
2678#else
2679 return h->access.intr_pending(h);
2680#endif
2681}
2682
2683static inline long interrupt_not_for_us(ctlr_info_t *h)
2684{
2685#ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002686 return (((h->access.intr_pending(h) == 0) ||
2687 (h->interrupts_enabled == 0))
2688 && (h->scsi_rejects.ncompletions == 0));
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002689#else
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002690 return (((h->access.intr_pending(h) == 0) ||
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002691 (h->interrupts_enabled == 0)));
2692#endif
2693}
2694
David Howells7d12e782006-10-05 14:55:46 +01002695static irqreturn_t do_cciss_intr(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696{
2697 ctlr_info_t *h = dev_id;
2698 CommandList_struct *c;
2699 unsigned long flags;
Mike Miller33079b22005-09-13 01:25:22 -07002700 __u32 a, a1, a2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002702 if (interrupt_not_for_us(h))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 return IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704 /*
2705 * If there are completed commands in the completion queue,
2706 * we had better do something about it.
2707 */
2708 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06002709 while (interrupt_pending(h)) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002710 while ((a = get_next_completion(h)) != FIFO_EMPTY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 a1 = a;
Mike Miller33079b22005-09-13 01:25:22 -07002712 if ((a & 0x04)) {
2713 a2 = (a >> 3);
Mike Millerf8806322006-12-06 20:35:01 -08002714 if (a2 >= h->nr_cmds) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002715 printk(KERN_WARNING
2716 "cciss: controller cciss%d failed, stopping.\n",
2717 h->ctlr);
Mike Miller33079b22005-09-13 01:25:22 -07002718 fail_all_cmds(h->ctlr);
2719 return IRQ_HANDLED;
2720 }
2721
2722 c = h->cmd_pool + a2;
2723 a = c->busaddr;
2724
2725 } else {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002726 a &= ~3;
Mike Miller33079b22005-09-13 01:25:22 -07002727 if ((c = h->cmpQ) == NULL) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002728 printk(KERN_WARNING
2729 "cciss: Completion of %08x ignored\n",
2730 a1);
2731 continue;
2732 }
2733 while (c->busaddr != a) {
2734 c = c->next;
2735 if (c == h->cmpQ)
2736 break;
2737 }
Mike Miller33079b22005-09-13 01:25:22 -07002738 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 /*
2740 * If we've found the command, take it off the
2741 * completion Q and free it
2742 */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002743 if (c->busaddr == a) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744 removeQ(&h->cmpQ, c);
2745 if (c->cmd_type == CMD_RWREQ) {
2746 complete_command(h, c, 0);
2747 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2748 complete(c->waiting);
2749 }
2750# ifdef CONFIG_CISS_SCSI_TAPE
2751 else if (c->cmd_type == CMD_SCSI)
2752 complete_scsi_command(c, 0, a1);
2753# endif
2754 continue;
2755 }
2756 }
2757 }
2758
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2760 return IRQ_HANDLED;
2761}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002762
2763/*
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07002764 * We cannot read the structure directly, for portability we must use
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 * the io functions.
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002766 * This is for debug only.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 */
2768#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002769static void print_cfg_table(CfgTable_struct *tb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770{
2771 int i;
2772 char temp_name[17];
2773
2774 printk("Controller Configuration information\n");
2775 printk("------------------------------------\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002776 for (i = 0; i < 4; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777 temp_name[i] = readb(&(tb->Signature[i]));
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002778 temp_name[4] = '\0';
2779 printk(" Signature = %s\n", temp_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002781 printk(" Transport methods supported = 0x%x\n",
2782 readl(&(tb->TransportSupport)));
2783 printk(" Transport methods active = 0x%x\n",
2784 readl(&(tb->TransportActive)));
2785 printk(" Requested transport Method = 0x%x\n",
2786 readl(&(tb->HostWrite.TransportRequest)));
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07002787 printk(" Coalesce Interrupt Delay = 0x%x\n",
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002788 readl(&(tb->HostWrite.CoalIntDelay)));
Bjorn Helgaasd14c4ab2006-06-25 05:49:04 -07002789 printk(" Coalesce Interrupt Count = 0x%x\n",
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002790 readl(&(tb->HostWrite.CoalIntCount)));
2791 printk(" Max outstanding commands = 0x%d\n",
2792 readl(&(tb->CmdsOutMax)));
2793 printk(" Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
2794 for (i = 0; i < 16; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 temp_name[i] = readb(&(tb->ServerName[i]));
2796 temp_name[16] = '\0';
2797 printk(" Server Name = %s\n", temp_name);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002798 printk(" Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799}
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002800#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002802static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803{
2804 int i, offset, mem_type, bar_type;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002805 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 return 0;
2807 offset = 0;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002808 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
2809 bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002810 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2811 offset += 4;
2812 else {
2813 mem_type = pci_resource_flags(pdev, i) &
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002814 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 switch (mem_type) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002816 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2817 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2818 offset += 4; /* 32 bit */
2819 break;
2820 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2821 offset += 8;
2822 break;
2823 default: /* reserved in PCI 2.2 */
2824 printk(KERN_WARNING
2825 "Base address is invalid\n");
2826 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 break;
2828 }
2829 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002830 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2831 return i + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 }
2833 return -1;
2834}
2835
Mike Millerfb86a352006-01-08 01:03:50 -08002836/* If MSI/MSI-X is supported by the kernel we will try to enable it on
2837 * controllers that are capable. If not, we use IO-APIC mode.
2838 */
2839
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002840static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
2841 struct pci_dev *pdev, __u32 board_id)
Mike Millerfb86a352006-01-08 01:03:50 -08002842{
2843#ifdef CONFIG_PCI_MSI
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002844 int err;
2845 struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
2846 {0, 2}, {0, 3}
2847 };
Mike Millerfb86a352006-01-08 01:03:50 -08002848
2849 /* Some boards advertise MSI but don't really support it */
2850 if ((board_id == 0x40700E11) ||
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002851 (board_id == 0x40800E11) ||
2852 (board_id == 0x40820E11) || (board_id == 0x40830E11))
Mike Millerfb86a352006-01-08 01:03:50 -08002853 goto default_int_mode;
2854
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002855 if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
2856 err = pci_enable_msix(pdev, cciss_msix_entries, 4);
2857 if (!err) {
2858 c->intr[0] = cciss_msix_entries[0].vector;
2859 c->intr[1] = cciss_msix_entries[1].vector;
2860 c->intr[2] = cciss_msix_entries[2].vector;
2861 c->intr[3] = cciss_msix_entries[3].vector;
2862 c->msix_vector = 1;
2863 return;
2864 }
2865 if (err > 0) {
2866 printk(KERN_WARNING "cciss: only %d MSI-X vectors "
2867 "available\n", err);
Mike Miller1ecb9c02006-12-06 20:35:13 -08002868 goto default_int_mode;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002869 } else {
2870 printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
2871 err);
Mike Miller1ecb9c02006-12-06 20:35:13 -08002872 goto default_int_mode;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002873 }
2874 }
2875 if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
2876 if (!pci_enable_msi(pdev)) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002877 c->msi_vector = 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002878 } else {
2879 printk(KERN_WARNING "cciss: MSI init failed\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002880 }
2881 }
Mike Miller1ecb9c02006-12-06 20:35:13 -08002882default_int_mode:
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002883#endif /* CONFIG_PCI_MSI */
Mike Millerfb86a352006-01-08 01:03:50 -08002884 /* if we get here we're going to use the default interrupt mode */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002885 c->intr[SIMPLE_MODE_INT] = pdev->irq;
Mike Millerfb86a352006-01-08 01:03:50 -08002886 return;
2887}
2888
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2890{
2891 ushort subsystem_vendor_id, subsystem_device_id, command;
2892 __u32 board_id, scratchpad = 0;
2893 __u64 cfg_offset;
2894 __u32 cfg_base_addr;
2895 __u64 cfg_base_addr_index;
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002896 int i, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897
2898 /* check to see if controller has been disabled */
2899 /* BEFORE trying to enable it */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002900 (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
2901 if (!(command & 0x02)) {
2902 printk(KERN_WARNING
2903 "cciss: controller appears to be disabled\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002904 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 }
2906
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002907 err = pci_enable_device(pdev);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002908 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002910 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912
Bjorn Helgaas4e570302006-06-25 05:49:02 -07002913 err = pci_request_regions(pdev, "cciss");
2914 if (err) {
2915 printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002916 "aborting\n");
Mike Miller872225c2006-12-13 00:34:22 -08002917 return err;
Bjorn Helgaas4e570302006-06-25 05:49:02 -07002918 }
2919
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920 subsystem_vendor_id = pdev->subsystem_vendor;
2921 subsystem_device_id = pdev->subsystem_device;
2922 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002923 subsystem_vendor_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925#ifdef CCISS_DEBUG
2926 printk("command = %x\n", command);
2927 printk("irq = %x\n", pdev->irq);
2928 printk("board_id = %x\n", board_id);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002929#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930
Mike Millerfb86a352006-01-08 01:03:50 -08002931/* If the kernel supports MSI/MSI-X we will try to enable that functionality,
2932 * else we use the IO-APIC interrupt assigned to us by system ROM.
2933 */
2934 cciss_interrupt_mode(c, pdev, board_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935
2936 /*
2937 * Memory base addr is first addr , the second points to the config
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002938 * table
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 */
2940
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002941 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942#ifdef CCISS_DEBUG
2943 printk("address 0 = %x\n", c->paddr);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002944#endif /* CCISS_DEBUG */
Mike Millera5b92872006-12-13 00:34:21 -08002945 c->vaddr = remap_pci_mem(c->paddr, 0x250);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946
2947 /* Wait for the board to become ready. (PCI hotplug needs this.)
2948 * We poll for up to 120 secs, once per 100ms. */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002949 for (i = 0; i < 1200; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2951 if (scratchpad == CCISS_FIRMWARE_READY)
2952 break;
2953 set_current_state(TASK_INTERRUPTIBLE);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002954 schedule_timeout(HZ / 10); /* wait 100ms */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 }
2956 if (scratchpad != CCISS_FIRMWARE_READY) {
2957 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002958 err = -ENODEV;
Bjorn Helgaas4e570302006-06-25 05:49:02 -07002959 goto err_out_free_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960 }
2961
2962 /* get the address index number */
2963 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2964 cfg_base_addr &= (__u32) 0x0000ffff;
2965#ifdef CCISS_DEBUG
2966 printk("cfg base address = %x\n", cfg_base_addr);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002967#endif /* CCISS_DEBUG */
2968 cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969#ifdef CCISS_DEBUG
2970 printk("cfg base address index = %x\n", cfg_base_addr_index);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002971#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 if (cfg_base_addr_index == -1) {
2973 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07002974 err = -ENODEV;
Bjorn Helgaas4e570302006-06-25 05:49:02 -07002975 goto err_out_free_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976 }
2977
2978 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2979#ifdef CCISS_DEBUG
2980 printk("cfg offset = %x\n", cfg_offset);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002981#endif /* CCISS_DEBUG */
2982 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2983 cfg_base_addr_index) +
2984 cfg_offset, sizeof(CfgTable_struct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 c->board_id = board_id;
2986
2987#ifdef CCISS_DEBUG
Tobias Klauser945f3902006-01-08 01:05:11 -08002988 print_cfg_table(c->cfgtable);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002989#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002991 for (i = 0; i < ARRAY_SIZE(products); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 if (board_id == products[i].board_id) {
2993 c->product_name = products[i].product_name;
2994 c->access = *(products[i].access);
Mike Millerf8806322006-12-06 20:35:01 -08002995 c->nr_cmds = products[i].nr_cmds;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 break;
2997 }
2998 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07002999 if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
3000 (readb(&c->cfgtable->Signature[1]) != 'I') ||
3001 (readb(&c->cfgtable->Signature[2]) != 'S') ||
3002 (readb(&c->cfgtable->Signature[3]) != 'S')) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 printk("Does not appear to be a valid CISS config table\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07003004 err = -ENODEV;
Bjorn Helgaas4e570302006-06-25 05:49:02 -07003005 goto err_out_free_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003006 }
Mike Miller4ff9a9a2006-12-06 20:35:00 -08003007 /* We didn't find the controller in our list. We know the
3008 * signature is valid. If it's an HP device let's try to
3009 * bind to the device and fire it up. Otherwise we bail.
3010 */
3011 if (i == ARRAY_SIZE(products)) {
3012 if (subsystem_vendor_id == PCI_VENDOR_ID_HP) {
3013 c->product_name = products[i-1].product_name;
3014 c->access = *(products[i-1].access);
Mike Millerf8806322006-12-06 20:35:01 -08003015 c->nr_cmds = products[i-1].nr_cmds;
Mike Miller4ff9a9a2006-12-06 20:35:00 -08003016 printk(KERN_WARNING "cciss: This is an unknown "
3017 "Smart Array controller.\n"
3018 "cciss: Please update to the latest driver "
3019 "available from www.hp.com.\n");
3020 } else {
3021 printk(KERN_WARNING "cciss: Sorry, I don't know how"
3022 " to access the Smart Array controller %08lx\n"
3023 , (unsigned long)board_id);
3024 err = -ENODEV;
3025 goto err_out_free_res;
3026 }
3027 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028#ifdef CONFIG_X86
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003029 {
3030 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
3031 __u32 prefetch;
3032 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
3033 prefetch |= 0x100;
3034 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
3035 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036#endif
3037
Mike Millerf92e2f52006-12-06 20:35:04 -08003038 /* Disabling DMA prefetch for the P600
3039 * An ASIC bug may result in a prefetch beyond
3040 * physical memory.
3041 */
3042 if(board_id == 0x3225103C) {
3043 __u32 dma_prefetch;
3044 dma_prefetch = readl(c->vaddr + I2O_DMA1_CFG);
3045 dma_prefetch |= 0x8000;
3046 writel(dma_prefetch, c->vaddr + I2O_DMA1_CFG);
3047 }
3048
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049#ifdef CCISS_DEBUG
3050 printk("Trying to put board into Simple mode\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003051#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003053 /* Update the field, and then ring the doorbell */
3054 writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
3055 writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056
3057 /* under certain very rare conditions, this can take awhile.
3058 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
3059 * as we enter this code.) */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003060 for (i = 0; i < MAX_CONFIG_WAIT; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
3062 break;
3063 /* delay and try again */
3064 set_current_state(TASK_INTERRUPTIBLE);
3065 schedule_timeout(10);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003066 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
3068#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003069 printk(KERN_DEBUG "I counter got to %d %x\n", i,
3070 readl(c->vaddr + SA5_DOORBELL));
3071#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003073 print_cfg_table(c->cfgtable);
3074#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003075
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003076 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077 printk(KERN_WARNING "cciss: unable to get board into"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003078 " simple mode\n");
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07003079 err = -ENODEV;
Bjorn Helgaas4e570302006-06-25 05:49:02 -07003080 goto err_out_free_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081 }
3082 return 0;
3083
Linus Torvalds5faad622006-12-13 09:15:34 -08003084err_out_free_res:
Mike Miller872225c2006-12-13 00:34:22 -08003085 /*
3086 * Deliberately omit pci_disable_device(): it does something nasty to
3087 * Smart Array controllers that pci_enable_device does not undo
3088 */
Bjorn Helgaas4e570302006-06-25 05:49:02 -07003089 pci_release_regions(pdev);
Bjorn Helgaasc33ac892006-06-25 05:49:01 -07003090 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003091}
3092
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003093/*
3094 * Gets information about the local volumes attached to the controller.
3095 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096static void cciss_getgeometry(int cntl_num)
3097{
3098 ReportLunData_struct *ld_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 InquiryData_struct *inq_buff;
3100 int return_code;
3101 int i;
3102 int listlength = 0;
3103 __u32 lunid = 0;
3104 int block_size;
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07003105 sector_t total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106
Eric Sesterhenn06ff37f2006-03-08 11:21:52 +01003107 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003108 if (ld_buff == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109 printk(KERN_ERR "cciss: out of memory\n");
3110 return;
3111 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003112 inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
3113 if (inq_buff == NULL) {
3114 printk(KERN_ERR "cciss: out of memory\n");
3115 kfree(ld_buff);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003116 return;
3117 }
3118 /* Get the firmware version */
3119 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
3120 sizeof(InquiryData_struct), 0, 0, 0, NULL,
3121 TYPE_CMD);
3122 if (return_code == IO_OK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
3124 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
3125 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
3126 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003127 } else { /* send command failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003129 printk(KERN_WARNING "cciss: unable to determine firmware"
3130 " version of controller\n");
3131 }
3132 /* Get the number of logical volumes */
3133 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
3134 sizeof(ReportLunData_struct), 0, 0, 0, NULL,
3135 TYPE_CMD);
3136
3137 if (return_code == IO_OK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138#ifdef CCISS_DEBUG
3139 printk("LUN Data\n--------------------------\n");
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003140#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003142 listlength |=
3143 (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
3144 listlength |=
3145 (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
3146 listlength |=
3147 (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003149 } else { /* reading number of logical volumes failed */
3150
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 printk(KERN_WARNING "cciss: report logical volume"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003152 " command failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 listlength = 0;
3154 }
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003155 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
3156 if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
3157 printk(KERN_ERR
3158 "ciss: only %d number of logical volumes supported\n",
3159 CISS_MAX_LUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160 hba[cntl_num]->num_luns = CISS_MAX_LUN;
3161 }
3162#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003163 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
3164 ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
3165 ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
3166 hba[cntl_num]->num_luns);
3167#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003168
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003169 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003170 for (i = 0; i < CISS_MAX_LUN; i++) {
3171 if (i < hba[cntl_num]->num_luns) {
3172 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
3173 << 24;
3174 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
3175 << 16;
3176 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
3177 << 8;
3178 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003180 hba[cntl_num]->drv[i].LunID = lunid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181
3182#ifdef CCISS_DEBUG
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003183 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
3184 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
3185 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
3186 hba[cntl_num]->drv[i].LunID);
3187#endif /* CCISS_DEBUG */
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07003188
3189 /* testing to see if 16-byte CDBs are already being used */
3190 if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
3191 cciss_read_capacity_16(cntl_num, i, 0,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003192 &total_size, &block_size);
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07003193 goto geo_inq;
3194 }
3195 cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
3196
Mike Miller (OS Dev)97c06972007-03-06 01:42:14 -08003197 /* If read_capacity returns all F's the logical is >2TB */
3198 /* so we switch to 16-byte CDBs for all read/write ops */
3199 if(total_size == 0xFFFFFFFFULL) {
Mike Miller (OS Dev)00988a32006-09-30 23:27:23 -07003200 cciss_read_capacity_16(cntl_num, i, 0,
3201 &total_size, &block_size);
3202 hba[cntl_num]->cciss_read = CCISS_READ_16;
3203 hba[cntl_num]->cciss_write = CCISS_WRITE_16;
3204 } else {
3205 hba[cntl_num]->cciss_read = CCISS_READ_10;
3206 hba[cntl_num]->cciss_write = CCISS_WRITE_10;
3207 }
3208geo_inq:
Mike Millerddd47442005-09-13 01:25:22 -07003209 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003210 block_size, inq_buff,
3211 &hba[cntl_num]->drv[i]);
Mike Millerddd47442005-09-13 01:25:22 -07003212 } else {
3213 /* initialize raid_level to indicate a free space */
3214 hba[cntl_num]->drv[i].raid_level = -1;
3215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 }
3217 kfree(ld_buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218 kfree(inq_buff);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003219}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220
3221/* Function to find the first free pointer into our hba[] array */
3222/* Returns -1 if no free entries are left. */
3223static int alloc_cciss_hba(void)
3224{
Mike Miller799202c2006-12-06 20:35:12 -08003225 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003227 for (i = 0; i < MAX_CTLR; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 if (!hba[i]) {
3229 ctlr_info_t *p;
Eric Sesterhenn06ff37f2006-03-08 11:21:52 +01003230 p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 if (!p)
3232 goto Enomem;
Mike Miller799202c2006-12-06 20:35:12 -08003233 p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
3234 if (!p->gendisk[0])
3235 goto Enomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003236 hba[i] = p;
3237 return i;
3238 }
3239 }
3240 printk(KERN_WARNING "cciss: This driver supports a maximum"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003241 " of %d controllers.\n", MAX_CTLR);
Mike Miller799202c2006-12-06 20:35:12 -08003242 return -1;
3243Enomem:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244 printk(KERN_ERR "cciss: out of memory.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245 return -1;
3246}
3247
3248static void free_hba(int i)
3249{
3250 ctlr_info_t *p = hba[i];
3251 int n;
3252
3253 hba[i] = NULL;
Mike Miller799202c2006-12-06 20:35:12 -08003254 for (n = 0; n < CISS_MAX_LUN; n++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 put_disk(p->gendisk[n]);
3256 kfree(p);
3257}
3258
3259/*
3260 * This is it. Find all the controllers and register them. I really hate
3261 * stealing all these major device numbers.
3262 * returns the number of block devices registered.
3263 */
3264static int __devinit cciss_init_one(struct pci_dev *pdev,
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003265 const struct pci_device_id *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267 int i;
Mike Miller799202c2006-12-06 20:35:12 -08003268 int j = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269 int rc;
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003270 int dac;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272 i = alloc_cciss_hba();
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003273 if (i < 0)
Bjorn Helgaase2019b52006-06-25 05:49:05 -07003274 return -1;
Mike Miller1f8ef382005-09-13 01:25:21 -07003275
3276 hba[i]->busy_initializing = 1;
3277
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 if (cciss_pci_init(hba[i], pdev) != 0)
3279 goto clean1;
3280
3281 sprintf(hba[i]->devname, "cciss%d", i);
3282 hba[i]->ctlr = i;
3283 hba[i]->pdev = pdev;
3284
3285 /* configure PCI DMA stuff */
mike.miller@hp.comeb0df992005-06-10 14:51:04 -05003286 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003287 dac = 1;
mike.miller@hp.comeb0df992005-06-10 14:51:04 -05003288 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003289 dac = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290 else {
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003291 printk(KERN_ERR "cciss: no suitable DMA available\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 goto clean1;
3293 }
3294
3295 /*
3296 * register with the major number, or get a dynamic major number
3297 * by passing 0 as argument. This is done for greater than
3298 * 8 controller support.
3299 */
3300 if (i < MAX_CTLR_ORIG)
Christoph Hellwig564de742006-01-08 01:05:17 -08003301 hba[i]->major = COMPAQ_CISS_MAJOR + i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302 rc = register_blkdev(hba[i]->major, hba[i]->devname);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003303 if (rc == -EBUSY || rc == -EINVAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304 printk(KERN_ERR
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003305 "cciss: Unable to get major number %d for %s "
3306 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307 goto clean1;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003308 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309 if (i >= MAX_CTLR_ORIG)
3310 hba[i]->major = rc;
3311 }
3312
3313 /* make sure the board interrupts are off */
3314 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003315 if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
Thomas Gleixner69ab3912006-07-01 19:29:32 -07003316 IRQF_DISABLED | IRQF_SHARED, hba[i]->devname, hba[i])) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003318 hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 goto clean2;
3320 }
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003321
3322 printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003323 hba[i]->devname, pdev->device, pci_name(pdev),
3324 hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
Bjorn Helgaas40aabb52006-06-25 05:49:03 -07003325
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003326 hba[i]->cmd_pool_bits =
Mike Millerf8806322006-12-06 20:35:01 -08003327 kmalloc(((hba[i]->nr_cmds + BITS_PER_LONG -
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003328 1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
3329 hba[i]->cmd_pool = (CommandList_struct *)
3330 pci_alloc_consistent(hba[i]->pdev,
Mike Millerf8806322006-12-06 20:35:01 -08003331 hba[i]->nr_cmds * sizeof(CommandList_struct),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003332 &(hba[i]->cmd_pool_dhandle));
3333 hba[i]->errinfo_pool = (ErrorInfo_struct *)
3334 pci_alloc_consistent(hba[i]->pdev,
Mike Millerf8806322006-12-06 20:35:01 -08003335 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003336 &(hba[i]->errinfo_pool_dhandle));
3337 if ((hba[i]->cmd_pool_bits == NULL)
3338 || (hba[i]->cmd_pool == NULL)
3339 || (hba[i]->errinfo_pool == NULL)) {
3340 printk(KERN_ERR "cciss: out of memory");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 goto clean4;
3342 }
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003343#ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003344 hba[i]->scsi_rejects.complete =
3345 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
Mike Millerf8806322006-12-06 20:35:01 -08003346 (hba[i]->nr_cmds + 5), GFP_KERNEL);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003347 if (hba[i]->scsi_rejects.complete == NULL) {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003348 printk(KERN_ERR "cciss: out of memory");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003349 goto clean4;
3350 }
3351#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352 spin_lock_init(&hba[i]->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003354 /* Initialize the pdev driver private data.
3355 have it point to hba[i]. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 pci_set_drvdata(pdev, hba[i]);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003357 /* command and error info recs zeroed out before
3358 they are used */
3359 memset(hba[i]->cmd_pool_bits, 0,
Mike Millerf8806322006-12-06 20:35:01 -08003360 ((hba[i]->nr_cmds + BITS_PER_LONG -
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003361 1) / BITS_PER_LONG) * sizeof(unsigned long));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003363#ifdef CCISS_DEBUG
3364 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
3365#endif /* CCISS_DEBUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366
3367 cciss_getgeometry(i);
3368
3369 cciss_scsi_setup(i);
3370
3371 /* Turn the interrupts on so we can service requests */
3372 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3373
3374 cciss_procinit(i);
Mike Miller92c4231a2006-12-06 20:35:06 -08003375
3376 hba[i]->cciss_max_sectors = 2048;
3377
Mike Millerd6dbf422005-09-21 09:55:32 -07003378 hba[i]->busy_initializing = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379
Mike Miller799202c2006-12-06 20:35:12 -08003380 do {
Mike Millerad2b9312005-07-28 01:07:31 -07003381 drive_info_struct *drv = &(hba[i]->drv[j]);
3382 struct gendisk *disk = hba[i]->gendisk[j];
Jens Axboe165125e2007-07-24 09:28:11 +02003383 struct request_queue *q;
Mike Miller799202c2006-12-06 20:35:12 -08003384
3385 /* Check if the disk was allocated already */
3386 if (!disk){
3387 hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
3388 disk = hba[i]->gendisk[j];
3389 }
3390
3391 /* Check that the disk was able to be allocated */
3392 if (!disk) {
3393 printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
3394 goto clean4;
3395 }
Mike Millerad2b9312005-07-28 01:07:31 -07003396
3397 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3398 if (!q) {
3399 printk(KERN_ERR
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003400 "cciss: unable to allocate queue for disk %d\n",
3401 j);
Mike Miller799202c2006-12-06 20:35:12 -08003402 goto clean4;
Mike Millerad2b9312005-07-28 01:07:31 -07003403 }
3404 drv->queue = q;
3405
3406 q->backing_dev_info.ra_pages = READ_AHEAD;
Jens Axboea9925a02006-01-09 16:04:06 +01003407 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003408
Jens Axboea9925a02006-01-09 16:04:06 +01003409 /* This is a hardware imposed limit. */
3410 blk_queue_max_hw_segments(q, MAXSGENTRIES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411
Jens Axboea9925a02006-01-09 16:04:06 +01003412 /* This is a limit in the driver and could be eliminated. */
3413 blk_queue_max_phys_segments(q, MAXSGENTRIES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003414
Mike Miller92c4231a2006-12-06 20:35:06 -08003415 blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
Jens Axboea9925a02006-01-09 16:04:06 +01003416
3417 blk_queue_softirq_done(q, cciss_softirq_done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418
Mike Millerad2b9312005-07-28 01:07:31 -07003419 q->queuedata = hba[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003420 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421 disk->major = hba[i]->major;
3422 disk->first_minor = j << NWD_SHIFT;
3423 disk->fops = &cciss_fops;
Mike Millerad2b9312005-07-28 01:07:31 -07003424 disk->queue = q;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425 disk->private_data = drv;
Greg Kroah-Hartman27c0ff82006-04-27 15:46:39 -07003426 disk->driverfs_dev = &pdev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 /* we must register the controller even if no disks exist */
3428 /* this is for the online array utilities */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003429 if (!drv->heads && j)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 continue;
Mike Millerad2b9312005-07-28 01:07:31 -07003431 blk_queue_hardsect_size(q, drv->block_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432 set_capacity(disk, drv->nr_blocks);
3433 add_disk(disk);
Mike Miller799202c2006-12-06 20:35:12 -08003434 j++;
3435 } while (j <= hba[i]->highest_lun);
Mike Millerad2b9312005-07-28 01:07:31 -07003436
Bjorn Helgaase2019b52006-06-25 05:49:05 -07003437 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003439 clean4:
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003440#ifdef CONFIG_CISS_SCSI_TAPE
Andrew Morton1acc0b02006-01-04 18:30:03 -08003441 kfree(hba[i]->scsi_rejects.complete);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003442#endif
Jesper Juhl6044ec82005-11-07 01:01:32 -08003443 kfree(hba[i]->cmd_pool_bits);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003444 if (hba[i]->cmd_pool)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445 pci_free_consistent(hba[i]->pdev,
Mike Millerf8806322006-12-06 20:35:01 -08003446 hba[i]->nr_cmds * sizeof(CommandList_struct),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003447 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3448 if (hba[i]->errinfo_pool)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 pci_free_consistent(hba[i]->pdev,
Mike Millerf8806322006-12-06 20:35:01 -08003450 hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003451 hba[i]->errinfo_pool,
3452 hba[i]->errinfo_pool_dhandle);
Mike Millerfb86a352006-01-08 01:03:50 -08003453 free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003454 clean2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455 unregister_blkdev(hba[i]->major, hba[i]->devname);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003456 clean1:
Mike Miller1f8ef382005-09-13 01:25:21 -07003457 hba[i]->busy_initializing = 0;
Mike Miller799202c2006-12-06 20:35:12 -08003458 /* cleanup any queues that may have been initialized */
3459 for (j=0; j <= hba[i]->highest_lun; j++){
3460 drive_info_struct *drv = &(hba[i]->drv[j]);
3461 if (drv->queue)
3462 blk_cleanup_queue(drv->queue);
3463 }
Mike Miller872225c2006-12-13 00:34:22 -08003464 /*
3465 * Deliberately omit pci_disable_device(): it does something nasty to
3466 * Smart Array controllers that pci_enable_device does not undo
3467 */
Mike Miller799202c2006-12-06 20:35:12 -08003468 pci_release_regions(pdev);
Mike Miller799202c2006-12-06 20:35:12 -08003469 pci_set_drvdata(pdev, NULL);
Patrick McHardy61808c22006-03-23 02:59:24 -08003470 free_hba(i);
Bjorn Helgaase2019b52006-06-25 05:49:05 -07003471 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472}
3473
Gerald Brittone9ca75b2007-05-14 13:53:01 -04003474static void cciss_shutdown(struct pci_dev *pdev)
3475{
3476 ctlr_info_t *tmp_ptr;
3477 int i;
3478 char flush_buf[4];
3479 int return_code;
3480
3481 tmp_ptr = pci_get_drvdata(pdev);
3482 if (tmp_ptr == NULL)
3483 return;
3484 i = tmp_ptr->ctlr;
3485 if (hba[i] == NULL)
3486 return;
3487
3488 /* Turn board interrupts off and send the flush cache command */
3489 /* sendcmd will turn off interrupt, and send the flush...
3490 * To write all data in the battery backed cache to disks */
3491 memset(flush_buf, 0, 4);
3492 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3493 TYPE_CMD);
3494 if (return_code == IO_OK) {
3495 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
3496 } else {
3497 printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
3498 }
3499 free_irq(hba[i]->intr[2], hba[i]);
3500}
3501
3502static void __devexit cciss_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503{
3504 ctlr_info_t *tmp_ptr;
3505 int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003507 if (pci_get_drvdata(pdev) == NULL) {
3508 printk(KERN_ERR "cciss: Unable to remove device \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 return;
3510 }
3511 tmp_ptr = pci_get_drvdata(pdev);
3512 i = tmp_ptr->ctlr;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003513 if (hba[i] == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 printk(KERN_ERR "cciss: device appears to "
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003515 "already be removed \n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 return;
3517 }
Bjorn Helgaasb6550772007-04-11 23:28:43 -07003518
3519 remove_proc_entry(hba[i]->devname, proc_cciss);
3520 unregister_blkdev(hba[i]->major, hba[i]->devname);
3521
3522 /* remove it from the disk list */
3523 for (j = 0; j < CISS_MAX_LUN; j++) {
3524 struct gendisk *disk = hba[i]->gendisk[j];
3525 if (disk) {
Jens Axboe165125e2007-07-24 09:28:11 +02003526 struct request_queue *q = disk->queue;
Bjorn Helgaasb6550772007-04-11 23:28:43 -07003527
3528 if (disk->flags & GENHD_FL_UP)
3529 del_gendisk(disk);
3530 if (q)
3531 blk_cleanup_queue(q);
3532 }
3533 }
3534
3535 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3536
Gerald Brittone9ca75b2007-05-14 13:53:01 -04003537 cciss_shutdown(pdev);
Mike Millerfb86a352006-01-08 01:03:50 -08003538
3539#ifdef CONFIG_PCI_MSI
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003540 if (hba[i]->msix_vector)
3541 pci_disable_msix(hba[i]->pdev);
3542 else if (hba[i]->msi_vector)
3543 pci_disable_msi(hba[i]->pdev);
3544#endif /* CONFIG_PCI_MSI */
Mike Millerfb86a352006-01-08 01:03:50 -08003545
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 iounmap(hba[i]->vaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003547
Mike Millerf8806322006-12-06 20:35:01 -08003548 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(CommandList_struct),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
Mike Millerf8806322006-12-06 20:35:01 -08003550 pci_free_consistent(hba[i]->pdev, hba[i]->nr_cmds * sizeof(ErrorInfo_struct),
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003551 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003552 kfree(hba[i]->cmd_pool_bits);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06003553#ifdef CONFIG_CISS_SCSI_TAPE
3554 kfree(hba[i]->scsi_rejects.complete);
3555#endif
Mike Miller872225c2006-12-13 00:34:22 -08003556 /*
3557 * Deliberately omit pci_disable_device(): it does something nasty to
3558 * Smart Array controllers that pci_enable_device does not undo
3559 */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003560 pci_release_regions(pdev);
Bjorn Helgaas4e570302006-06-25 05:49:02 -07003561 pci_set_drvdata(pdev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003562 free_hba(i);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003563}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564
3565static struct pci_driver cciss_pci_driver = {
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003566 .name = "cciss",
3567 .probe = cciss_init_one,
3568 .remove = __devexit_p(cciss_remove_one),
3569 .id_table = cciss_pci_device_id, /* id_table */
Gerald Brittone9ca75b2007-05-14 13:53:01 -04003570 .shutdown = cciss_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571};
3572
3573/*
3574 * This is it. Register the PCI driver information for the cards we control
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003575 * the OS will call our registered routines when it finds one of our cards.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576 */
3577static int __init cciss_init(void)
3578{
3579 printk(KERN_INFO DRIVER_NAME "\n");
3580
3581 /* Register for our PCI devices */
Richard Knutsson9bfab8c2005-11-30 00:59:34 +01003582 return pci_register_driver(&cciss_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583}
3584
3585static void __exit cciss_cleanup(void)
3586{
3587 int i;
3588
3589 pci_unregister_driver(&cciss_pci_driver);
3590 /* double check that all controller entrys have been removed */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003591 for (i = 0; i < MAX_CTLR; i++) {
3592 if (hba[i] != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 printk(KERN_WARNING "cciss: had to remove"
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003594 " controller %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 cciss_remove_one(hba[i]->pdev);
3596 }
3597 }
3598 remove_proc_entry("cciss", proc_root_driver);
3599}
3600
Mike Miller33079b22005-09-13 01:25:22 -07003601static void fail_all_cmds(unsigned long ctlr)
3602{
3603 /* If we get here, the board is apparently dead. */
3604 ctlr_info_t *h = hba[ctlr];
3605 CommandList_struct *c;
3606 unsigned long flags;
3607
3608 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003609 h->alive = 0; /* the controller apparently died... */
Mike Miller33079b22005-09-13 01:25:22 -07003610
3611 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3612
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003613 pci_disable_device(h->pdev); /* Make sure it is really dead. */
Mike Miller33079b22005-09-13 01:25:22 -07003614
3615 /* move everything off the request queue onto the completed queue */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003616 while ((c = h->reqQ) != NULL) {
Mike Miller33079b22005-09-13 01:25:22 -07003617 removeQ(&(h->reqQ), c);
3618 h->Qdepth--;
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003619 addQ(&(h->cmpQ), c);
Mike Miller33079b22005-09-13 01:25:22 -07003620 }
3621
3622 /* Now, fail everything on the completed queue with a HW error */
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003623 while ((c = h->cmpQ) != NULL) {
Mike Miller33079b22005-09-13 01:25:22 -07003624 removeQ(&h->cmpQ, c);
3625 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3626 if (c->cmd_type == CMD_RWREQ) {
3627 complete_command(h, c, 0);
3628 } else if (c->cmd_type == CMD_IOCTL_PEND)
3629 complete(c->waiting);
3630#ifdef CONFIG_CISS_SCSI_TAPE
Bjorn Helgaas7c832832006-06-25 05:49:06 -07003631 else if (c->cmd_type == CMD_SCSI)
3632 complete_scsi_command(c, 0, 0);
Mike Miller33079b22005-09-13 01:25:22 -07003633#endif
3634 }
3635 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3636 return;
3637}
3638
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639module_init(cciss_init);
3640module_exit(cciss_cleanup);