blob: e820b68d2f6cd4d74382b85b5e020069294f00f3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Mike Millerbd4f36d2007-10-24 10:30:34 +02002 * Disk Array driver for HP Smart Array controllers, SCSI Tape module.
3 * (C) Copyright 2001, 2007 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
Mike Millerbd4f36d2007-10-24 10:30:34 +02007 * the Free Software Foundation; version 2 of the License.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Mike Millerbd4f36d2007-10-24 10:30:34 +020011 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
Mike Millerbd4f36d2007-10-24 10:30:34 +020016 * Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
17 * 02111-1307, USA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 *
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
20 *
21 * Author: Stephen M. Cameron
22 */
23#ifdef CONFIG_CISS_SCSI_TAPE
24
25/* Here we have code to present the driver as a scsi driver
26 as it is simultaneously presented as a block driver. The
27 reason for doing this is to allow access to SCSI tape drives
28 through the array controller. Note in particular, neither
29 physical nor logical disks are presented through the scsi layer. */
30
Tim Schmielau4e57b682005-10-30 15:03:48 -080031#include <linux/timer.h>
32#include <linux/completion.h>
33#include <linux/slab.h>
34#include <linux/string.h>
35
Arun Sharma600634972011-07-26 16:09:06 -070036#include <linux/atomic.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080037
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <scsi/scsi_cmnd.h>
39#include <scsi/scsi_device.h>
40#include <scsi/scsi_host.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include "cciss_scsi.h"
43
mike.miller@hp.com3da8b712005-11-04 12:30:37 -060044#define CCISS_ABORT_MSG 0x00
45#define CCISS_RESET_MSG 0x01
46
Stephen M. Cameronf70dba82010-07-19 13:46:38 -050047static int fill_cmd(ctlr_info_t *h, CommandList_struct *c, __u8 cmd, void *buff,
Stephen M. Cameron88f627a2009-06-02 14:48:11 +020048 size_t size,
scameron@beardog.cca.cpqcorp.netb57695f2009-06-08 16:02:17 -050049 __u8 page_code, unsigned char *scsi3addr,
Stephen M. Cameron88f627a2009-06-02 14:48:11 +020050 int cmd_type);
51
Stephen M. Cameron6b4d96b2010-07-19 13:46:43 -050052static CommandList_struct *cmd_alloc(ctlr_info_t *h);
53static CommandList_struct *cmd_special_alloc(ctlr_info_t *h);
54static void cmd_free(ctlr_info_t *h, CommandList_struct *c);
55static void cmd_special_free(ctlr_info_t *h, CommandList_struct *c);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57static int cciss_scsi_proc_info(
58 struct Scsi_Host *sh,
59 char *buffer, /* data buffer */
60 char **start, /* where data in buffer starts */
61 off_t offset, /* offset from start of imaginary file */
62 int length, /* length of data in buffer */
63 int func); /* 0 == read, 1 == write */
64
Jeff Garzikf2812332010-11-16 02:10:29 -050065static int cciss_scsi_queue_command (struct Scsi_Host *h,
66 struct scsi_cmnd *cmd);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -060067static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
68static int cciss_eh_abort_handler(struct scsi_cmnd *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
71 { .name = "cciss0", .ndevices = 0 },
72 { .name = "cciss1", .ndevices = 0 },
73 { .name = "cciss2", .ndevices = 0 },
74 { .name = "cciss3", .ndevices = 0 },
75 { .name = "cciss4", .ndevices = 0 },
76 { .name = "cciss5", .ndevices = 0 },
77 { .name = "cciss6", .ndevices = 0 },
78 { .name = "cciss7", .ndevices = 0 },
79};
80
81static struct scsi_host_template cciss_driver_template = {
82 .module = THIS_MODULE,
83 .name = "cciss",
84 .proc_name = "cciss",
85 .proc_info = cciss_scsi_proc_info,
86 .queuecommand = cciss_scsi_queue_command,
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 .this_id = 7,
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 .cmd_per_lun = 1,
89 .use_clustering = DISABLE_CLUSTERING,
mike.miller@hp.com3da8b712005-11-04 12:30:37 -060090 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
91 .eh_device_reset_handler= cciss_eh_device_reset_handler,
92 .eh_abort_handler = cciss_eh_abort_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -070093};
94
95#pragma pack(1)
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -060096
Mike Miller5e216152010-06-02 12:58:06 -070097#define SCSI_PAD_32 8
98#define SCSI_PAD_64 8
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -060099
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100struct cciss_scsi_cmd_stack_elem_t {
101 CommandList_struct cmd;
102 ErrorInfo_struct Err;
103 __u32 busaddr;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600104 int cmdindex;
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -0600105 u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106};
107
108#pragma pack()
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#pragma pack(1)
111struct cciss_scsi_cmd_stack_t {
112 struct cciss_scsi_cmd_stack_elem_t *pool;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500113 struct cciss_scsi_cmd_stack_elem_t **elem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 dma_addr_t cmd_pool_handle;
115 int top;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500116 int nelems;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117};
118#pragma pack()
119
120struct cciss_scsi_adapter_data_t {
121 struct Scsi_Host *scsi_host;
122 struct cciss_scsi_cmd_stack_t cmd_stack;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600123 SGDescriptor_struct **cmd_sg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 int registered;
125 spinlock_t lock; // to protect ccissscsi[ctlr];
126};
127
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500128#define CPQ_TAPE_LOCK(h, flags) spin_lock_irqsave( \
129 &h->scsi_ctlr->lock, flags);
130#define CPQ_TAPE_UNLOCK(h, flags) spin_unlock_irqrestore( \
131 &h->scsi_ctlr->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
133static CommandList_struct *
134scsi_cmd_alloc(ctlr_info_t *h)
135{
136 /* assume only one process in here at a time, locking done by caller. */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500137 /* use h->lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 /* might be better to rewrite how we allocate scsi commands in a way that */
139 /* needs no locking at all. */
140
141 /* take the top memory chunk off the stack and return it, if any. */
142 struct cciss_scsi_cmd_stack_elem_t *c;
143 struct cciss_scsi_adapter_data_t *sa;
144 struct cciss_scsi_cmd_stack_t *stk;
145 u64bit temp64;
146
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600147 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 stk = &sa->cmd_stack;
149
150 if (stk->top < 0)
151 return NULL;
152 c = stk->elem[stk->top];
153 /* memset(c, 0, sizeof(*c)); */
154 memset(&c->cmd, 0, sizeof(c->cmd));
155 memset(&c->Err, 0, sizeof(c->Err));
156 /* set physical addr of cmd and addr of scsi parameters */
157 c->cmd.busaddr = c->busaddr;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600158 c->cmd.cmdindex = c->cmdindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 /* (__u32) (stk->cmd_pool_handle +
160 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
161
162 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
163 /* (__u64) (stk->cmd_pool_handle +
164 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
165 sizeof(CommandList_struct)); */
166 stk->top--;
167 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
168 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
169 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
170
171 c->cmd.ctlr = h->ctlr;
172 c->cmd.err_info = &c->Err;
173
174 return (CommandList_struct *) c;
175}
176
177static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500178scsi_cmd_free(ctlr_info_t *h, CommandList_struct *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
180 /* assume only one process in here at a time, locking done by caller. */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500181 /* use h->lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 /* drop the free memory chunk on top of the stack. */
183
184 struct cciss_scsi_adapter_data_t *sa;
185 struct cciss_scsi_cmd_stack_t *stk;
186
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600187 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 stk = &sa->cmd_stack;
Dan Carpenter713b6862010-06-01 12:17:48 +0200189 stk->top++;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500190 if (stk->top >= stk->nelems) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500191 dev_err(&h->pdev->dev,
192 "scsi_cmd_free called too many times.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 BUG();
194 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500195 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) c;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196}
197
198static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500199scsi_cmd_stack_setup(ctlr_info_t *h, struct cciss_scsi_adapter_data_t *sa)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 int i;
202 struct cciss_scsi_cmd_stack_t *stk;
203 size_t size;
204
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500205 stk = &sa->cmd_stack;
206 stk->nelems = cciss_tape_cmds + 2;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500207 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(h,
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500208 h->chainsize, stk->nelems);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500209 if (!sa->cmd_sg_list && h->chainsize > 0)
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600210 return -ENOMEM;
211
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500212 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -0600214 /* Check alignment, see cciss_cmd.h near CommandList_struct def. */
215 BUILD_BUG_ON((sizeof(*stk->pool) % COMMANDLIST_ALIGNMENT) != 0);
216 /* pci_alloc_consistent guarantees 32-bit DMA address will be used */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500218 pci_alloc_consistent(h->pdev, size, &stk->cmd_pool_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220 if (stk->pool == NULL) {
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600222 sa->cmd_sg_list = NULL;
223 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 }
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500225 stk->elem = kmalloc(sizeof(stk->elem[0]) * stk->nelems, GFP_KERNEL);
226 if (!stk->elem) {
227 pci_free_consistent(h->pdev, size, stk->pool,
228 stk->cmd_pool_handle);
229 return -1;
230 }
231 for (i = 0; i < stk->nelems; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 stk->elem[i] = &stk->pool[i];
233 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
234 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600235 stk->elem[i]->cmdindex = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500237 stk->top = stk->nelems-1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 return 0;
239}
240
241static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500242scsi_cmd_stack_free(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
244 struct cciss_scsi_adapter_data_t *sa;
245 struct cciss_scsi_cmd_stack_t *stk;
246 size_t size;
247
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500248 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 stk = &sa->cmd_stack;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500250 if (stk->top != stk->nelems-1) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500251 dev_warn(&h->pdev->dev,
252 "bug: %d scsi commands are still outstanding.\n",
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500253 stk->nelems - stk->top);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500255 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * stk->nelems;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500257 pci_free_consistent(h->pdev, size, stk->pool, stk->cmd_pool_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 stk->pool = NULL;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500259 cciss_free_sg_chain_blocks(sa->cmd_sg_list, stk->nelems);
260 kfree(stk->elem);
261 stk->elem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
Grant Coady400bb232005-11-15 00:09:20 -0800264#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265static int xmargin=8;
266static int amargin=60;
267
268static void
269print_bytes (unsigned char *c, int len, int hex, int ascii)
270{
271
272 int i;
273 unsigned char *x;
274
275 if (hex)
276 {
277 x = c;
278 for (i=0;i<len;i++)
279 {
280 if ((i % xmargin) == 0 && i>0) printk("\n");
281 if ((i % xmargin) == 0) printk("0x%04x:", i);
282 printk(" %02x", *x);
283 x++;
284 }
285 printk("\n");
286 }
287 if (ascii)
288 {
289 x = c;
290 for (i=0;i<len;i++)
291 {
292 if ((i % amargin) == 0 && i>0) printk("\n");
293 if ((i % amargin) == 0) printk("0x%04x:", i);
294 if (*x > 26 && *x < 128) printk("%c", *x);
295 else printk(".");
296 x++;
297 }
298 printk("\n");
299 }
300}
301
302static void
303print_cmd(CommandList_struct *cp)
304{
305 printk("queue:%d\n", cp->Header.ReplyQueue);
306 printk("sglist:%d\n", cp->Header.SGList);
307 printk("sgtot:%d\n", cp->Header.SGTotal);
308 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
309 cp->Header.Tag.lower);
310 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
311 cp->Header.LUN.LunAddrBytes[0],
312 cp->Header.LUN.LunAddrBytes[1],
313 cp->Header.LUN.LunAddrBytes[2],
314 cp->Header.LUN.LunAddrBytes[3],
315 cp->Header.LUN.LunAddrBytes[4],
316 cp->Header.LUN.LunAddrBytes[5],
317 cp->Header.LUN.LunAddrBytes[6],
318 cp->Header.LUN.LunAddrBytes[7]);
319 printk("CDBLen:%d\n", cp->Request.CDBLen);
320 printk("Type:%d\n",cp->Request.Type.Type);
321 printk("Attr:%d\n",cp->Request.Type.Attribute);
322 printk(" Dir:%d\n",cp->Request.Type.Direction);
323 printk("Timeout:%d\n",cp->Request.Timeout);
324 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
325 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
326 cp->Request.CDB[0], cp->Request.CDB[1],
327 cp->Request.CDB[2], cp->Request.CDB[3],
328 cp->Request.CDB[4], cp->Request.CDB[5],
329 cp->Request.CDB[6], cp->Request.CDB[7],
330 cp->Request.CDB[8], cp->Request.CDB[9],
331 cp->Request.CDB[10], cp->Request.CDB[11],
332 cp->Request.CDB[12], cp->Request.CDB[13],
333 cp->Request.CDB[14], cp->Request.CDB[15]),
334 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
335 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
336 cp->ErrDesc.Len);
337 printk("sgs..........Errorinfo:\n");
338 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
339 printk("senselen:%d\n", cp->err_info->SenseLen);
340 printk("cmd status:%d\n", cp->err_info->CommandStatus);
341 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
342 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
343 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
344 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
345
346}
347
348#endif
349
350static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500351find_bus_target_lun(ctlr_info_t *h, int *bus, int *target, int *lun)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
353 /* finds an unused bus, target, lun for a new device */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500354 /* assumes h->scsi_ctlr->lock is held */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 int i, found=0;
356 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
357
358 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
359
360 target_taken[SELF_SCSI_ID] = 1;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500361 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++)
362 target_taken[ccissscsi[h->ctlr].dev[i].target] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500364 for (i = 0; i < CCISS_MAX_SCSI_DEVS_PER_HBA; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (!target_taken[i]) {
366 *bus = 0; *target=i; *lun = 0; found=1;
367 break;
368 }
369 }
370 return (!found);
371}
Mike Millerf4a93bc2008-08-04 11:54:53 +0200372struct scsi2map {
373 char scsi3addr[8];
374 int bus, target, lun;
375};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500378cciss_scsi_add_entry(ctlr_info_t *h, int hostno,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700379 struct cciss_scsi_dev_t *device,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200380 struct scsi2map *added, int *nadded)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500382 /* assumes h->scsi_ctlr->lock is held */
383 int n = ccissscsi[h->ctlr].ndevices;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct cciss_scsi_dev_t *sd;
Mike Miller935dc8d2008-08-04 11:54:54 +0200385 int i, bus, target, lun;
386 unsigned char addr1[8], addr2[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500389 dev_warn(&h->pdev->dev, "Too many devices, "
390 "some will be inaccessible.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 return -1;
392 }
Mike Millerf4a93bc2008-08-04 11:54:53 +0200393
Mike Miller935dc8d2008-08-04 11:54:54 +0200394 bus = target = -1;
395 lun = 0;
396 /* Is this device a non-zero lun of a multi-lun device */
397 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700398 if (device->scsi3addr[4] != 0) {
Mike Miller935dc8d2008-08-04 11:54:54 +0200399 /* Search through our list and find the device which */
400 /* has the same 8 byte LUN address, excepting byte 4. */
401 /* Assign the same bus and target for this new LUN. */
402 /* Use the logical unit number from the firmware. */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700403 memcpy(addr1, device->scsi3addr, 8);
Mike Miller935dc8d2008-08-04 11:54:54 +0200404 addr1[4] = 0;
405 for (i = 0; i < n; i++) {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500406 sd = &ccissscsi[h->ctlr].dev[i];
Mike Miller935dc8d2008-08-04 11:54:54 +0200407 memcpy(addr2, sd->scsi3addr, 8);
408 addr2[4] = 0;
409 /* differ only in byte 4? */
410 if (memcmp(addr1, addr2, 8) == 0) {
411 bus = sd->bus;
412 target = sd->target;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700413 lun = device->scsi3addr[4];
Mike Miller935dc8d2008-08-04 11:54:54 +0200414 break;
415 }
416 }
417 }
418
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500419 sd = &ccissscsi[h->ctlr].dev[n];
Mike Miller935dc8d2008-08-04 11:54:54 +0200420 if (lun == 0) {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500421 if (find_bus_target_lun(h,
Mike Miller935dc8d2008-08-04 11:54:54 +0200422 &sd->bus, &sd->target, &sd->lun) != 0)
423 return -1;
424 } else {
425 sd->bus = bus;
426 sd->target = target;
427 sd->lun = lun;
428 }
Mike Millerf4a93bc2008-08-04 11:54:53 +0200429 added[*nadded].bus = sd->bus;
430 added[*nadded].target = sd->target;
431 added[*nadded].lun = sd->lun;
432 (*nadded)++;
433
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700434 memcpy(sd->scsi3addr, device->scsi3addr, 8);
435 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
436 memcpy(sd->revision, device->revision, sizeof(sd->revision));
437 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
438 sd->devtype = device->devtype;
439
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500440 ccissscsi[h->ctlr].ndevices++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 /* initially, (before registering with scsi layer) we don't
443 know our hostno and we don't want to print anything first
444 time anyway (the scsi layer's inquiries will show that info) */
445 if (hostno != -1)
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500446 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
447 scsi_device_type(sd->devtype), hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 sd->bus, sd->target, sd->lun);
449 return 0;
450}
451
452static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500453cciss_scsi_remove_entry(ctlr_info_t *h, int hostno, int entry,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200454 struct scsi2map *removed, int *nremoved)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500456 /* assumes h->ctlr]->scsi_ctlr->lock is held */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 int i;
458 struct cciss_scsi_dev_t sd;
459
460 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500461 sd = ccissscsi[h->ctlr].dev[entry];
Mike Millerf4a93bc2008-08-04 11:54:53 +0200462 removed[*nremoved].bus = sd.bus;
463 removed[*nremoved].target = sd.target;
464 removed[*nremoved].lun = sd.lun;
465 (*nremoved)++;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500466 for (i = entry; i < ccissscsi[h->ctlr].ndevices-1; i++)
467 ccissscsi[h->ctlr].dev[i] = ccissscsi[h->ctlr].dev[i+1];
468 ccissscsi[h->ctlr].ndevices--;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500469 dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
470 scsi_device_type(sd.devtype), hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 sd.bus, sd.target, sd.lun);
472}
473
474
475#define SCSI3ADDR_EQ(a,b) ( \
476 (a)[7] == (b)[7] && \
477 (a)[6] == (b)[6] && \
478 (a)[5] == (b)[5] && \
479 (a)[4] == (b)[4] && \
480 (a)[3] == (b)[3] && \
481 (a)[2] == (b)[2] && \
482 (a)[1] == (b)[1] && \
483 (a)[0] == (b)[0])
484
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500485static void fixup_botched_add(ctlr_info_t *h, char *scsi3addr)
Mike Millerf4a93bc2008-08-04 11:54:53 +0200486{
487 /* called when scsi_add_device fails in order to re-adjust */
488 /* ccissscsi[] to match the mid layer's view. */
489 unsigned long flags;
490 int i, j;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500491 CPQ_TAPE_LOCK(h, flags);
492 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
Mike Millerf4a93bc2008-08-04 11:54:53 +0200493 if (memcmp(scsi3addr,
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500494 ccissscsi[h->ctlr].dev[i].scsi3addr, 8) == 0) {
495 for (j = i; j < ccissscsi[h->ctlr].ndevices-1; j++)
496 ccissscsi[h->ctlr].dev[j] =
497 ccissscsi[h->ctlr].dev[j+1];
498 ccissscsi[h->ctlr].ndevices--;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200499 break;
500 }
501 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500502 CPQ_TAPE_UNLOCK(h, flags);
Mike Millerf4a93bc2008-08-04 11:54:53 +0200503}
504
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700505static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
506 struct cciss_scsi_dev_t *dev2)
507{
508 return dev1->devtype == dev2->devtype &&
509 memcmp(dev1->scsi3addr, dev2->scsi3addr,
510 sizeof(dev1->scsi3addr)) == 0 &&
511 memcmp(dev1->device_id, dev2->device_id,
512 sizeof(dev1->device_id)) == 0 &&
513 memcmp(dev1->vendor, dev2->vendor,
514 sizeof(dev1->vendor)) == 0 &&
515 memcmp(dev1->model, dev2->model,
516 sizeof(dev1->model)) == 0 &&
517 memcmp(dev1->revision, dev2->revision,
518 sizeof(dev1->revision)) == 0;
519}
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500522adjust_cciss_scsi_table(ctlr_info_t *h, int hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 struct cciss_scsi_dev_t sd[], int nsds)
524{
525 /* sd contains scsi3 addresses and devtypes, but
526 bus target and lun are not filled in. This funciton
527 takes what's in sd to be the current and adjusts
528 ccissscsi[] to be in line with what's in sd. */
529
530 int i,j, found, changes=0;
531 struct cciss_scsi_dev_t *csd;
532 unsigned long flags;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200533 struct scsi2map *added, *removed;
534 int nadded, nremoved;
535 struct Scsi_Host *sh = NULL;
536
537 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
538 GFP_KERNEL);
539 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
540 GFP_KERNEL);
541
542 if (!added || !removed) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500543 dev_warn(&h->pdev->dev,
544 "Out of memory in adjust_cciss_scsi_table\n");
Mike Millerf4a93bc2008-08-04 11:54:53 +0200545 goto free_and_out;
546 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500548 CPQ_TAPE_LOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Mike Millerf4a93bc2008-08-04 11:54:53 +0200550 if (hostno != -1) /* if it's not the first time... */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500551 sh = h->scsi_ctlr->scsi_host;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* find any devices in ccissscsi[] that are not in
554 sd[] and remove them from ccissscsi[] */
555
556 i = 0;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200557 nremoved = 0;
558 nadded = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500559 while (i < ccissscsi[h->ctlr].ndevices) {
560 csd = &ccissscsi[h->ctlr].dev[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 found=0;
562 for (j=0;j<nsds;j++) {
563 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
564 csd->scsi3addr)) {
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700565 if (device_is_the_same(&sd[j], csd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 found=2;
567 else
568 found=1;
569 break;
570 }
571 }
572
573 if (found == 0) { /* device no longer present. */
574 changes++;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500575 cciss_scsi_remove_entry(h, hostno, i,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200576 removed, &nremoved);
577 /* remove ^^^, hence i not incremented */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700578 } else if (found == 1) { /* device is different in some way */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 changes++;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500580 dev_info(&h->pdev->dev,
581 "device c%db%dt%dl%d has changed.\n",
582 hostno, csd->bus, csd->target, csd->lun);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500583 cciss_scsi_remove_entry(h, hostno, i,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200584 removed, &nremoved);
585 /* remove ^^^, hence i not incremented */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500586 if (cciss_scsi_add_entry(h, hostno, &sd[j],
Mike Millerf4a93bc2008-08-04 11:54:53 +0200587 added, &nadded) != 0)
588 /* we just removed one, so add can't fail. */
589 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 csd->devtype = sd[j].devtype;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700591 memcpy(csd->device_id, sd[j].device_id,
592 sizeof(csd->device_id));
593 memcpy(csd->vendor, sd[j].vendor,
594 sizeof(csd->vendor));
595 memcpy(csd->model, sd[j].model,
596 sizeof(csd->model));
597 memcpy(csd->revision, sd[j].revision,
598 sizeof(csd->revision));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 } else /* device is same as it ever was, */
600 i++; /* so just move along. */
601 }
602
603 /* Now, make sure every device listed in sd[] is also
604 listed in ccissscsi[], adding them if they aren't found */
605
606 for (i=0;i<nsds;i++) {
607 found=0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500608 for (j = 0; j < ccissscsi[h->ctlr].ndevices; j++) {
609 csd = &ccissscsi[h->ctlr].dev[j];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
611 csd->scsi3addr)) {
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700612 if (device_is_the_same(&sd[i], csd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 found=2; /* found device */
614 else
615 found=1; /* found a bug. */
616 break;
617 }
618 }
619 if (!found) {
620 changes++;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500621 if (cciss_scsi_add_entry(h, hostno, &sd[i],
Mike Millerf4a93bc2008-08-04 11:54:53 +0200622 added, &nadded) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 break;
624 } else if (found == 1) {
625 /* should never happen... */
626 changes++;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500627 dev_warn(&h->pdev->dev,
628 "device unexpectedly changed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 /* but if it does happen, we just ignore that device */
630 }
631 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500632 CPQ_TAPE_UNLOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Mike Millerf4a93bc2008-08-04 11:54:53 +0200634 /* Don't notify scsi mid layer of any changes the first time through */
635 /* (or if there are no changes) scsi_scan_host will do it later the */
636 /* first time through. */
637 if (hostno == -1 || !changes)
638 goto free_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Mike Millerf4a93bc2008-08-04 11:54:53 +0200640 /* Notify scsi mid layer of any removed devices */
641 for (i = 0; i < nremoved; i++) {
642 struct scsi_device *sdev =
643 scsi_device_lookup(sh, removed[i].bus,
644 removed[i].target, removed[i].lun);
645 if (sdev != NULL) {
646 scsi_remove_device(sdev);
647 scsi_device_put(sdev);
648 } else {
649 /* We don't expect to get here. */
650 /* future cmds to this device will get selection */
651 /* timeout as if the device was gone. */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500652 dev_warn(&h->pdev->dev, "didn't find "
Mike Millerf4a93bc2008-08-04 11:54:53 +0200653 "c%db%dt%dl%d\n for removal.",
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500654 hostno, removed[i].bus,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200655 removed[i].target, removed[i].lun);
656 }
657 }
658
659 /* Notify scsi mid layer of any added devices */
660 for (i = 0; i < nadded; i++) {
661 int rc;
662 rc = scsi_add_device(sh, added[i].bus,
663 added[i].target, added[i].lun);
664 if (rc == 0)
665 continue;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500666 dev_warn(&h->pdev->dev, "scsi_add_device "
Mike Millerf4a93bc2008-08-04 11:54:53 +0200667 "c%db%dt%dl%d failed, device not added.\n",
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500668 hostno, added[i].bus, added[i].target, added[i].lun);
Mike Millerf4a93bc2008-08-04 11:54:53 +0200669 /* now we have to remove it from ccissscsi, */
670 /* since it didn't get added to scsi mid layer */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500671 fixup_botched_add(h, added[i].scsi3addr);
Mike Millerf4a93bc2008-08-04 11:54:53 +0200672 }
673
674free_and_out:
675 kfree(added);
676 kfree(removed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return 0;
678}
679
680static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500681lookup_scsi3addr(ctlr_info_t *h, int bus, int target, int lun, char *scsi3addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
683 int i;
684 struct cciss_scsi_dev_t *sd;
685 unsigned long flags;
686
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500687 CPQ_TAPE_LOCK(h, flags);
688 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
689 sd = &ccissscsi[h->ctlr].dev[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 if (sd->bus == bus &&
691 sd->target == target &&
692 sd->lun == lun) {
693 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500694 CPQ_TAPE_UNLOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 return 0;
696 }
697 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500698 CPQ_TAPE_UNLOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 return -1;
700}
701
702static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500703cciss_scsi_setup(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704{
705 struct cciss_scsi_adapter_data_t * shba;
706
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500707 ccissscsi[h->ctlr].ndevices = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 shba = (struct cciss_scsi_adapter_data_t *)
709 kmalloc(sizeof(*shba), GFP_KERNEL);
710 if (shba == NULL)
711 return;
712 shba->scsi_host = NULL;
713 spin_lock_init(&shba->lock);
714 shba->registered = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500715 if (scsi_cmd_stack_setup(h, shba) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 kfree(shba);
717 shba = NULL;
718 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500719 h->scsi_ctlr = shba;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 return;
721}
722
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500723static void complete_scsi_command(CommandList_struct *c, int timeout,
724 __u32 tag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
726 struct scsi_cmnd *cmd;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500727 ctlr_info_t *h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 ErrorInfo_struct *ei;
729
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500730 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
732 /* First, see if it was a message rather than a command */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500733 if (c->Request.Type.Type == TYPE_MSG) {
734 c->cmd_type = CMD_MSG_DONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 return;
736 }
737
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500738 cmd = (struct scsi_cmnd *) c->scsi_cmd;
739 h = hba[c->ctlr];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
FUJITA Tomonori41ce6392007-05-26 02:45:17 +0900741 scsi_dma_unmap(cmd);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500742 if (c->Header.SGTotal > h->max_cmd_sgentries)
743 cciss_unmap_sg_chain_block(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 cmd->result = (DID_OK << 16); /* host byte */
746 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
747 /* cmd->result |= (GOOD < 1); */ /* status byte */
748
749 cmd->result |= (ei->ScsiStatus);
750 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
751
752 /* copy the sense data whether we need to or not. */
753
754 memcpy(cmd->sense_buffer, ei->SenseInfo,
755 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
756 SCSI_SENSE_BUFFERSIZE :
757 ei->SenseLen);
FUJITA Tomonori41ce6392007-05-26 02:45:17 +0900758 scsi_set_resid(cmd, ei->ResidualCnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 if(ei->CommandStatus != 0)
761 { /* an error has occurred */
762 switch(ei->CommandStatus)
763 {
764 case CMD_TARGET_STATUS:
765 /* Pass it up to the upper layers... */
766 if( ei->ScsiStatus)
767 {
768#if 0
769 printk(KERN_WARNING "cciss: cmd %p "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500770 "has SCSI Status = %x\n",
771 c, ei->ScsiStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772#endif
Stephen M. Cameronb0e15f62009-11-12 12:49:45 -0600773 cmd->result |= (ei->ScsiStatus << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775 else { /* scsi status is zero??? How??? */
776
777 /* Ordinarily, this case should never happen, but there is a bug
778 in some released firmware revisions that allows it to happen
779 if, for example, a 4100 backplane loses power and the tape
780 drive is in it. We assume that it's a fatal error of some
781 kind because we can't show that it wasn't. We will make it
782 look like selection timeout since that is the most common
783 reason for this to occur, and it's severe enough. */
784
785 cmd->result = DID_NO_CONNECT << 16;
786 }
787 break;
788 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
789 break;
790 case CMD_DATA_OVERRUN:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500791 dev_warn(&h->pdev->dev, "%p has"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 " completed with data overrun "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500793 "reported\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 break;
795 case CMD_INVALID: {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500796 /* print_bytes(c, sizeof(*c), 1, 0);
797 print_cmd(c); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 /* We get CMD_INVALID if you address a non-existent tape drive instead
799 of a selection timeout (no response). You will see this if you yank
800 out a tape drive, then try to access it. This is kind of a shame
801 because it means that any other CMD_INVALID (e.g. driver bug) will
802 get interpreted as a missing target. */
803 cmd->result = DID_NO_CONNECT << 16;
804 }
805 break;
806 case CMD_PROTOCOL_ERR:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500807 dev_warn(&h->pdev->dev,
808 "%p has protocol error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 break;
810 case CMD_HARDWARE_ERR:
811 cmd->result = DID_ERROR << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500812 dev_warn(&h->pdev->dev,
813 "%p had hardware error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 break;
815 case CMD_CONNECTION_LOST:
816 cmd->result = DID_ERROR << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500817 dev_warn(&h->pdev->dev,
818 "%p had connection lost\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 break;
820 case CMD_ABORTED:
821 cmd->result = DID_ABORT << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500822 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 break;
824 case CMD_ABORT_FAILED:
825 cmd->result = DID_ERROR << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500826 dev_warn(&h->pdev->dev,
827 "%p reports abort failed\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 break;
829 case CMD_UNSOLICITED_ABORT:
830 cmd->result = DID_ABORT << 16;
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +0100831 dev_warn(&h->pdev->dev, "%p aborted due to an "
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500832 "unsolicited abort\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 break;
834 case CMD_TIMEOUT:
835 cmd->result = DID_TIME_OUT << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500836 dev_warn(&h->pdev->dev, "%p timedout\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 break;
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +0100838 case CMD_UNABORTABLE:
839 cmd->result = DID_ERROR << 16;
840 dev_warn(&h->pdev->dev, "c %p command "
841 "unabortable\n", c);
842 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 default:
844 cmd->result = DID_ERROR << 16;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500845 dev_warn(&h->pdev->dev,
846 "%p returned unknown status %x\n", c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 ei->CommandStatus);
848 }
849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 cmd->scsi_done(cmd);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500851 scsi_cmd_free(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
854static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500855cciss_scsi_detect(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
857 struct Scsi_Host *sh;
858 int error;
859
860 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
861 if (sh == NULL)
862 goto fail;
863 sh->io_port = 0; // good enough? FIXME,
864 sh->n_io_port = 0; // I don't think we use these two...
865 sh->this_id = SELF_SCSI_ID;
Stephen M. Cameron8a4ec672011-05-03 14:54:12 -0500866 sh->can_queue = cciss_tape_cmds;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500867 sh->sg_tablesize = h->maxsgentries;
Stephen M. Cameron79600aa2010-06-15 08:12:34 +0200868 sh->max_cmd_len = MAX_COMMAND_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870 ((struct cciss_scsi_adapter_data_t *)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500871 h->scsi_ctlr)->scsi_host = sh;
872 sh->hostdata[0] = (unsigned long) h;
873 sh->irq = h->intr[SIMPLE_MODE_INT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 sh->unique_id = sh->irq;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500875 error = scsi_add_host(sh, &h->pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (error)
877 goto fail_host_put;
878 scsi_scan_host(sh);
879 return 1;
880
881 fail_host_put:
882 scsi_host_put(sh);
883 fail:
884 return 0;
885}
886
887static void
888cciss_unmap_one(struct pci_dev *pdev,
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500889 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 size_t buflen,
891 int data_direction)
892{
893 u64bit addr64;
894
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500895 addr64.val32.lower = c->SG[0].Addr.lower;
896 addr64.val32.upper = c->SG[0].Addr.upper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
898}
899
900static void
901cciss_map_one(struct pci_dev *pdev,
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500902 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 unsigned char *buf,
904 size_t buflen,
905 int data_direction)
906{
907 __u64 addr64;
908
909 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500910 c->SG[0].Addr.lower =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500912 c->SG[0].Addr.upper =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500914 c->SG[0].Len = buflen;
915 c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
916 c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917}
918
919static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500920cciss_scsi_do_simple_cmd(ctlr_info_t *h,
921 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 unsigned char *scsi3addr,
923 unsigned char *cdb,
924 unsigned char cdblen,
925 unsigned char *buf, int bufsize,
926 int direction)
927{
Peter Zijlstra6e9a4732006-09-30 23:28:10 -0700928 DECLARE_COMPLETION_ONSTACK(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500930 c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
931 c->scsi_cmd = NULL;
932 c->Header.ReplyQueue = 0; /* unused in simple mode */
933 memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
934 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 // Fill in the request block...
936
937 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
938 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
939 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
940
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500941 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
942 memcpy(c->Request.CDB, cdb, cdblen);
943 c->Request.Timeout = 0;
944 c->Request.CDBLen = cdblen;
945 c->Request.Type.Type = TYPE_CMD;
946 c->Request.Type.Attribute = ATTR_SIMPLE;
947 c->Request.Type.Direction = direction;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948
949 /* Fill in the SG list and do dma mapping */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500950 cciss_map_one(h->pdev, c, (unsigned char *) buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 bufsize, DMA_FROM_DEVICE);
952
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500953 c->waiting = &wait;
954 enqueue_cmd_and_start_io(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 wait_for_completion(&wait);
956
957 /* undo the dma mapping */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500958 cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 return(0);
960}
961
962static void
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500963cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964{
965 ErrorInfo_struct *ei;
966
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500967 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 switch(ei->CommandStatus)
969 {
970 case CMD_TARGET_STATUS:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500971 dev_warn(&h->pdev->dev,
972 "cmd %p has completed with errors\n", c);
973 dev_warn(&h->pdev->dev,
974 "cmd %p has SCSI Status = %x\n",
975 c, ei->ScsiStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 if (ei->ScsiStatus == 0)
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500977 dev_warn(&h->pdev->dev,
978 "SCSI status is abnormally zero. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 "(probably indicates selection timeout "
980 "reported incorrectly due to a known "
981 "firmware bug, circa July, 2001.)\n");
982 break;
983 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500984 dev_info(&h->pdev->dev, "UNDERRUN\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 break;
986 case CMD_DATA_OVERRUN:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500987 dev_warn(&h->pdev->dev, "%p has"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 " completed with data overrun "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500989 "reported\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 break;
991 case CMD_INVALID: {
992 /* controller unfortunately reports SCSI passthru's */
993 /* to non-existent targets as invalid commands. */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500994 dev_warn(&h->pdev->dev,
995 "%p is reported invalid (probably means "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500996 "target device no longer present)\n", c);
997 /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
998 print_cmd(c); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000 break;
1001 case CMD_PROTOCOL_ERR:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001002 dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 break;
1004 case CMD_HARDWARE_ERR:
1005 /* cmd->result = DID_ERROR << 16; */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001006 dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 break;
1008 case CMD_CONNECTION_LOST:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001009 dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 break;
1011 case CMD_ABORTED:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001012 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 break;
1014 case CMD_ABORT_FAILED:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001015 dev_warn(&h->pdev->dev,
1016 "%p reports abort failed\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 break;
1018 case CMD_UNSOLICITED_ABORT:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001019 dev_warn(&h->pdev->dev,
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +01001020 "%p aborted due to an unsolicited abort\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 break;
1022 case CMD_TIMEOUT:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001023 dev_warn(&h->pdev->dev, "%p timedout\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 break;
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +01001025 case CMD_UNABORTABLE:
1026 dev_warn(&h->pdev->dev,
1027 "%p unabortable\n", c);
1028 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 default:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001030 dev_warn(&h->pdev->dev,
1031 "%p returned unknown status %x\n",
1032 c, ei->CommandStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 }
1034}
1035
1036static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001037cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001038 unsigned char page, unsigned char *buf,
1039 unsigned char bufsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040{
1041 int rc;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001042 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 char cdb[6];
1044 ErrorInfo_struct *ei;
1045 unsigned long flags;
1046
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001047 spin_lock_irqsave(&h->lock, flags);
1048 c = scsi_cmd_alloc(h);
1049 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001051 if (c == NULL) { /* trouble... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 printk("cmd_alloc returned NULL!\n");
1053 return -1;
1054 }
1055
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001056 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 cdb[0] = CISS_INQUIRY;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001059 cdb[1] = (page != 0);
1060 cdb[2] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 cdb[3] = 0;
Mike Miller47922d02005-09-13 01:25:25 -07001062 cdb[4] = bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 cdb[5] = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001064 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
Mike Miller47922d02005-09-13 01:25:25 -07001065 6, buf, bufsize, XFER_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
1067 if (rc != 0) return rc; /* something went wrong */
1068
1069 if (ei->CommandStatus != 0 &&
1070 ei->CommandStatus != CMD_DATA_UNDERRUN) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001071 cciss_scsi_interpret_error(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 rc = -1;
1073 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001074 spin_lock_irqsave(&h->lock, flags);
1075 scsi_cmd_free(h, c);
1076 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return rc;
1078}
1079
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001080/* Get the device id from inquiry page 0x83 */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001081static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001082 unsigned char *device_id, int buflen)
1083{
1084 int rc;
1085 unsigned char *buf;
1086
1087 if (buflen > 16)
1088 buflen = 16;
1089 buf = kzalloc(64, GFP_KERNEL);
1090 if (!buf)
1091 return -1;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001092 rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001093 if (rc == 0)
1094 memcpy(device_id, &buf[8], buflen);
1095 kfree(buf);
1096 return rc != 0;
1097}
1098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001100cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 ReportLunData_struct *buf, int bufsize)
1102{
1103 int rc;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001104 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 unsigned char cdb[12];
1106 unsigned char scsi3addr[8];
1107 ErrorInfo_struct *ei;
1108 unsigned long flags;
1109
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001110 spin_lock_irqsave(&h->lock, flags);
1111 c = scsi_cmd_alloc(h);
1112 spin_unlock_irqrestore(&h->lock, flags);
1113 if (c == NULL) { /* trouble... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 printk("cmd_alloc returned NULL!\n");
1115 return -1;
1116 }
1117
1118 memset(&scsi3addr[0], 0, 8); /* address the controller */
1119 cdb[0] = CISS_REPORT_PHYS;
1120 cdb[1] = 0;
1121 cdb[2] = 0;
1122 cdb[3] = 0;
1123 cdb[4] = 0;
1124 cdb[5] = 0;
1125 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1126 cdb[7] = (bufsize >> 16) & 0xFF;
1127 cdb[8] = (bufsize >> 8) & 0xFF;
1128 cdb[9] = bufsize & 0xFF;
1129 cdb[10] = 0;
1130 cdb[11] = 0;
1131
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001132 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 cdb, 12,
1134 (unsigned char *) buf,
1135 bufsize, XFER_READ);
1136
1137 if (rc != 0) return rc; /* something went wrong */
1138
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001139 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (ei->CommandStatus != 0 &&
1141 ei->CommandStatus != CMD_DATA_UNDERRUN) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001142 cciss_scsi_interpret_error(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 rc = -1;
1144 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001145 spin_lock_irqsave(&h->lock, flags);
1146 scsi_cmd_free(h, c);
1147 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 return rc;
1149}
1150
1151static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001152cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
1154 /* the idea here is we could get notified from /proc
1155 that some devices have changed, so we do a report
1156 physical luns cmd, and adjust our list of devices
1157 accordingly. (We can't rely on the scsi-mid layer just
1158 doing inquiries, because the "busses" that the scsi
1159 mid-layer probes are totally fabricated by this driver,
1160 so new devices wouldn't show up.
1161
1162 the scsi3addr's of devices won't change so long as the
1163 adapter is not reset. That means we can rescan and
1164 tell which devices we already know about, vs. new
1165 devices, vs. disappearing devices.
1166
1167 Also, if you yank out a tape drive, then put in a disk
1168 in it's place, (say, a configured volume from another
1169 array controller for instance) _don't_ poke this driver
1170 (so it thinks it's still a tape, but _do_ poke the scsi
1171 mid layer, so it does an inquiry... the scsi mid layer
1172 will see the physical disk. This would be bad. Need to
1173 think about how to prevent that. One idea would be to
1174 snoop all scsi responses and if an inquiry repsonse comes
1175 back that reports a disk, chuck it an return selection
1176 timeout instead and adjust our table... Not sure i like
1177 that though.
1178
1179 */
Mike Miller47922d02005-09-13 01:25:25 -07001180#define OBDR_TAPE_INQ_SIZE 49
1181#define OBDR_TAPE_SIG "$DR-10"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 ReportLunData_struct *ld_buff;
Mike Miller47922d02005-09-13 01:25:25 -07001183 unsigned char *inq_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 unsigned char scsi3addr[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 __u32 num_luns=0;
1186 unsigned char *ch;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001187 struct cciss_scsi_dev_t *currentsd, *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 int ncurrent=0;
1189 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1190 int i;
1191
Eric Sesterhenn06ff37f2006-03-08 11:21:52 +01001192 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
Mike Miller47922d02005-09-13 01:25:25 -07001193 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001194 currentsd = kzalloc(sizeof(*currentsd) *
1195 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1196 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1197 printk(KERN_ERR "cciss: out of memory\n");
1198 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001200 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001201 if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 ch = &ld_buff->LUNListLength[0];
1203 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1204 if (num_luns > CISS_MAX_PHYS_LUN) {
1205 printk(KERN_WARNING
1206 "cciss: Maximum physical LUNs (%d) exceeded. "
1207 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1208 num_luns - CISS_MAX_PHYS_LUN);
1209 num_luns = CISS_MAX_PHYS_LUN;
1210 }
1211 }
1212 else {
1213 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1214 goto out;
1215 }
1216
1217
1218 /* adjust our table of devices */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001219 for (i = 0; i < num_luns; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 /* for each physical lun, do an inquiry */
1221 if (ld_buff->LUN[i][3] & 0xC0) continue;
Mike Miller47922d02005-09-13 01:25:25 -07001222 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1224
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001225 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001226 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 /* Inquiry failed (msg printed already) */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001228 continue; /* so we will skip this device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001230 this_device->devtype = (inq_buff[0] & 0x1f);
1231 this_device->bus = -1;
1232 this_device->target = -1;
1233 this_device->lun = -1;
1234 memcpy(this_device->scsi3addr, scsi3addr, 8);
1235 memcpy(this_device->vendor, &inq_buff[8],
1236 sizeof(this_device->vendor));
1237 memcpy(this_device->model, &inq_buff[16],
1238 sizeof(this_device->model));
1239 memcpy(this_device->revision, &inq_buff[32],
1240 sizeof(this_device->revision));
1241 memset(this_device->device_id, 0,
1242 sizeof(this_device->device_id));
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001243 cciss_scsi_get_device_id(h, scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001244 this_device->device_id, sizeof(this_device->device_id));
1245
1246 switch (this_device->devtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 {
Mike Miller47922d02005-09-13 01:25:25 -07001248 case 0x05: /* CD-ROM */ {
1249
1250 /* We don't *really* support actual CD-ROM devices,
1251 * just this "One Button Disaster Recovery" tape drive
1252 * which temporarily pretends to be a CD-ROM drive.
1253 * So we check that the device is really an OBDR tape
1254 * device by checking for "$DR-10" in bytes 43-48 of
1255 * the inquiry data.
1256 */
1257 char obdr_sig[7];
1258
1259 strncpy(obdr_sig, &inq_buff[43], 6);
1260 obdr_sig[6] = '\0';
1261 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1262 /* Not OBDR device, ignore it. */
1263 break;
1264 }
1265 /* fall through . . . */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 case 0x01: /* sequential access, (tape) */
1267 case 0x08: /* medium changer */
1268 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1269 printk(KERN_INFO "cciss%d: %s ignored, "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001270 "too many devices.\n", h->ctlr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001271 scsi_device_type(this_device->devtype));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 break;
1273 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001274 currentsd[ncurrent] = *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 ncurrent++;
1276 break;
1277 default:
1278 break;
1279 }
1280 }
1281
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001282 adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283out:
1284 kfree(inq_buff);
1285 kfree(ld_buff);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001286 kfree(currentsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 return;
1288}
1289
1290static int
1291is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1292{
1293 int verb_len = strlen(verb);
1294 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1295 return verb_len;
1296 else
1297 return 0;
1298}
1299
1300static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001301cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
1303 int arg_len;
1304
1305 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001306 cciss_update_non_disk_devices(h, hostno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 else
1308 return -EINVAL;
1309 return length;
1310}
1311
1312
1313static int
1314cciss_scsi_proc_info(struct Scsi_Host *sh,
1315 char *buffer, /* data buffer */
1316 char **start, /* where data in buffer starts */
1317 off_t offset, /* offset from start of imaginary file */
1318 int length, /* length of data in buffer */
1319 int func) /* 0 == read, 1 == write */
1320{
1321
1322 int buflen, datalen;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001323 ctlr_info_t *h;
Mike Millerb9f0bd02005-09-13 01:25:26 -07001324 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001326 h = (ctlr_info_t *) sh->hostdata[0];
1327 if (h == NULL) /* This really shouldn't ever happen. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 return -EINVAL;
1329
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
Mike Millerb9f0bd02005-09-13 01:25:26 -07001331 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001332 h->ctlr, sh->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
Mike Millerb9f0bd02005-09-13 01:25:26 -07001334 /* this information is needed by apps to know which cciss
1335 device corresponds to which scsi host number without
1336 having to open a scsi target device node. The device
1337 information is not a duplicate of /proc/scsi/scsi because
1338 the two may be out of sync due to scsi hotplug, rather
1339 this info is for an app to be able to use to know how to
1340 get them back in sync. */
1341
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001342 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1343 struct cciss_scsi_dev_t *sd =
1344 &ccissscsi[h->ctlr].dev[i];
Mike Millerb9f0bd02005-09-13 01:25:26 -07001345 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1346 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1347 sh->host_no, sd->bus, sd->target, sd->lun,
1348 sd->devtype,
1349 sd->scsi3addr[0], sd->scsi3addr[1],
1350 sd->scsi3addr[2], sd->scsi3addr[3],
1351 sd->scsi3addr[4], sd->scsi3addr[5],
1352 sd->scsi3addr[6], sd->scsi3addr[7]);
1353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 datalen = buflen - offset;
1355 if (datalen < 0) { /* they're reading past EOF. */
1356 datalen = 0;
1357 *start = buffer+buflen;
1358 } else
1359 *start = buffer + offset;
1360 return(datalen);
1361 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001362 return cciss_scsi_user_command(h, sh->host_no,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 buffer, length);
1364}
1365
1366/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1367 dma mapping and fills in the scatter gather entries of the
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001368 cciss command, c. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001370static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001371 struct scsi_cmnd *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372{
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001373 unsigned int len;
1374 struct scatterlist *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 __u64 addr64;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001376 int request_nsgs, i, chained, sg_index;
1377 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1378 SGDescriptor_struct *curr_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001380 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001382 chained = 0;
1383 sg_index = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001384 curr_sg = c->SG;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001385 request_nsgs = scsi_dma_map(cmd);
1386 if (request_nsgs) {
1387 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1388 if (sg_index + 1 == h->max_cmd_sgentries &&
1389 !chained && request_nsgs - i > 1) {
1390 chained = 1;
1391 sg_index = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001392 curr_sg = sa->cmd_sg_list[c->cmdindex];
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001393 }
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001394 addr64 = (__u64) sg_dma_address(sg);
1395 len = sg_dma_len(sg);
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001396 curr_sg[sg_index].Addr.lower =
1397 (__u32) (addr64 & 0x0FFFFFFFFULL);
1398 curr_sg[sg_index].Addr.upper =
1399 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1400 curr_sg[sg_index].Len = len;
1401 curr_sg[sg_index].Ext = 0;
1402 ++sg_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001404 if (chained)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001405 cciss_map_sg_chain_block(h, c,
1406 sa->cmd_sg_list[c->cmdindex],
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001407 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1408 sizeof(SGDescriptor_struct));
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001409 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001410 /* track how many SG entries we are using */
1411 if (request_nsgs > h->maxSG)
1412 h->maxSG = request_nsgs;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001413 c->Header.SGTotal = (__u8) request_nsgs + chained;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001414 if (request_nsgs > h->max_cmd_sgentries)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001415 c->Header.SGList = h->max_cmd_sgentries;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001416 else
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001417 c->Header.SGList = c->Header.SGTotal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 return;
1419}
1420
1421
1422static int
Jeff Garzikf2812332010-11-16 02:10:29 -05001423cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424{
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001425 ctlr_info_t *h;
1426 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 unsigned char scsi3addr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001428 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 unsigned long flags;
1430
1431 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1432 // We violate cmd->host privacy here. (Is there another way?)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001433 h = (ctlr_info_t *) cmd->device->host->hostdata[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001435 rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 cmd->device->lun, scsi3addr);
1437 if (rc != 0) {
1438 /* the scsi nexus does not match any that we presented... */
1439 /* pretend to mid layer that we got selection timeout */
1440 cmd->result = DID_NO_CONNECT << 16;
1441 done(cmd);
1442 /* we might want to think about registering controller itself
1443 as a processor device on the bus so sg binds to it. */
1444 return 0;
1445 }
1446
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1448 see what the device thinks of it. */
1449
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001450 spin_lock_irqsave(&h->lock, flags);
1451 c = scsi_cmd_alloc(h);
1452 spin_unlock_irqrestore(&h->lock, flags);
1453 if (c == NULL) { /* trouble... */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001454 dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 /* FIXME: next 3 lines are -> BAD! <- */
1456 cmd->result = DID_NO_CONNECT << 16;
1457 done(cmd);
1458 return 0;
1459 }
1460
1461 // Fill in the command list header
1462
1463 cmd->scsi_done = done; // save this for use by completion code
1464
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001465 /* save c in case we have to abort it */
1466 cmd->host_scribble = (unsigned char *) c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001468 c->cmd_type = CMD_SCSI;
1469 c->scsi_cmd = cmd;
1470 c->Header.ReplyQueue = 0; /* unused in simple mode */
1471 memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1472 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473
1474 // Fill in the request block...
1475
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001476 c->Request.Timeout = 0;
1477 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1478 BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1479 c->Request.CDBLen = cmd->cmd_len;
1480 memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1481 c->Request.Type.Type = TYPE_CMD;
1482 c->Request.Type.Attribute = ATTR_SIMPLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 switch(cmd->sc_data_direction)
1484 {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001485 case DMA_TO_DEVICE:
1486 c->Request.Type.Direction = XFER_WRITE;
1487 break;
1488 case DMA_FROM_DEVICE:
1489 c->Request.Type.Direction = XFER_READ;
1490 break;
1491 case DMA_NONE:
1492 c->Request.Type.Direction = XFER_NONE;
1493 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 case DMA_BIDIRECTIONAL:
1495 // This can happen if a buggy application does a scsi passthru
1496 // and sets both inlen and outlen to non-zero. ( see
1497 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1498
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001499 c->Request.Type.Direction = XFER_RSVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 // This is technically wrong, and cciss controllers should
1501 // reject it with CMD_INVALID, which is the most correct
1502 // response, but non-fibre backends appear to let it
1503 // slide by, and give the same results as if this field
1504 // were set correctly. Either way is acceptable for
1505 // our purposes here.
1506
1507 break;
1508
1509 default:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001510 dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 cmd->sc_data_direction);
1512 BUG();
1513 break;
1514 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001515 cciss_scatter_gather(h, c, cmd);
1516 enqueue_cmd_and_start_io(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 /* the cmd'll come back via intr handler in complete_scsi_command() */
1518 return 0;
1519}
1520
Jeff Garzikf2812332010-11-16 02:10:29 -05001521static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1522
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001523static void cciss_unregister_scsi(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524{
1525 struct cciss_scsi_adapter_data_t *sa;
1526 struct cciss_scsi_cmd_stack_t *stk;
1527 unsigned long flags;
1528
1529 /* we are being forcibly unloaded, and may not refuse. */
1530
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001531 spin_lock_irqsave(&h->lock, flags);
1532 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 stk = &sa->cmd_stack;
1534
1535 /* if we weren't ever actually registered, don't unregister */
1536 if (sa->registered) {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001537 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 scsi_remove_host(sa->scsi_host);
1539 scsi_host_put(sa->scsi_host);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001540 spin_lock_irqsave(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 }
1542
1543 /* set scsi_host to NULL so our detect routine will
1544 find us on register */
1545 sa->scsi_host = NULL;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001546 spin_unlock_irqrestore(&h->lock, flags);
1547 scsi_cmd_stack_free(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 kfree(sa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549}
1550
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001551static int cciss_engage_scsi(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552{
1553 struct cciss_scsi_adapter_data_t *sa;
1554 struct cciss_scsi_cmd_stack_t *stk;
1555 unsigned long flags;
1556
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001557 spin_lock_irqsave(&h->lock, flags);
1558 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 stk = &sa->cmd_stack;
1560
Mike Millerf4a93bc2008-08-04 11:54:53 +02001561 if (sa->registered) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001562 dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001563 spin_unlock_irqrestore(&h->lock, flags);
Stephen M. Cameron8721c812009-11-12 12:50:06 -06001564 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 }
Mike Millerf4a93bc2008-08-04 11:54:53 +02001566 sa->registered = 1;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001567 spin_unlock_irqrestore(&h->lock, flags);
1568 cciss_update_non_disk_devices(h, -1);
1569 cciss_scsi_detect(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 return 0;
1571}
1572
1573static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001574cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575{
1576 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001578 CPQ_TAPE_LOCK(h, flags);
Mike Miller89b6e742008-02-21 08:54:03 +01001579 seq_printf(seq,
Mike Millerb9f0bd02005-09-13 01:25:26 -07001580 "Sequential access devices: %d\n\n",
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001581 ccissscsi[h->ctlr].ndevices);
1582 CPQ_TAPE_UNLOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583}
1584
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001585static int wait_for_device_to_become_ready(ctlr_info_t *h,
1586 unsigned char lunaddr[])
1587{
1588 int rc;
1589 int count = 0;
1590 int waittime = HZ;
1591 CommandList_struct *c;
1592
Stephen M. Cameron6b4d96b2010-07-19 13:46:43 -05001593 c = cmd_alloc(h);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001594 if (!c) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001595 dev_warn(&h->pdev->dev, "out of memory in "
1596 "wait_for_device_to_become_ready.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001597 return IO_ERROR;
1598 }
1599
1600 /* Send test unit ready until device ready, or give up. */
1601 while (count < 20) {
1602
1603 /* Wait for a bit. do this first, because if we send
1604 * the TUR right away, the reset will just abort it.
1605 */
scameron@beardog.cca.cpqcorp.net40df6ae2009-06-08 15:59:38 -05001606 schedule_timeout_uninterruptible(waittime);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001607 count++;
1608
1609 /* Increase wait time with each try, up to a point. */
1610 if (waittime < (HZ * 30))
1611 waittime = waittime * 2;
1612
1613 /* Send the Test Unit Ready */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001614 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001615 lunaddr, TYPE_CMD);
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001616 if (rc == 0)
1617 rc = sendcmd_withirq_core(h, c, 0);
1618
1619 (void) process_sendcmd_error(h, c);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001620
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001621 if (rc != 0)
1622 goto retry_tur;
1623
1624 if (c->err_info->CommandStatus == CMD_SUCCESS)
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001625 break;
1626
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001627 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1628 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1629 if (c->err_info->SenseInfo[2] == NO_SENSE)
1630 break;
1631 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1632 unsigned char asc;
1633 asc = c->err_info->SenseInfo[12];
1634 check_for_unit_attention(h, c);
1635 if (asc == POWER_OR_RESET)
1636 break;
1637 }
1638 }
1639retry_tur:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001640 dev_warn(&h->pdev->dev, "Waiting %d secs "
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001641 "for device to become ready.\n",
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001642 waittime / HZ);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001643 rc = 1; /* device not ready. */
1644 }
1645
1646 if (rc)
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001647 dev_warn(&h->pdev->dev, "giving up on device.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001648 else
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001649 dev_warn(&h->pdev->dev, "device is ready.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001650
Stephen M. Cameron6b4d96b2010-07-19 13:46:43 -05001651 cmd_free(h, c);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001652 return rc;
1653}
Mike Miller89b6e742008-02-21 08:54:03 +01001654
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001655/* Need at least one of these error handlers to keep ../scsi/hosts.c from
1656 * complaining. Doing a host- or bus-reset can't do anything good here.
1657 * Despite what it might say in scsi_error.c, there may well be commands
1658 * on the controller, as the cciss driver registers twice, once as a block
1659 * device for the logical drives, and once as a scsi device, for any tape
1660 * drives. So we know there are no commands out on the tape drives, but we
1661 * don't know there are no commands on the controller, and it is likely
1662 * that there probably are, as the cciss block device is most commonly used
1663 * as a boot device (embedded controller on HP/Compaq systems.)
1664*/
1665
1666static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1667{
1668 int rc;
1669 CommandList_struct *cmd_in_trouble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001670 unsigned char lunaddr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001671 ctlr_info_t *h;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001672
1673 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001674 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1675 if (h == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001676 return FAILED;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001677 dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001678 /* find the command that's giving us trouble */
1679 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001680 if (cmd_in_trouble == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001681 return FAILED;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001682 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001683 /* send a reset to the SCSI LUN which the command was sent to */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001684 rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001685 TYPE_MSG);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001686 if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001687 return SUCCESS;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001688 dev_warn(&h->pdev->dev, "resetting device failed.\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001689 return FAILED;
1690}
1691
1692static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1693{
1694 int rc;
1695 CommandList_struct *cmd_to_abort;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001696 unsigned char lunaddr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001697 ctlr_info_t *h;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001698
1699 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001700 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1701 if (h == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001702 return FAILED;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001703 dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001704
1705 /* find the command to be aborted */
1706 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1707 if (cmd_to_abort == NULL) /* paranoia */
1708 return FAILED;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001709 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001710 rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001711 0, 0, lunaddr, TYPE_MSG);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001712 if (rc == 0)
1713 return SUCCESS;
1714 return FAILED;
1715
1716}
1717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718#else /* no CONFIG_CISS_SCSI_TAPE */
1719
1720/* If no tape support, then these become defined out of existence */
1721
1722#define cciss_scsi_setup(cntl_num)
Stephen M. Cameron0007a4c2011-11-16 09:21:49 +01001723#define cciss_engage_scsi(h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
1725#endif /* CONFIG_CISS_SCSI_TAPE */