blob: acda773b3720878495d14f5ebfbe1a82f50c0f74 [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 Sharma60063492011-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;
Stephen M. Cameron395d2872012-03-22 21:40:08 +0100869 sh->max_sectors = h->cciss_max_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871 ((struct cciss_scsi_adapter_data_t *)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500872 h->scsi_ctlr)->scsi_host = sh;
873 sh->hostdata[0] = (unsigned long) h;
874 sh->irq = h->intr[SIMPLE_MODE_INT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 sh->unique_id = sh->irq;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500876 error = scsi_add_host(sh, &h->pdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 if (error)
878 goto fail_host_put;
879 scsi_scan_host(sh);
880 return 1;
881
882 fail_host_put:
883 scsi_host_put(sh);
884 fail:
885 return 0;
886}
887
888static void
889cciss_unmap_one(struct pci_dev *pdev,
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500890 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 size_t buflen,
892 int data_direction)
893{
894 u64bit addr64;
895
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500896 addr64.val32.lower = c->SG[0].Addr.lower;
897 addr64.val32.upper = c->SG[0].Addr.upper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
899}
900
901static void
902cciss_map_one(struct pci_dev *pdev,
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500903 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 unsigned char *buf,
905 size_t buflen,
906 int data_direction)
907{
908 __u64 addr64;
909
910 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500911 c->SG[0].Addr.lower =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500913 c->SG[0].Addr.upper =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500915 c->SG[0].Len = buflen;
916 c->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
917 c->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918}
919
920static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500921cciss_scsi_do_simple_cmd(ctlr_info_t *h,
922 CommandList_struct *c,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 unsigned char *scsi3addr,
924 unsigned char *cdb,
925 unsigned char cdblen,
926 unsigned char *buf, int bufsize,
927 int direction)
928{
Peter Zijlstra6e9a4732006-09-30 23:28:10 -0700929 DECLARE_COMPLETION_ONSTACK(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500931 c->cmd_type = CMD_IOCTL_PEND; /* treat this like an ioctl */
932 c->scsi_cmd = NULL;
933 c->Header.ReplyQueue = 0; /* unused in simple mode */
934 memcpy(&c->Header.LUN, scsi3addr, sizeof(c->Header.LUN));
935 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 // Fill in the request block...
937
938 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
939 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
940 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
941
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500942 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
943 memcpy(c->Request.CDB, cdb, cdblen);
944 c->Request.Timeout = 0;
945 c->Request.CDBLen = cdblen;
946 c->Request.Type.Type = TYPE_CMD;
947 c->Request.Type.Attribute = ATTR_SIMPLE;
948 c->Request.Type.Direction = direction;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 /* Fill in the SG list and do dma mapping */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500951 cciss_map_one(h->pdev, c, (unsigned char *) buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 bufsize, DMA_FROM_DEVICE);
953
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500954 c->waiting = &wait;
955 enqueue_cmd_and_start_io(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 wait_for_completion(&wait);
957
958 /* undo the dma mapping */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500959 cciss_unmap_one(h->pdev, c, bufsize, DMA_FROM_DEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 return(0);
961}
962
963static void
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500964cciss_scsi_interpret_error(ctlr_info_t *h, CommandList_struct *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965{
966 ErrorInfo_struct *ei;
967
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500968 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 switch(ei->CommandStatus)
970 {
971 case CMD_TARGET_STATUS:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500972 dev_warn(&h->pdev->dev,
973 "cmd %p has completed with errors\n", c);
974 dev_warn(&h->pdev->dev,
975 "cmd %p has SCSI Status = %x\n",
976 c, ei->ScsiStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 if (ei->ScsiStatus == 0)
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500978 dev_warn(&h->pdev->dev,
979 "SCSI status is abnormally zero. "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 "(probably indicates selection timeout "
981 "reported incorrectly due to a known "
982 "firmware bug, circa July, 2001.)\n");
983 break;
984 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500985 dev_info(&h->pdev->dev, "UNDERRUN\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 break;
987 case CMD_DATA_OVERRUN:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500988 dev_warn(&h->pdev->dev, "%p has"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 " completed with data overrun "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500990 "reported\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 break;
992 case CMD_INVALID: {
993 /* controller unfortunately reports SCSI passthru's */
994 /* to non-existent targets as invalid commands. */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -0500995 dev_warn(&h->pdev->dev,
996 "%p is reported invalid (probably means "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -0500997 "target device no longer present)\n", c);
998 /* print_bytes((unsigned char *) c, sizeof(*c), 1, 0);
999 print_cmd(c); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 }
1001 break;
1002 case CMD_PROTOCOL_ERR:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001003 dev_warn(&h->pdev->dev, "%p has protocol error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 break;
1005 case CMD_HARDWARE_ERR:
1006 /* cmd->result = DID_ERROR << 16; */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001007 dev_warn(&h->pdev->dev, "%p had hardware error\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 break;
1009 case CMD_CONNECTION_LOST:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001010 dev_warn(&h->pdev->dev, "%p had connection lost\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 break;
1012 case CMD_ABORTED:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001013 dev_warn(&h->pdev->dev, "%p was aborted\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 break;
1015 case CMD_ABORT_FAILED:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001016 dev_warn(&h->pdev->dev,
1017 "%p reports abort failed\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 break;
1019 case CMD_UNSOLICITED_ABORT:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001020 dev_warn(&h->pdev->dev,
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +01001021 "%p aborted due to an unsolicited abort\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 break;
1023 case CMD_TIMEOUT:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001024 dev_warn(&h->pdev->dev, "%p timedout\n", c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 break;
Stephen M. Cameron6d9a4f92011-03-12 10:02:30 +01001026 case CMD_UNABORTABLE:
1027 dev_warn(&h->pdev->dev,
1028 "%p unabortable\n", c);
1029 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 default:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001031 dev_warn(&h->pdev->dev,
1032 "%p returned unknown status %x\n",
1033 c, ei->CommandStatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
1035}
1036
1037static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001038cciss_scsi_do_inquiry(ctlr_info_t *h, unsigned char *scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001039 unsigned char page, unsigned char *buf,
1040 unsigned char bufsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041{
1042 int rc;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001043 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 char cdb[6];
1045 ErrorInfo_struct *ei;
1046 unsigned long flags;
1047
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001048 spin_lock_irqsave(&h->lock, flags);
1049 c = scsi_cmd_alloc(h);
1050 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001052 if (c == NULL) { /* trouble... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 printk("cmd_alloc returned NULL!\n");
1054 return -1;
1055 }
1056
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001057 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 cdb[0] = CISS_INQUIRY;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001060 cdb[1] = (page != 0);
1061 cdb[2] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 cdb[3] = 0;
Mike Miller47922d02005-09-13 01:25:25 -07001063 cdb[4] = bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 cdb[5] = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001065 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr, cdb,
Mike Miller47922d02005-09-13 01:25:25 -07001066 6, buf, bufsize, XFER_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068 if (rc != 0) return rc; /* something went wrong */
1069
1070 if (ei->CommandStatus != 0 &&
1071 ei->CommandStatus != CMD_DATA_UNDERRUN) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001072 cciss_scsi_interpret_error(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 rc = -1;
1074 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001075 spin_lock_irqsave(&h->lock, flags);
1076 scsi_cmd_free(h, c);
1077 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 return rc;
1079}
1080
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001081/* Get the device id from inquiry page 0x83 */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001082static int cciss_scsi_get_device_id(ctlr_info_t *h, unsigned char *scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001083 unsigned char *device_id, int buflen)
1084{
1085 int rc;
1086 unsigned char *buf;
1087
1088 if (buflen > 16)
1089 buflen = 16;
1090 buf = kzalloc(64, GFP_KERNEL);
1091 if (!buf)
1092 return -1;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001093 rc = cciss_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001094 if (rc == 0)
1095 memcpy(device_id, &buf[8], buflen);
1096 kfree(buf);
1097 return rc != 0;
1098}
1099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001101cciss_scsi_do_report_phys_luns(ctlr_info_t *h,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 ReportLunData_struct *buf, int bufsize)
1103{
1104 int rc;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001105 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 unsigned char cdb[12];
1107 unsigned char scsi3addr[8];
1108 ErrorInfo_struct *ei;
1109 unsigned long flags;
1110
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001111 spin_lock_irqsave(&h->lock, flags);
1112 c = scsi_cmd_alloc(h);
1113 spin_unlock_irqrestore(&h->lock, flags);
1114 if (c == NULL) { /* trouble... */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 printk("cmd_alloc returned NULL!\n");
1116 return -1;
1117 }
1118
1119 memset(&scsi3addr[0], 0, 8); /* address the controller */
1120 cdb[0] = CISS_REPORT_PHYS;
1121 cdb[1] = 0;
1122 cdb[2] = 0;
1123 cdb[3] = 0;
1124 cdb[4] = 0;
1125 cdb[5] = 0;
1126 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1127 cdb[7] = (bufsize >> 16) & 0xFF;
1128 cdb[8] = (bufsize >> 8) & 0xFF;
1129 cdb[9] = bufsize & 0xFF;
1130 cdb[10] = 0;
1131 cdb[11] = 0;
1132
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001133 rc = cciss_scsi_do_simple_cmd(h, c, scsi3addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 cdb, 12,
1135 (unsigned char *) buf,
1136 bufsize, XFER_READ);
1137
1138 if (rc != 0) return rc; /* something went wrong */
1139
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001140 ei = c->err_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 if (ei->CommandStatus != 0 &&
1142 ei->CommandStatus != CMD_DATA_UNDERRUN) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001143 cciss_scsi_interpret_error(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 rc = -1;
1145 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001146 spin_lock_irqsave(&h->lock, flags);
1147 scsi_cmd_free(h, c);
1148 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 return rc;
1150}
1151
1152static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001153cciss_update_non_disk_devices(ctlr_info_t *h, int hostno)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154{
1155 /* the idea here is we could get notified from /proc
1156 that some devices have changed, so we do a report
1157 physical luns cmd, and adjust our list of devices
1158 accordingly. (We can't rely on the scsi-mid layer just
1159 doing inquiries, because the "busses" that the scsi
1160 mid-layer probes are totally fabricated by this driver,
1161 so new devices wouldn't show up.
1162
1163 the scsi3addr's of devices won't change so long as the
1164 adapter is not reset. That means we can rescan and
1165 tell which devices we already know about, vs. new
1166 devices, vs. disappearing devices.
1167
1168 Also, if you yank out a tape drive, then put in a disk
1169 in it's place, (say, a configured volume from another
1170 array controller for instance) _don't_ poke this driver
1171 (so it thinks it's still a tape, but _do_ poke the scsi
1172 mid layer, so it does an inquiry... the scsi mid layer
1173 will see the physical disk. This would be bad. Need to
1174 think about how to prevent that. One idea would be to
1175 snoop all scsi responses and if an inquiry repsonse comes
1176 back that reports a disk, chuck it an return selection
1177 timeout instead and adjust our table... Not sure i like
1178 that though.
1179
1180 */
Mike Miller47922d02005-09-13 01:25:25 -07001181#define OBDR_TAPE_INQ_SIZE 49
1182#define OBDR_TAPE_SIG "$DR-10"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 ReportLunData_struct *ld_buff;
Mike Miller47922d02005-09-13 01:25:25 -07001184 unsigned char *inq_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 unsigned char scsi3addr[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 __u32 num_luns=0;
1187 unsigned char *ch;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001188 struct cciss_scsi_dev_t *currentsd, *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 int ncurrent=0;
1190 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1191 int i;
1192
Eric Sesterhenn06ff37f2006-03-08 11:21:52 +01001193 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
Mike Miller47922d02005-09-13 01:25:25 -07001194 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001195 currentsd = kzalloc(sizeof(*currentsd) *
1196 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1197 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1198 printk(KERN_ERR "cciss: out of memory\n");
1199 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001201 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001202 if (cciss_scsi_do_report_phys_luns(h, ld_buff, reportlunsize) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 ch = &ld_buff->LUNListLength[0];
1204 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1205 if (num_luns > CISS_MAX_PHYS_LUN) {
1206 printk(KERN_WARNING
1207 "cciss: Maximum physical LUNs (%d) exceeded. "
1208 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1209 num_luns - CISS_MAX_PHYS_LUN);
1210 num_luns = CISS_MAX_PHYS_LUN;
1211 }
1212 }
1213 else {
1214 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1215 goto out;
1216 }
1217
1218
1219 /* adjust our table of devices */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001220 for (i = 0; i < num_luns; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 /* for each physical lun, do an inquiry */
1222 if (ld_buff->LUN[i][3] & 0xC0) continue;
Mike Miller47922d02005-09-13 01:25:25 -07001223 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1225
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001226 if (cciss_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001227 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 /* Inquiry failed (msg printed already) */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001229 continue; /* so we will skip this device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001231 this_device->devtype = (inq_buff[0] & 0x1f);
1232 this_device->bus = -1;
1233 this_device->target = -1;
1234 this_device->lun = -1;
1235 memcpy(this_device->scsi3addr, scsi3addr, 8);
1236 memcpy(this_device->vendor, &inq_buff[8],
1237 sizeof(this_device->vendor));
1238 memcpy(this_device->model, &inq_buff[16],
1239 sizeof(this_device->model));
1240 memcpy(this_device->revision, &inq_buff[32],
1241 sizeof(this_device->revision));
1242 memset(this_device->device_id, 0,
1243 sizeof(this_device->device_id));
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001244 cciss_scsi_get_device_id(h, scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001245 this_device->device_id, sizeof(this_device->device_id));
1246
1247 switch (this_device->devtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 {
Mike Miller47922d02005-09-13 01:25:25 -07001249 case 0x05: /* CD-ROM */ {
1250
1251 /* We don't *really* support actual CD-ROM devices,
1252 * just this "One Button Disaster Recovery" tape drive
1253 * which temporarily pretends to be a CD-ROM drive.
1254 * So we check that the device is really an OBDR tape
1255 * device by checking for "$DR-10" in bytes 43-48 of
1256 * the inquiry data.
1257 */
1258 char obdr_sig[7];
1259
1260 strncpy(obdr_sig, &inq_buff[43], 6);
1261 obdr_sig[6] = '\0';
1262 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1263 /* Not OBDR device, ignore it. */
1264 break;
1265 }
1266 /* fall through . . . */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 case 0x01: /* sequential access, (tape) */
1268 case 0x08: /* medium changer */
1269 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1270 printk(KERN_INFO "cciss%d: %s ignored, "
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001271 "too many devices.\n", h->ctlr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001272 scsi_device_type(this_device->devtype));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 break;
1274 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001275 currentsd[ncurrent] = *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 ncurrent++;
1277 break;
1278 default:
1279 break;
1280 }
1281 }
1282
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001283 adjust_cciss_scsi_table(h, hostno, currentsd, ncurrent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284out:
1285 kfree(inq_buff);
1286 kfree(ld_buff);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001287 kfree(currentsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 return;
1289}
1290
1291static int
1292is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1293{
1294 int verb_len = strlen(verb);
1295 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1296 return verb_len;
1297 else
1298 return 0;
1299}
1300
1301static int
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001302cciss_scsi_user_command(ctlr_info_t *h, int hostno, char *buffer, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303{
1304 int arg_len;
1305
1306 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001307 cciss_update_non_disk_devices(h, hostno);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 else
1309 return -EINVAL;
1310 return length;
1311}
1312
1313
1314static int
1315cciss_scsi_proc_info(struct Scsi_Host *sh,
1316 char *buffer, /* data buffer */
1317 char **start, /* where data in buffer starts */
1318 off_t offset, /* offset from start of imaginary file */
1319 int length, /* length of data in buffer */
1320 int func) /* 0 == read, 1 == write */
1321{
1322
1323 int buflen, datalen;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001324 ctlr_info_t *h;
Mike Millerb9f0bd02005-09-13 01:25:26 -07001325 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001327 h = (ctlr_info_t *) sh->hostdata[0];
1328 if (h == NULL) /* This really shouldn't ever happen. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 return -EINVAL;
1330
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
Mike Millerb9f0bd02005-09-13 01:25:26 -07001332 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001333 h->ctlr, sh->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
Mike Millerb9f0bd02005-09-13 01:25:26 -07001335 /* this information is needed by apps to know which cciss
1336 device corresponds to which scsi host number without
1337 having to open a scsi target device node. The device
1338 information is not a duplicate of /proc/scsi/scsi because
1339 the two may be out of sync due to scsi hotplug, rather
1340 this info is for an app to be able to use to know how to
1341 get them back in sync. */
1342
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001343 for (i = 0; i < ccissscsi[h->ctlr].ndevices; i++) {
1344 struct cciss_scsi_dev_t *sd =
1345 &ccissscsi[h->ctlr].dev[i];
Mike Millerb9f0bd02005-09-13 01:25:26 -07001346 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1347 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1348 sh->host_no, sd->bus, sd->target, sd->lun,
1349 sd->devtype,
1350 sd->scsi3addr[0], sd->scsi3addr[1],
1351 sd->scsi3addr[2], sd->scsi3addr[3],
1352 sd->scsi3addr[4], sd->scsi3addr[5],
1353 sd->scsi3addr[6], sd->scsi3addr[7]);
1354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 datalen = buflen - offset;
1356 if (datalen < 0) { /* they're reading past EOF. */
1357 datalen = 0;
1358 *start = buffer+buflen;
1359 } else
1360 *start = buffer + offset;
1361 return(datalen);
1362 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001363 return cciss_scsi_user_command(h, sh->host_no,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 buffer, length);
1365}
1366
1367/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1368 dma mapping and fills in the scatter gather entries of the
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001369 cciss command, c. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001371static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *c,
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001372 struct scsi_cmnd *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373{
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001374 unsigned int len;
1375 struct scatterlist *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 __u64 addr64;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001377 int request_nsgs, i, chained, sg_index;
1378 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1379 SGDescriptor_struct *curr_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001381 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001383 chained = 0;
1384 sg_index = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001385 curr_sg = c->SG;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001386 request_nsgs = scsi_dma_map(cmd);
1387 if (request_nsgs) {
1388 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1389 if (sg_index + 1 == h->max_cmd_sgentries &&
1390 !chained && request_nsgs - i > 1) {
1391 chained = 1;
1392 sg_index = 0;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001393 curr_sg = sa->cmd_sg_list[c->cmdindex];
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001394 }
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001395 addr64 = (__u64) sg_dma_address(sg);
1396 len = sg_dma_len(sg);
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001397 curr_sg[sg_index].Addr.lower =
1398 (__u32) (addr64 & 0x0FFFFFFFFULL);
1399 curr_sg[sg_index].Addr.upper =
1400 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1401 curr_sg[sg_index].Len = len;
1402 curr_sg[sg_index].Ext = 0;
1403 ++sg_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001405 if (chained)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001406 cciss_map_sg_chain_block(h, c,
1407 sa->cmd_sg_list[c->cmdindex],
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001408 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1409 sizeof(SGDescriptor_struct));
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001410 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001411 /* track how many SG entries we are using */
1412 if (request_nsgs > h->maxSG)
1413 h->maxSG = request_nsgs;
Stephen M. Cameronbc67f632012-03-22 21:40:09 +01001414 c->Header.SGTotal = (u16) request_nsgs + chained;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001415 if (request_nsgs > h->max_cmd_sgentries)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001416 c->Header.SGList = h->max_cmd_sgentries;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001417 else
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001418 c->Header.SGList = c->Header.SGTotal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 return;
1420}
1421
1422
1423static int
Jeff Garzikf2812332010-11-16 02:10:29 -05001424cciss_scsi_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425{
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001426 ctlr_info_t *h;
1427 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 unsigned char scsi3addr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001429 CommandList_struct *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 unsigned long flags;
1431
1432 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1433 // We violate cmd->host privacy here. (Is there another way?)
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001434 h = (ctlr_info_t *) cmd->device->host->hostdata[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001436 rc = lookup_scsi3addr(h, cmd->device->channel, cmd->device->id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 cmd->device->lun, scsi3addr);
1438 if (rc != 0) {
1439 /* the scsi nexus does not match any that we presented... */
1440 /* pretend to mid layer that we got selection timeout */
1441 cmd->result = DID_NO_CONNECT << 16;
1442 done(cmd);
1443 /* we might want to think about registering controller itself
1444 as a processor device on the bus so sg binds to it. */
1445 return 0;
1446 }
1447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1449 see what the device thinks of it. */
1450
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001451 spin_lock_irqsave(&h->lock, flags);
1452 c = scsi_cmd_alloc(h);
1453 spin_unlock_irqrestore(&h->lock, flags);
1454 if (c == NULL) { /* trouble... */
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001455 dev_warn(&h->pdev->dev, "scsi_cmd_alloc returned NULL!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 /* FIXME: next 3 lines are -> BAD! <- */
1457 cmd->result = DID_NO_CONNECT << 16;
1458 done(cmd);
1459 return 0;
1460 }
1461
1462 // Fill in the command list header
1463
1464 cmd->scsi_done = done; // save this for use by completion code
1465
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001466 /* save c in case we have to abort it */
1467 cmd->host_scribble = (unsigned char *) c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001469 c->cmd_type = CMD_SCSI;
1470 c->scsi_cmd = cmd;
1471 c->Header.ReplyQueue = 0; /* unused in simple mode */
1472 memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1473 c->Header.Tag.lower = c->busaddr; /* Use k. address of cmd as tag */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
1475 // Fill in the request block...
1476
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001477 c->Request.Timeout = 0;
1478 memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
1479 BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
1480 c->Request.CDBLen = cmd->cmd_len;
1481 memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
1482 c->Request.Type.Type = TYPE_CMD;
1483 c->Request.Type.Attribute = ATTR_SIMPLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 switch(cmd->sc_data_direction)
1485 {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001486 case DMA_TO_DEVICE:
1487 c->Request.Type.Direction = XFER_WRITE;
1488 break;
1489 case DMA_FROM_DEVICE:
1490 c->Request.Type.Direction = XFER_READ;
1491 break;
1492 case DMA_NONE:
1493 c->Request.Type.Direction = XFER_NONE;
1494 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 case DMA_BIDIRECTIONAL:
1496 // This can happen if a buggy application does a scsi passthru
1497 // and sets both inlen and outlen to non-zero. ( see
1498 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1499
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001500 c->Request.Type.Direction = XFER_RSVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 // This is technically wrong, and cciss controllers should
1502 // reject it with CMD_INVALID, which is the most correct
1503 // response, but non-fibre backends appear to let it
1504 // slide by, and give the same results as if this field
1505 // were set correctly. Either way is acceptable for
1506 // our purposes here.
1507
1508 break;
1509
1510 default:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001511 dev_warn(&h->pdev->dev, "unknown data direction: %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 cmd->sc_data_direction);
1513 BUG();
1514 break;
1515 }
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001516 cciss_scatter_gather(h, c, cmd);
1517 enqueue_cmd_and_start_io(h, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 /* the cmd'll come back via intr handler in complete_scsi_command() */
1519 return 0;
1520}
1521
Jeff Garzikf2812332010-11-16 02:10:29 -05001522static DEF_SCSI_QCMD(cciss_scsi_queue_command)
1523
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001524static void cciss_unregister_scsi(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525{
1526 struct cciss_scsi_adapter_data_t *sa;
1527 struct cciss_scsi_cmd_stack_t *stk;
1528 unsigned long flags;
1529
1530 /* we are being forcibly unloaded, and may not refuse. */
1531
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001532 spin_lock_irqsave(&h->lock, flags);
1533 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 stk = &sa->cmd_stack;
1535
1536 /* if we weren't ever actually registered, don't unregister */
1537 if (sa->registered) {
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001538 spin_unlock_irqrestore(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 scsi_remove_host(sa->scsi_host);
1540 scsi_host_put(sa->scsi_host);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001541 spin_lock_irqsave(&h->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 }
1543
1544 /* set scsi_host to NULL so our detect routine will
1545 find us on register */
1546 sa->scsi_host = NULL;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001547 spin_unlock_irqrestore(&h->lock, flags);
1548 scsi_cmd_stack_free(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 kfree(sa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550}
1551
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001552static int cciss_engage_scsi(ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553{
1554 struct cciss_scsi_adapter_data_t *sa;
1555 struct cciss_scsi_cmd_stack_t *stk;
1556 unsigned long flags;
1557
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001558 spin_lock_irqsave(&h->lock, flags);
1559 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 stk = &sa->cmd_stack;
1561
Mike Millerf4a93bc2008-08-04 11:54:53 +02001562 if (sa->registered) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001563 dev_info(&h->pdev->dev, "SCSI subsystem already engaged.\n");
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001564 spin_unlock_irqrestore(&h->lock, flags);
Stephen M. Cameron8721c812009-11-12 12:50:06 -06001565 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 }
Mike Millerf4a93bc2008-08-04 11:54:53 +02001567 sa->registered = 1;
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001568 spin_unlock_irqrestore(&h->lock, flags);
1569 cciss_update_non_disk_devices(h, -1);
1570 cciss_scsi_detect(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 return 0;
1572}
1573
1574static void
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001575cciss_seq_tape_report(struct seq_file *seq, ctlr_info_t *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576{
1577 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001579 CPQ_TAPE_LOCK(h, flags);
Mike Miller89b6e742008-02-21 08:54:03 +01001580 seq_printf(seq,
Mike Millerb9f0bd02005-09-13 01:25:26 -07001581 "Sequential access devices: %d\n\n",
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001582 ccissscsi[h->ctlr].ndevices);
1583 CPQ_TAPE_UNLOCK(h, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584}
1585
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001586static int wait_for_device_to_become_ready(ctlr_info_t *h,
1587 unsigned char lunaddr[])
1588{
1589 int rc;
1590 int count = 0;
1591 int waittime = HZ;
1592 CommandList_struct *c;
1593
Stephen M. Cameron6b4d96b2010-07-19 13:46:43 -05001594 c = cmd_alloc(h);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001595 if (!c) {
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001596 dev_warn(&h->pdev->dev, "out of memory in "
1597 "wait_for_device_to_become_ready.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001598 return IO_ERROR;
1599 }
1600
1601 /* Send test unit ready until device ready, or give up. */
1602 while (count < 20) {
1603
1604 /* Wait for a bit. do this first, because if we send
1605 * the TUR right away, the reset will just abort it.
1606 */
scameron@beardog.cca.cpqcorp.net40df6ae2009-06-08 15:59:38 -05001607 schedule_timeout_uninterruptible(waittime);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001608 count++;
1609
1610 /* Increase wait time with each try, up to a point. */
1611 if (waittime < (HZ * 30))
1612 waittime = waittime * 2;
1613
1614 /* Send the Test Unit Ready */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001615 rc = fill_cmd(h, c, TEST_UNIT_READY, NULL, 0, 0,
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001616 lunaddr, TYPE_CMD);
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001617 if (rc == 0)
1618 rc = sendcmd_withirq_core(h, c, 0);
1619
1620 (void) process_sendcmd_error(h, c);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001621
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001622 if (rc != 0)
1623 goto retry_tur;
1624
1625 if (c->err_info->CommandStatus == CMD_SUCCESS)
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001626 break;
1627
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001628 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1629 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1630 if (c->err_info->SenseInfo[2] == NO_SENSE)
1631 break;
1632 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1633 unsigned char asc;
1634 asc = c->err_info->SenseInfo[12];
1635 check_for_unit_attention(h, c);
1636 if (asc == POWER_OR_RESET)
1637 break;
1638 }
1639 }
1640retry_tur:
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001641 dev_warn(&h->pdev->dev, "Waiting %d secs "
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001642 "for device to become ready.\n",
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001643 waittime / HZ);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001644 rc = 1; /* device not ready. */
1645 }
1646
1647 if (rc)
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001648 dev_warn(&h->pdev->dev, "giving up on device.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001649 else
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001650 dev_warn(&h->pdev->dev, "device is ready.\n");
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001651
Stephen M. Cameron6b4d96b2010-07-19 13:46:43 -05001652 cmd_free(h, c);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001653 return rc;
1654}
Mike Miller89b6e742008-02-21 08:54:03 +01001655
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001656/* Need at least one of these error handlers to keep ../scsi/hosts.c from
1657 * complaining. Doing a host- or bus-reset can't do anything good here.
1658 * Despite what it might say in scsi_error.c, there may well be commands
1659 * on the controller, as the cciss driver registers twice, once as a block
1660 * device for the logical drives, and once as a scsi device, for any tape
1661 * drives. So we know there are no commands out on the tape drives, but we
1662 * don't know there are no commands on the controller, and it is likely
1663 * that there probably are, as the cciss block device is most commonly used
1664 * as a boot device (embedded controller on HP/Compaq systems.)
1665*/
1666
1667static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1668{
1669 int rc;
1670 CommandList_struct *cmd_in_trouble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001671 unsigned char lunaddr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001672 ctlr_info_t *h;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001673
1674 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001675 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1676 if (h == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001677 return FAILED;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001678 dev_warn(&h->pdev->dev, "resetting tape drive or medium changer.\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001679 /* find the command that's giving us trouble */
1680 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001681 if (cmd_in_trouble == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001682 return FAILED;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001683 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001684 /* send a reset to the SCSI LUN which the command was sent to */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001685 rc = sendcmd_withirq(h, CCISS_RESET_MSG, NULL, 0, 0, lunaddr,
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001686 TYPE_MSG);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001687 if (rc == 0 && wait_for_device_to_become_ready(h, lunaddr) == 0)
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001688 return SUCCESS;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001689 dev_warn(&h->pdev->dev, "resetting device failed.\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001690 return FAILED;
1691}
1692
1693static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1694{
1695 int rc;
1696 CommandList_struct *cmd_to_abort;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001697 unsigned char lunaddr[8];
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001698 ctlr_info_t *h;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001699
1700 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001701 h = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1702 if (h == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001703 return FAILED;
Stephen M. Cameronb2a4a432010-07-19 13:46:48 -05001704 dev_warn(&h->pdev->dev, "aborting tardy SCSI cmd\n");
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001705
1706 /* find the command to be aborted */
1707 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1708 if (cmd_to_abort == NULL) /* paranoia */
1709 return FAILED;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001710 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
Stephen M. Cameronf70dba82010-07-19 13:46:38 -05001711 rc = sendcmd_withirq(h, CCISS_ABORT_MSG, &cmd_to_abort->Header.Tag,
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001712 0, 0, lunaddr, TYPE_MSG);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001713 if (rc == 0)
1714 return SUCCESS;
1715 return FAILED;
1716
1717}
1718
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719#else /* no CONFIG_CISS_SCSI_TAPE */
1720
1721/* If no tape support, then these become defined out of existence */
1722
1723#define cciss_scsi_setup(cntl_num)
Stephen M. Cameron0007a4c2011-11-16 09:21:49 +01001724#define cciss_engage_scsi(h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
1726#endif /* CONFIG_CISS_SCSI_TAPE */