blob: 72dae92f3cab89770e0c43abd6e7b01aa554b62c [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
36#include <asm/atomic.h>
37
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. Cameron88f627a2009-06-02 14:48:11 +020047static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
48 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. Cameron88f627a2009-06-02 14:48:11 +020052static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
53static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55static int cciss_scsi_proc_info(
56 struct Scsi_Host *sh,
57 char *buffer, /* data buffer */
58 char **start, /* where data in buffer starts */
59 off_t offset, /* offset from start of imaginary file */
60 int length, /* length of data in buffer */
61 int func); /* 0 == read, 1 == write */
62
63static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
64 void (* done)(struct scsi_cmnd *));
mike.miller@hp.com3da8b712005-11-04 12:30:37 -060065static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
66static int cciss_eh_abort_handler(struct scsi_cmnd *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
69 { .name = "cciss0", .ndevices = 0 },
70 { .name = "cciss1", .ndevices = 0 },
71 { .name = "cciss2", .ndevices = 0 },
72 { .name = "cciss3", .ndevices = 0 },
73 { .name = "cciss4", .ndevices = 0 },
74 { .name = "cciss5", .ndevices = 0 },
75 { .name = "cciss6", .ndevices = 0 },
76 { .name = "cciss7", .ndevices = 0 },
77};
78
79static struct scsi_host_template cciss_driver_template = {
80 .module = THIS_MODULE,
81 .name = "cciss",
82 .proc_name = "cciss",
83 .proc_info = cciss_scsi_proc_info,
84 .queuecommand = cciss_scsi_queue_command,
85 .can_queue = SCSI_CCISS_CAN_QUEUE,
86 .this_id = 7,
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 .cmd_per_lun = 1,
88 .use_clustering = DISABLE_CLUSTERING,
mike.miller@hp.com3da8b712005-11-04 12:30:37 -060089 /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
90 .eh_device_reset_handler= cciss_eh_device_reset_handler,
91 .eh_abort_handler = cciss_eh_abort_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -070092};
93
94#pragma pack(1)
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -060095
Stephen M. Cameron87c3a922010-02-26 16:01:53 -060096#define SCSI_PAD_32 0
97#define SCSI_PAD_64 0
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -060098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099struct cciss_scsi_cmd_stack_elem_t {
100 CommandList_struct cmd;
101 ErrorInfo_struct Err;
102 __u32 busaddr;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600103 int cmdindex;
Stephen M. Cameron1b7d0d22010-02-26 16:01:17 -0600104 u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
107#pragma pack()
108
109#define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
110 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
111 // plus two for init time usage
112
113#pragma pack(1)
114struct cciss_scsi_cmd_stack_t {
115 struct cciss_scsi_cmd_stack_elem_t *pool;
116 struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
117 dma_addr_t cmd_pool_handle;
118 int top;
119};
120#pragma pack()
121
122struct cciss_scsi_adapter_data_t {
123 struct Scsi_Host *scsi_host;
124 struct cciss_scsi_cmd_stack_t cmd_stack;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600125 SGDescriptor_struct **cmd_sg_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 int registered;
127 spinlock_t lock; // to protect ccissscsi[ctlr];
128};
129
130#define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600131 &hba[ctlr]->scsi_ctlr->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132#define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600133 &hba[ctlr]->scsi_ctlr->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135static CommandList_struct *
136scsi_cmd_alloc(ctlr_info_t *h)
137{
138 /* assume only one process in here at a time, locking done by caller. */
139 /* use CCISS_LOCK(ctlr) */
140 /* might be better to rewrite how we allocate scsi commands in a way that */
141 /* needs no locking at all. */
142
143 /* take the top memory chunk off the stack and return it, if any. */
144 struct cciss_scsi_cmd_stack_elem_t *c;
145 struct cciss_scsi_adapter_data_t *sa;
146 struct cciss_scsi_cmd_stack_t *stk;
147 u64bit temp64;
148
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600149 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 stk = &sa->cmd_stack;
151
152 if (stk->top < 0)
153 return NULL;
154 c = stk->elem[stk->top];
155 /* memset(c, 0, sizeof(*c)); */
156 memset(&c->cmd, 0, sizeof(c->cmd));
157 memset(&c->Err, 0, sizeof(c->Err));
158 /* set physical addr of cmd and addr of scsi parameters */
159 c->cmd.busaddr = c->busaddr;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600160 c->cmd.cmdindex = c->cmdindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 /* (__u32) (stk->cmd_pool_handle +
162 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
163
164 temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
165 /* (__u64) (stk->cmd_pool_handle +
166 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
167 sizeof(CommandList_struct)); */
168 stk->top--;
169 c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
170 c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
171 c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
172
173 c->cmd.ctlr = h->ctlr;
174 c->cmd.err_info = &c->Err;
175
176 return (CommandList_struct *) c;
177}
178
179static void
180scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
181{
182 /* assume only one process in here at a time, locking done by caller. */
183 /* use CCISS_LOCK(ctlr) */
184 /* drop the free memory chunk on top of the stack. */
185
186 struct cciss_scsi_adapter_data_t *sa;
187 struct cciss_scsi_cmd_stack_t *stk;
188
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600189 sa = h->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 stk = &sa->cmd_stack;
Dan Carpenter713b6862010-06-01 12:17:48 +0200191 stk->top++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (stk->top >= CMD_STACK_SIZE) {
193 printk("cciss: scsi_cmd_free called too many times.\n");
194 BUG();
195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
197}
198
199static int
200scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
201{
202 int i;
203 struct cciss_scsi_cmd_stack_t *stk;
204 size_t size;
205
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600206 sa->cmd_sg_list = cciss_allocate_sg_chain_blocks(hba[ctlr],
207 hba[ctlr]->chainsize, CMD_STACK_SIZE);
208 if (!sa->cmd_sg_list && hba[ctlr]->chainsize > 0)
209 return -ENOMEM;
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 stk = &sa->cmd_stack;
212 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
213
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 *)
218 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
219
220 if (stk->pool == NULL) {
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600221 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
222 sa->cmd_sg_list = NULL;
223 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 }
225
226 for (i=0; i<CMD_STACK_SIZE; i++) {
227 stk->elem[i] = &stk->pool[i];
228 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle +
229 (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600230 stk->elem[i]->cmdindex = i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232 stk->top = CMD_STACK_SIZE-1;
233 return 0;
234}
235
236static void
237scsi_cmd_stack_free(int ctlr)
238{
239 struct cciss_scsi_adapter_data_t *sa;
240 struct cciss_scsi_cmd_stack_t *stk;
241 size_t size;
242
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600243 sa = hba[ctlr]->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 stk = &sa->cmd_stack;
245 if (stk->top != CMD_STACK_SIZE-1) {
246 printk( "cciss: %d scsi commands are still outstanding.\n",
247 CMD_STACK_SIZE - stk->top);
248 // BUG();
249 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
250 }
251 size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
252
253 pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
254 stk->pool = NULL;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600255 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256}
257
Grant Coady400bb232005-11-15 00:09:20 -0800258#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259static int xmargin=8;
260static int amargin=60;
261
262static void
263print_bytes (unsigned char *c, int len, int hex, int ascii)
264{
265
266 int i;
267 unsigned char *x;
268
269 if (hex)
270 {
271 x = c;
272 for (i=0;i<len;i++)
273 {
274 if ((i % xmargin) == 0 && i>0) printk("\n");
275 if ((i % xmargin) == 0) printk("0x%04x:", i);
276 printk(" %02x", *x);
277 x++;
278 }
279 printk("\n");
280 }
281 if (ascii)
282 {
283 x = c;
284 for (i=0;i<len;i++)
285 {
286 if ((i % amargin) == 0 && i>0) printk("\n");
287 if ((i % amargin) == 0) printk("0x%04x:", i);
288 if (*x > 26 && *x < 128) printk("%c", *x);
289 else printk(".");
290 x++;
291 }
292 printk("\n");
293 }
294}
295
296static void
297print_cmd(CommandList_struct *cp)
298{
299 printk("queue:%d\n", cp->Header.ReplyQueue);
300 printk("sglist:%d\n", cp->Header.SGList);
301 printk("sgtot:%d\n", cp->Header.SGTotal);
302 printk("Tag:0x%08x/0x%08x\n", cp->Header.Tag.upper,
303 cp->Header.Tag.lower);
304 printk("LUN:0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
305 cp->Header.LUN.LunAddrBytes[0],
306 cp->Header.LUN.LunAddrBytes[1],
307 cp->Header.LUN.LunAddrBytes[2],
308 cp->Header.LUN.LunAddrBytes[3],
309 cp->Header.LUN.LunAddrBytes[4],
310 cp->Header.LUN.LunAddrBytes[5],
311 cp->Header.LUN.LunAddrBytes[6],
312 cp->Header.LUN.LunAddrBytes[7]);
313 printk("CDBLen:%d\n", cp->Request.CDBLen);
314 printk("Type:%d\n",cp->Request.Type.Type);
315 printk("Attr:%d\n",cp->Request.Type.Attribute);
316 printk(" Dir:%d\n",cp->Request.Type.Direction);
317 printk("Timeout:%d\n",cp->Request.Timeout);
318 printk( "CDB: %02x %02x %02x %02x %02x %02x %02x %02x"
319 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
320 cp->Request.CDB[0], cp->Request.CDB[1],
321 cp->Request.CDB[2], cp->Request.CDB[3],
322 cp->Request.CDB[4], cp->Request.CDB[5],
323 cp->Request.CDB[6], cp->Request.CDB[7],
324 cp->Request.CDB[8], cp->Request.CDB[9],
325 cp->Request.CDB[10], cp->Request.CDB[11],
326 cp->Request.CDB[12], cp->Request.CDB[13],
327 cp->Request.CDB[14], cp->Request.CDB[15]),
328 printk("edesc.Addr: 0x%08x/0%08x, Len = %d\n",
329 cp->ErrDesc.Addr.upper, cp->ErrDesc.Addr.lower,
330 cp->ErrDesc.Len);
331 printk("sgs..........Errorinfo:\n");
332 printk("scsistatus:%d\n", cp->err_info->ScsiStatus);
333 printk("senselen:%d\n", cp->err_info->SenseLen);
334 printk("cmd status:%d\n", cp->err_info->CommandStatus);
335 printk("resid cnt:%d\n", cp->err_info->ResidualCnt);
336 printk("offense size:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_size);
337 printk("offense byte:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_num);
338 printk("offense value:%d\n", cp->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
339
340}
341
342#endif
343
344static int
345find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
346{
347 /* finds an unused bus, target, lun for a new device */
348 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
349 int i, found=0;
350 unsigned char target_taken[CCISS_MAX_SCSI_DEVS_PER_HBA];
351
352 memset(&target_taken[0], 0, CCISS_MAX_SCSI_DEVS_PER_HBA);
353
354 target_taken[SELF_SCSI_ID] = 1;
355 for (i=0;i<ccissscsi[ctlr].ndevices;i++)
356 target_taken[ccissscsi[ctlr].dev[i].target] = 1;
357
358 for (i=0;i<CCISS_MAX_SCSI_DEVS_PER_HBA;i++) {
359 if (!target_taken[i]) {
360 *bus = 0; *target=i; *lun = 0; found=1;
361 break;
362 }
363 }
364 return (!found);
365}
Mike Millerf4a93bc2008-08-04 11:54:53 +0200366struct scsi2map {
367 char scsi3addr[8];
368 int bus, target, lun;
369};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371static int
372cciss_scsi_add_entry(int ctlr, int hostno,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700373 struct cciss_scsi_dev_t *device,
Mike Millerf4a93bc2008-08-04 11:54:53 +0200374 struct scsi2map *added, int *nadded)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
376 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
377 int n = ccissscsi[ctlr].ndevices;
378 struct cciss_scsi_dev_t *sd;
Mike Miller935dc8d2008-08-04 11:54:54 +0200379 int i, bus, target, lun;
380 unsigned char addr1[8], addr2[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
383 printk("cciss%d: Too many devices, "
384 "some will be inaccessible.\n", ctlr);
385 return -1;
386 }
Mike Millerf4a93bc2008-08-04 11:54:53 +0200387
Mike Miller935dc8d2008-08-04 11:54:54 +0200388 bus = target = -1;
389 lun = 0;
390 /* Is this device a non-zero lun of a multi-lun device */
391 /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700392 if (device->scsi3addr[4] != 0) {
Mike Miller935dc8d2008-08-04 11:54:54 +0200393 /* Search through our list and find the device which */
394 /* has the same 8 byte LUN address, excepting byte 4. */
395 /* Assign the same bus and target for this new LUN. */
396 /* Use the logical unit number from the firmware. */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700397 memcpy(addr1, device->scsi3addr, 8);
Mike Miller935dc8d2008-08-04 11:54:54 +0200398 addr1[4] = 0;
399 for (i = 0; i < n; i++) {
400 sd = &ccissscsi[ctlr].dev[i];
401 memcpy(addr2, sd->scsi3addr, 8);
402 addr2[4] = 0;
403 /* differ only in byte 4? */
404 if (memcmp(addr1, addr2, 8) == 0) {
405 bus = sd->bus;
406 target = sd->target;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700407 lun = device->scsi3addr[4];
Mike Miller935dc8d2008-08-04 11:54:54 +0200408 break;
409 }
410 }
411 }
412
413 sd = &ccissscsi[ctlr].dev[n];
414 if (lun == 0) {
415 if (find_bus_target_lun(ctlr,
416 &sd->bus, &sd->target, &sd->lun) != 0)
417 return -1;
418 } else {
419 sd->bus = bus;
420 sd->target = target;
421 sd->lun = lun;
422 }
Mike Millerf4a93bc2008-08-04 11:54:53 +0200423 added[*nadded].bus = sd->bus;
424 added[*nadded].target = sd->target;
425 added[*nadded].lun = sd->lun;
426 (*nadded)++;
427
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700428 memcpy(sd->scsi3addr, device->scsi3addr, 8);
429 memcpy(sd->vendor, device->vendor, sizeof(sd->vendor));
430 memcpy(sd->revision, device->revision, sizeof(sd->revision));
431 memcpy(sd->device_id, device->device_id, sizeof(sd->device_id));
432 sd->devtype = device->devtype;
433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 ccissscsi[ctlr].ndevices++;
435
436 /* initially, (before registering with scsi layer) we don't
437 know our hostno and we don't want to print anything first
438 time anyway (the scsi layer's inquiries will show that info) */
439 if (hostno != -1)
440 printk("cciss%d: %s device c%db%dt%dl%d added.\n",
Matthew Wilcox4ff36712006-07-04 12:15:20 -0600441 ctlr, scsi_device_type(sd->devtype), hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sd->bus, sd->target, sd->lun);
443 return 0;
444}
445
446static void
Mike Millerf4a93bc2008-08-04 11:54:53 +0200447cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
448 struct scsi2map *removed, int *nremoved)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 /* assumes hba[ctlr]->scsi_ctlr->lock is held */
451 int i;
452 struct cciss_scsi_dev_t sd;
453
454 if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
455 sd = ccissscsi[ctlr].dev[entry];
Mike Millerf4a93bc2008-08-04 11:54:53 +0200456 removed[*nremoved].bus = sd.bus;
457 removed[*nremoved].target = sd.target;
458 removed[*nremoved].lun = sd.lun;
459 (*nremoved)++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
461 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
462 ccissscsi[ctlr].ndevices--;
463 printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
Matthew Wilcox4ff36712006-07-04 12:15:20 -0600464 ctlr, scsi_device_type(sd.devtype), hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 sd.bus, sd.target, sd.lun);
466}
467
468
469#define SCSI3ADDR_EQ(a,b) ( \
470 (a)[7] == (b)[7] && \
471 (a)[6] == (b)[6] && \
472 (a)[5] == (b)[5] && \
473 (a)[4] == (b)[4] && \
474 (a)[3] == (b)[3] && \
475 (a)[2] == (b)[2] && \
476 (a)[1] == (b)[1] && \
477 (a)[0] == (b)[0])
478
Mike Millerf4a93bc2008-08-04 11:54:53 +0200479static void fixup_botched_add(int ctlr, char *scsi3addr)
480{
481 /* called when scsi_add_device fails in order to re-adjust */
482 /* ccissscsi[] to match the mid layer's view. */
483 unsigned long flags;
484 int i, j;
485 CPQ_TAPE_LOCK(ctlr, flags);
486 for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
487 if (memcmp(scsi3addr,
488 ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
489 for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
490 ccissscsi[ctlr].dev[j] =
491 ccissscsi[ctlr].dev[j+1];
492 ccissscsi[ctlr].ndevices--;
493 break;
494 }
495 }
496 CPQ_TAPE_UNLOCK(ctlr, flags);
497}
498
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700499static int device_is_the_same(struct cciss_scsi_dev_t *dev1,
500 struct cciss_scsi_dev_t *dev2)
501{
502 return dev1->devtype == dev2->devtype &&
503 memcmp(dev1->scsi3addr, dev2->scsi3addr,
504 sizeof(dev1->scsi3addr)) == 0 &&
505 memcmp(dev1->device_id, dev2->device_id,
506 sizeof(dev1->device_id)) == 0 &&
507 memcmp(dev1->vendor, dev2->vendor,
508 sizeof(dev1->vendor)) == 0 &&
509 memcmp(dev1->model, dev2->model,
510 sizeof(dev1->model)) == 0 &&
511 memcmp(dev1->revision, dev2->revision,
512 sizeof(dev1->revision)) == 0;
513}
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515static int
516adjust_cciss_scsi_table(int ctlr, int hostno,
517 struct cciss_scsi_dev_t sd[], int nsds)
518{
519 /* sd contains scsi3 addresses and devtypes, but
520 bus target and lun are not filled in. This funciton
521 takes what's in sd to be the current and adjusts
522 ccissscsi[] to be in line with what's in sd. */
523
524 int i,j, found, changes=0;
525 struct cciss_scsi_dev_t *csd;
526 unsigned long flags;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200527 struct scsi2map *added, *removed;
528 int nadded, nremoved;
529 struct Scsi_Host *sh = NULL;
530
531 added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
532 GFP_KERNEL);
533 removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
534 GFP_KERNEL);
535
536 if (!added || !removed) {
537 printk(KERN_WARNING "cciss%d: Out of memory in "
538 "adjust_cciss_scsi_table\n", ctlr);
539 goto free_and_out;
540 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
542 CPQ_TAPE_LOCK(ctlr, flags);
543
Mike Millerf4a93bc2008-08-04 11:54:53 +0200544 if (hostno != -1) /* if it's not the first time... */
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600545 sh = hba[ctlr]->scsi_ctlr->scsi_host;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* find any devices in ccissscsi[] that are not in
548 sd[] and remove them from ccissscsi[] */
549
550 i = 0;
Mike Millerf4a93bc2008-08-04 11:54:53 +0200551 nremoved = 0;
552 nadded = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 while(i<ccissscsi[ctlr].ndevices) {
554 csd = &ccissscsi[ctlr].dev[i];
555 found=0;
556 for (j=0;j<nsds;j++) {
557 if (SCSI3ADDR_EQ(sd[j].scsi3addr,
558 csd->scsi3addr)) {
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700559 if (device_is_the_same(&sd[j], csd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 found=2;
561 else
562 found=1;
563 break;
564 }
565 }
566
567 if (found == 0) { /* device no longer present. */
568 changes++;
569 /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
Matthew Wilcox4ff36712006-07-04 12:15:20 -0600570 ctlr, scsi_device_type(csd->devtype), hostno,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 csd->bus, csd->target, csd->lun); */
Mike Millerf4a93bc2008-08-04 11:54:53 +0200572 cciss_scsi_remove_entry(ctlr, hostno, i,
573 removed, &nremoved);
574 /* remove ^^^, hence i not incremented */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700575 } else if (found == 1) { /* device is different in some way */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 changes++;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700577 printk("cciss%d: device c%db%dt%dl%d has changed.\n",
578 ctlr, hostno, csd->bus, csd->target, csd->lun);
Mike Millerf4a93bc2008-08-04 11:54:53 +0200579 cciss_scsi_remove_entry(ctlr, hostno, i,
580 removed, &nremoved);
581 /* remove ^^^, hence i not incremented */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700582 if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
Mike Millerf4a93bc2008-08-04 11:54:53 +0200583 added, &nadded) != 0)
584 /* we just removed one, so add can't fail. */
585 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 csd->devtype = sd[j].devtype;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700587 memcpy(csd->device_id, sd[j].device_id,
588 sizeof(csd->device_id));
589 memcpy(csd->vendor, sd[j].vendor,
590 sizeof(csd->vendor));
591 memcpy(csd->model, sd[j].model,
592 sizeof(csd->model));
593 memcpy(csd->revision, sd[j].revision,
594 sizeof(csd->revision));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 } else /* device is same as it ever was, */
596 i++; /* so just move along. */
597 }
598
599 /* Now, make sure every device listed in sd[] is also
600 listed in ccissscsi[], adding them if they aren't found */
601
602 for (i=0;i<nsds;i++) {
603 found=0;
604 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
605 csd = &ccissscsi[ctlr].dev[j];
606 if (SCSI3ADDR_EQ(sd[i].scsi3addr,
607 csd->scsi3addr)) {
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700608 if (device_is_the_same(&sd[i], csd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 found=2; /* found device */
610 else
611 found=1; /* found a bug. */
612 break;
613 }
614 }
615 if (!found) {
616 changes++;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700617 if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
Mike Millerf4a93bc2008-08-04 11:54:53 +0200618 added, &nadded) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 break;
620 } else if (found == 1) {
621 /* should never happen... */
622 changes++;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -0700623 printk(KERN_WARNING "cciss%d: device "
624 "unexpectedly changed\n", ctlr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* but if it does happen, we just ignore that device */
626 }
627 }
628 CPQ_TAPE_UNLOCK(ctlr, flags);
629
Mike Millerf4a93bc2008-08-04 11:54:53 +0200630 /* Don't notify scsi mid layer of any changes the first time through */
631 /* (or if there are no changes) scsi_scan_host will do it later the */
632 /* first time through. */
633 if (hostno == -1 || !changes)
634 goto free_and_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Mike Millerf4a93bc2008-08-04 11:54:53 +0200636 /* Notify scsi mid layer of any removed devices */
637 for (i = 0; i < nremoved; i++) {
638 struct scsi_device *sdev =
639 scsi_device_lookup(sh, removed[i].bus,
640 removed[i].target, removed[i].lun);
641 if (sdev != NULL) {
642 scsi_remove_device(sdev);
643 scsi_device_put(sdev);
644 } else {
645 /* We don't expect to get here. */
646 /* future cmds to this device will get selection */
647 /* timeout as if the device was gone. */
648 printk(KERN_WARNING "cciss%d: didn't find "
649 "c%db%dt%dl%d\n for removal.",
650 ctlr, hostno, removed[i].bus,
651 removed[i].target, removed[i].lun);
652 }
653 }
654
655 /* Notify scsi mid layer of any added devices */
656 for (i = 0; i < nadded; i++) {
657 int rc;
658 rc = scsi_add_device(sh, added[i].bus,
659 added[i].target, added[i].lun);
660 if (rc == 0)
661 continue;
662 printk(KERN_WARNING "cciss%d: scsi_add_device "
663 "c%db%dt%dl%d failed, device not added.\n",
664 ctlr, hostno,
665 added[i].bus, added[i].target, added[i].lun);
666 /* now we have to remove it from ccissscsi, */
667 /* since it didn't get added to scsi mid layer */
668 fixup_botched_add(ctlr, added[i].scsi3addr);
669 }
670
671free_and_out:
672 kfree(added);
673 kfree(removed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 return 0;
675}
676
677static int
678lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
679{
680 int i;
681 struct cciss_scsi_dev_t *sd;
682 unsigned long flags;
683
684 CPQ_TAPE_LOCK(ctlr, flags);
685 for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
686 sd = &ccissscsi[ctlr].dev[i];
687 if (sd->bus == bus &&
688 sd->target == target &&
689 sd->lun == lun) {
690 memcpy(scsi3addr, &sd->scsi3addr[0], 8);
691 CPQ_TAPE_UNLOCK(ctlr, flags);
692 return 0;
693 }
694 }
695 CPQ_TAPE_UNLOCK(ctlr, flags);
696 return -1;
697}
698
699static void
700cciss_scsi_setup(int cntl_num)
701{
702 struct cciss_scsi_adapter_data_t * shba;
703
704 ccissscsi[cntl_num].ndevices = 0;
705 shba = (struct cciss_scsi_adapter_data_t *)
706 kmalloc(sizeof(*shba), GFP_KERNEL);
707 if (shba == NULL)
708 return;
709 shba->scsi_host = NULL;
710 spin_lock_init(&shba->lock);
711 shba->registered = 0;
712 if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
713 kfree(shba);
714 shba = NULL;
715 }
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600716 hba[cntl_num]->scsi_ctlr = shba;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return;
718}
719
720static void
721complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
722{
723 struct scsi_cmnd *cmd;
724 ctlr_info_t *ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 ErrorInfo_struct *ei;
726
727 ei = cp->err_info;
728
729 /* First, see if it was a message rather than a command */
730 if (cp->Request.Type.Type == TYPE_MSG) {
731 cp->cmd_type = CMD_MSG_DONE;
732 return;
733 }
734
735 cmd = (struct scsi_cmnd *) cp->scsi_cmd;
736 ctlr = hba[cp->ctlr];
737
FUJITA Tomonori41ce6392007-05-26 02:45:17 +0900738 scsi_dma_unmap(cmd);
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600739 if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
740 cciss_unmap_sg_chain_block(ctlr, cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 cmd->result = (DID_OK << 16); /* host byte */
743 cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
744 /* cmd->result |= (GOOD < 1); */ /* status byte */
745
746 cmd->result |= (ei->ScsiStatus);
747 /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus); */
748
749 /* copy the sense data whether we need to or not. */
750
751 memcpy(cmd->sense_buffer, ei->SenseInfo,
752 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
753 SCSI_SENSE_BUFFERSIZE :
754 ei->SenseLen);
FUJITA Tomonori41ce6392007-05-26 02:45:17 +0900755 scsi_set_resid(cmd, ei->ResidualCnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 if(ei->CommandStatus != 0)
758 { /* an error has occurred */
759 switch(ei->CommandStatus)
760 {
761 case CMD_TARGET_STATUS:
762 /* Pass it up to the upper layers... */
763 if( ei->ScsiStatus)
764 {
765#if 0
766 printk(KERN_WARNING "cciss: cmd %p "
767 "has SCSI Status = %x\n",
768 cp,
769 ei->ScsiStatus);
770#endif
Stephen M. Cameronb0e15f62009-11-12 12:49:45 -0600771 cmd->result |= (ei->ScsiStatus << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
773 else { /* scsi status is zero??? How??? */
774
775 /* Ordinarily, this case should never happen, but there is a bug
776 in some released firmware revisions that allows it to happen
777 if, for example, a 4100 backplane loses power and the tape
778 drive is in it. We assume that it's a fatal error of some
779 kind because we can't show that it wasn't. We will make it
780 look like selection timeout since that is the most common
781 reason for this to occur, and it's severe enough. */
782
783 cmd->result = DID_NO_CONNECT << 16;
784 }
785 break;
786 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
787 break;
788 case CMD_DATA_OVERRUN:
789 printk(KERN_WARNING "cciss: cp %p has"
790 " completed with data overrun "
791 "reported\n", cp);
792 break;
793 case CMD_INVALID: {
794 /* print_bytes(cp, sizeof(*cp), 1, 0);
795 print_cmd(cp); */
796 /* We get CMD_INVALID if you address a non-existent tape drive instead
797 of a selection timeout (no response). You will see this if you yank
798 out a tape drive, then try to access it. This is kind of a shame
799 because it means that any other CMD_INVALID (e.g. driver bug) will
800 get interpreted as a missing target. */
801 cmd->result = DID_NO_CONNECT << 16;
802 }
803 break;
804 case CMD_PROTOCOL_ERR:
805 printk(KERN_WARNING "cciss: cp %p has "
806 "protocol error \n", cp);
807 break;
808 case CMD_HARDWARE_ERR:
809 cmd->result = DID_ERROR << 16;
810 printk(KERN_WARNING "cciss: cp %p had "
811 " hardware error\n", cp);
812 break;
813 case CMD_CONNECTION_LOST:
814 cmd->result = DID_ERROR << 16;
815 printk(KERN_WARNING "cciss: cp %p had "
816 "connection lost\n", cp);
817 break;
818 case CMD_ABORTED:
819 cmd->result = DID_ABORT << 16;
820 printk(KERN_WARNING "cciss: cp %p was "
821 "aborted\n", cp);
822 break;
823 case CMD_ABORT_FAILED:
824 cmd->result = DID_ERROR << 16;
825 printk(KERN_WARNING "cciss: cp %p reports "
826 "abort failed\n", cp);
827 break;
828 case CMD_UNSOLICITED_ABORT:
829 cmd->result = DID_ABORT << 16;
830 printk(KERN_WARNING "cciss: cp %p aborted "
831 "do to an unsolicited abort\n", cp);
832 break;
833 case CMD_TIMEOUT:
834 cmd->result = DID_TIME_OUT << 16;
835 printk(KERN_WARNING "cciss: cp %p timedout\n",
836 cp);
837 break;
838 default:
839 cmd->result = DID_ERROR << 16;
840 printk(KERN_WARNING "cciss: cp %p returned "
841 "unknown status %x\n", cp,
842 ei->CommandStatus);
843 }
844 }
845 // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel,
846 // cmd->target, cmd->lun);
847 cmd->scsi_done(cmd);
848 scsi_cmd_free(ctlr, cp);
849}
850
851static int
852cciss_scsi_detect(int ctlr)
853{
854 struct Scsi_Host *sh;
855 int error;
856
857 sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
858 if (sh == NULL)
859 goto fail;
860 sh->io_port = 0; // good enough? FIXME,
861 sh->n_io_port = 0; // I don't think we use these two...
862 sh->this_id = SELF_SCSI_ID;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -0600863 sh->sg_tablesize = hba[ctlr]->maxsgentries;
Stephen M. Cameron79600aa2010-06-15 08:12:34 +0200864 sh->max_cmd_len = MAX_COMMAND_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 ((struct cciss_scsi_adapter_data_t *)
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -0600867 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 sh->hostdata[0] = (unsigned long) hba[ctlr];
Mike Millerfb86a352006-01-08 01:03:50 -0800869 sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 sh->unique_id = sh->irq;
871 error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
872 if (error)
873 goto fail_host_put;
874 scsi_scan_host(sh);
875 return 1;
876
877 fail_host_put:
878 scsi_host_put(sh);
879 fail:
880 return 0;
881}
882
883static void
884cciss_unmap_one(struct pci_dev *pdev,
885 CommandList_struct *cp,
886 size_t buflen,
887 int data_direction)
888{
889 u64bit addr64;
890
891 addr64.val32.lower = cp->SG[0].Addr.lower;
892 addr64.val32.upper = cp->SG[0].Addr.upper;
893 pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
894}
895
896static void
897cciss_map_one(struct pci_dev *pdev,
898 CommandList_struct *cp,
899 unsigned char *buf,
900 size_t buflen,
901 int data_direction)
902{
903 __u64 addr64;
904
905 addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
906 cp->SG[0].Addr.lower =
907 (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
908 cp->SG[0].Addr.upper =
909 (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
910 cp->SG[0].Len = buflen;
911 cp->Header.SGList = (__u8) 1; /* no. SGs contig in this cmd */
912 cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
913}
914
915static int
916cciss_scsi_do_simple_cmd(ctlr_info_t *c,
917 CommandList_struct *cp,
918 unsigned char *scsi3addr,
919 unsigned char *cdb,
920 unsigned char cdblen,
921 unsigned char *buf, int bufsize,
922 int direction)
923{
924 unsigned long flags;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -0700925 DECLARE_COMPLETION_ONSTACK(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 cp->cmd_type = CMD_IOCTL_PEND; // treat this like an ioctl
928 cp->scsi_cmd = NULL;
929 cp->Header.ReplyQueue = 0; // unused in simple mode
930 memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
931 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
932 // Fill in the request block...
933
934 /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n",
935 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
936 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
937
938 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
939 memcpy(cp->Request.CDB, cdb, cdblen);
940 cp->Request.Timeout = 0;
941 cp->Request.CDBLen = cdblen;
942 cp->Request.Type.Type = TYPE_CMD;
943 cp->Request.Type.Attribute = ATTR_SIMPLE;
944 cp->Request.Type.Direction = direction;
945
946 /* Fill in the SG list and do dma mapping */
947 cciss_map_one(c->pdev, cp, (unsigned char *) buf,
948 bufsize, DMA_FROM_DEVICE);
949
950 cp->waiting = &wait;
951
952 /* Put the request on the tail of the request queue */
953 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
954 addQ(&c->reqQ, cp);
955 c->Qdepth++;
956 start_io(c);
957 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
958
959 wait_for_completion(&wait);
960
961 /* undo the dma mapping */
962 cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
963 return(0);
964}
965
966static void
967cciss_scsi_interpret_error(CommandList_struct *cp)
968{
969 ErrorInfo_struct *ei;
970
971 ei = cp->err_info;
972 switch(ei->CommandStatus)
973 {
974 case CMD_TARGET_STATUS:
975 printk(KERN_WARNING "cciss: cmd %p has "
976 "completed with errors\n", cp);
977 printk(KERN_WARNING "cciss: cmd %p "
978 "has SCSI Status = %x\n",
979 cp,
980 ei->ScsiStatus);
981 if (ei->ScsiStatus == 0)
982 printk(KERN_WARNING
983 "cciss:SCSI status is abnormally zero. "
984 "(probably indicates selection timeout "
985 "reported incorrectly due to a known "
986 "firmware bug, circa July, 2001.)\n");
987 break;
988 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
989 printk("UNDERRUN\n");
990 break;
991 case CMD_DATA_OVERRUN:
992 printk(KERN_WARNING "cciss: cp %p has"
993 " completed with data overrun "
994 "reported\n", cp);
995 break;
996 case CMD_INVALID: {
997 /* controller unfortunately reports SCSI passthru's */
998 /* to non-existent targets as invalid commands. */
999 printk(KERN_WARNING "cciss: cp %p is "
1000 "reported invalid (probably means "
1001 "target device no longer present)\n",
1002 cp);
1003 /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
1004 print_cmd(cp); */
1005 }
1006 break;
1007 case CMD_PROTOCOL_ERR:
1008 printk(KERN_WARNING "cciss: cp %p has "
1009 "protocol error \n", cp);
1010 break;
1011 case CMD_HARDWARE_ERR:
1012 /* cmd->result = DID_ERROR << 16; */
1013 printk(KERN_WARNING "cciss: cp %p had "
1014 " hardware error\n", cp);
1015 break;
1016 case CMD_CONNECTION_LOST:
1017 printk(KERN_WARNING "cciss: cp %p had "
1018 "connection lost\n", cp);
1019 break;
1020 case CMD_ABORTED:
1021 printk(KERN_WARNING "cciss: cp %p was "
1022 "aborted\n", cp);
1023 break;
1024 case CMD_ABORT_FAILED:
1025 printk(KERN_WARNING "cciss: cp %p reports "
1026 "abort failed\n", cp);
1027 break;
1028 case CMD_UNSOLICITED_ABORT:
1029 printk(KERN_WARNING "cciss: cp %p aborted "
1030 "do to an unsolicited abort\n", cp);
1031 break;
1032 case CMD_TIMEOUT:
1033 printk(KERN_WARNING "cciss: cp %p timedout\n",
1034 cp);
1035 break;
1036 default:
1037 printk(KERN_WARNING "cciss: cp %p returned "
1038 "unknown status %x\n", cp,
1039 ei->CommandStatus);
1040 }
1041}
1042
1043static int
1044cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001045 unsigned char page, unsigned char *buf,
1046 unsigned char bufsize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047{
1048 int rc;
1049 CommandList_struct *cp;
1050 char cdb[6];
1051 ErrorInfo_struct *ei;
1052 unsigned long flags;
1053
1054 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1055 cp = scsi_cmd_alloc(c);
1056 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1057
1058 if (cp == NULL) { /* trouble... */
1059 printk("cmd_alloc returned NULL!\n");
1060 return -1;
1061 }
1062
1063 ei = cp->err_info;
1064
1065 cdb[0] = CISS_INQUIRY;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001066 cdb[1] = (page != 0);
1067 cdb[2] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 cdb[3] = 0;
Mike Miller47922d02005-09-13 01:25:25 -07001069 cdb[4] = bufsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 cdb[5] = 0;
1071 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb,
Mike Miller47922d02005-09-13 01:25:25 -07001072 6, buf, bufsize, XFER_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
1074 if (rc != 0) return rc; /* something went wrong */
1075
1076 if (ei->CommandStatus != 0 &&
1077 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1078 cciss_scsi_interpret_error(cp);
1079 rc = -1;
1080 }
1081 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1082 scsi_cmd_free(c, cp);
1083 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1084 return rc;
1085}
1086
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001087/* Get the device id from inquiry page 0x83 */
1088static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1089 unsigned char *device_id, int buflen)
1090{
1091 int rc;
1092 unsigned char *buf;
1093
1094 if (buflen > 16)
1095 buflen = 16;
1096 buf = kzalloc(64, GFP_KERNEL);
1097 if (!buf)
1098 return -1;
1099 rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1100 if (rc == 0)
1101 memcpy(device_id, &buf[8], buflen);
1102 kfree(buf);
1103 return rc != 0;
1104}
1105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106static int
1107cciss_scsi_do_report_phys_luns(ctlr_info_t *c,
1108 ReportLunData_struct *buf, int bufsize)
1109{
1110 int rc;
1111 CommandList_struct *cp;
1112 unsigned char cdb[12];
1113 unsigned char scsi3addr[8];
1114 ErrorInfo_struct *ei;
1115 unsigned long flags;
1116
1117 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1118 cp = scsi_cmd_alloc(c);
1119 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1120 if (cp == NULL) { /* trouble... */
1121 printk("cmd_alloc returned NULL!\n");
1122 return -1;
1123 }
1124
1125 memset(&scsi3addr[0], 0, 8); /* address the controller */
1126 cdb[0] = CISS_REPORT_PHYS;
1127 cdb[1] = 0;
1128 cdb[2] = 0;
1129 cdb[3] = 0;
1130 cdb[4] = 0;
1131 cdb[5] = 0;
1132 cdb[6] = (bufsize >> 24) & 0xFF; //MSB
1133 cdb[7] = (bufsize >> 16) & 0xFF;
1134 cdb[8] = (bufsize >> 8) & 0xFF;
1135 cdb[9] = bufsize & 0xFF;
1136 cdb[10] = 0;
1137 cdb[11] = 0;
1138
1139 rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr,
1140 cdb, 12,
1141 (unsigned char *) buf,
1142 bufsize, XFER_READ);
1143
1144 if (rc != 0) return rc; /* something went wrong */
1145
1146 ei = cp->err_info;
1147 if (ei->CommandStatus != 0 &&
1148 ei->CommandStatus != CMD_DATA_UNDERRUN) {
1149 cciss_scsi_interpret_error(cp);
1150 rc = -1;
1151 }
1152 spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1153 scsi_cmd_free(c, cp);
1154 spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1155 return rc;
1156}
1157
1158static void
1159cciss_update_non_disk_devices(int cntl_num, int hostno)
1160{
1161 /* the idea here is we could get notified from /proc
1162 that some devices have changed, so we do a report
1163 physical luns cmd, and adjust our list of devices
1164 accordingly. (We can't rely on the scsi-mid layer just
1165 doing inquiries, because the "busses" that the scsi
1166 mid-layer probes are totally fabricated by this driver,
1167 so new devices wouldn't show up.
1168
1169 the scsi3addr's of devices won't change so long as the
1170 adapter is not reset. That means we can rescan and
1171 tell which devices we already know about, vs. new
1172 devices, vs. disappearing devices.
1173
1174 Also, if you yank out a tape drive, then put in a disk
1175 in it's place, (say, a configured volume from another
1176 array controller for instance) _don't_ poke this driver
1177 (so it thinks it's still a tape, but _do_ poke the scsi
1178 mid layer, so it does an inquiry... the scsi mid layer
1179 will see the physical disk. This would be bad. Need to
1180 think about how to prevent that. One idea would be to
1181 snoop all scsi responses and if an inquiry repsonse comes
1182 back that reports a disk, chuck it an return selection
1183 timeout instead and adjust our table... Not sure i like
1184 that though.
1185
1186 */
Mike Miller47922d02005-09-13 01:25:25 -07001187#define OBDR_TAPE_INQ_SIZE 49
1188#define OBDR_TAPE_SIG "$DR-10"
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 ReportLunData_struct *ld_buff;
Mike Miller47922d02005-09-13 01:25:25 -07001190 unsigned char *inq_buff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 unsigned char scsi3addr[8];
1192 ctlr_info_t *c;
1193 __u32 num_luns=0;
1194 unsigned char *ch;
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001195 struct cciss_scsi_dev_t *currentsd, *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 int ncurrent=0;
1197 int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1198 int i;
1199
1200 c = (ctlr_info_t *) hba[cntl_num];
Eric Sesterhenn06ff37f2006-03-08 11:21:52 +01001201 ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
Mike Miller47922d02005-09-13 01:25:25 -07001202 inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001203 currentsd = kzalloc(sizeof(*currentsd) *
1204 (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1205 if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1206 printk(KERN_ERR "cciss: out of memory\n");
1207 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001209 this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1211 ch = &ld_buff->LUNListLength[0];
1212 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1213 if (num_luns > CISS_MAX_PHYS_LUN) {
1214 printk(KERN_WARNING
1215 "cciss: Maximum physical LUNs (%d) exceeded. "
1216 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN,
1217 num_luns - CISS_MAX_PHYS_LUN);
1218 num_luns = CISS_MAX_PHYS_LUN;
1219 }
1220 }
1221 else {
1222 printk(KERN_ERR "cciss: Report physical LUNs failed.\n");
1223 goto out;
1224 }
1225
1226
1227 /* adjust our table of devices */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001228 for (i = 0; i < num_luns; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 /* for each physical lun, do an inquiry */
1230 if (ld_buff->LUN[i][3] & 0xC0) continue;
Mike Miller47922d02005-09-13 01:25:25 -07001231 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1233
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001234 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1235 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 /* Inquiry failed (msg printed already) */
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001237 continue; /* so we will skip this device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001239 this_device->devtype = (inq_buff[0] & 0x1f);
1240 this_device->bus = -1;
1241 this_device->target = -1;
1242 this_device->lun = -1;
1243 memcpy(this_device->scsi3addr, scsi3addr, 8);
1244 memcpy(this_device->vendor, &inq_buff[8],
1245 sizeof(this_device->vendor));
1246 memcpy(this_device->model, &inq_buff[16],
1247 sizeof(this_device->model));
1248 memcpy(this_device->revision, &inq_buff[32],
1249 sizeof(this_device->revision));
1250 memset(this_device->device_id, 0,
1251 sizeof(this_device->device_id));
1252 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1253 this_device->device_id, sizeof(this_device->device_id));
1254
1255 switch (this_device->devtype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 {
Mike Miller47922d02005-09-13 01:25:25 -07001257 case 0x05: /* CD-ROM */ {
1258
1259 /* We don't *really* support actual CD-ROM devices,
1260 * just this "One Button Disaster Recovery" tape drive
1261 * which temporarily pretends to be a CD-ROM drive.
1262 * So we check that the device is really an OBDR tape
1263 * device by checking for "$DR-10" in bytes 43-48 of
1264 * the inquiry data.
1265 */
1266 char obdr_sig[7];
1267
1268 strncpy(obdr_sig, &inq_buff[43], 6);
1269 obdr_sig[6] = '\0';
1270 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1271 /* Not OBDR device, ignore it. */
1272 break;
1273 }
1274 /* fall through . . . */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 case 0x01: /* sequential access, (tape) */
1276 case 0x08: /* medium changer */
1277 if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1278 printk(KERN_INFO "cciss%d: %s ignored, "
1279 "too many devices.\n", cntl_num,
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001280 scsi_device_type(this_device->devtype));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 break;
1282 }
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001283 currentsd[ncurrent] = *this_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 ncurrent++;
1285 break;
1286 default:
1287 break;
1288 }
1289 }
1290
1291 adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1292out:
1293 kfree(inq_buff);
1294 kfree(ld_buff);
scameron@beardog.cca.cpqcorp.net905bd782008-09-19 18:27:47 -07001295 kfree(currentsd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 return;
1297}
1298
1299static int
1300is_keyword(char *ptr, int len, char *verb) // Thanks to ncr53c8xx.c
1301{
1302 int verb_len = strlen(verb);
1303 if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1304 return verb_len;
1305 else
1306 return 0;
1307}
1308
1309static int
1310cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1311{
1312 int arg_len;
1313
1314 if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1315 cciss_update_non_disk_devices(ctlr, hostno);
1316 else
1317 return -EINVAL;
1318 return length;
1319}
1320
1321
1322static int
1323cciss_scsi_proc_info(struct Scsi_Host *sh,
1324 char *buffer, /* data buffer */
1325 char **start, /* where data in buffer starts */
1326 off_t offset, /* offset from start of imaginary file */
1327 int length, /* length of data in buffer */
1328 int func) /* 0 == read, 1 == write */
1329{
1330
1331 int buflen, datalen;
1332 ctlr_info_t *ci;
Mike Millerb9f0bd02005-09-13 01:25:26 -07001333 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 int cntl_num;
1335
1336
1337 ci = (ctlr_info_t *) sh->hostdata[0];
1338 if (ci == NULL) /* This really shouldn't ever happen. */
1339 return -EINVAL;
1340
1341 cntl_num = ci->ctlr; /* Get our index into the hba[] array */
1342
1343 if (func == 0) { /* User is reading from /proc/scsi/ciss*?/?* */
Mike Millerb9f0bd02005-09-13 01:25:26 -07001344 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1345 cntl_num, sh->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Mike Millerb9f0bd02005-09-13 01:25:26 -07001347 /* this information is needed by apps to know which cciss
1348 device corresponds to which scsi host number without
1349 having to open a scsi target device node. The device
1350 information is not a duplicate of /proc/scsi/scsi because
1351 the two may be out of sync due to scsi hotplug, rather
1352 this info is for an app to be able to use to know how to
1353 get them back in sync. */
1354
1355 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1356 struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1357 buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1358 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1359 sh->host_no, sd->bus, sd->target, sd->lun,
1360 sd->devtype,
1361 sd->scsi3addr[0], sd->scsi3addr[1],
1362 sd->scsi3addr[2], sd->scsi3addr[3],
1363 sd->scsi3addr[4], sd->scsi3addr[5],
1364 sd->scsi3addr[6], sd->scsi3addr[7]);
1365 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 datalen = buflen - offset;
1367 if (datalen < 0) { /* they're reading past EOF. */
1368 datalen = 0;
1369 *start = buffer+buflen;
1370 } else
1371 *start = buffer + offset;
1372 return(datalen);
1373 } else /* User is writing to /proc/scsi/cciss*?/?* ... */
1374 return cciss_scsi_user_command(cntl_num, sh->host_no,
1375 buffer, length);
1376}
1377
1378/* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
1379 dma mapping and fills in the scatter gather entries of the
1380 cciss command, cp. */
1381
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001382static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1383 struct scsi_cmnd *cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384{
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001385 unsigned int len;
1386 struct scatterlist *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 __u64 addr64;
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001388 int request_nsgs, i, chained, sg_index;
1389 struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1390 SGDescriptor_struct *curr_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001392 BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001394 chained = 0;
1395 sg_index = 0;
1396 curr_sg = cp->SG;
1397 request_nsgs = scsi_dma_map(cmd);
1398 if (request_nsgs) {
1399 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1400 if (sg_index + 1 == h->max_cmd_sgentries &&
1401 !chained && request_nsgs - i > 1) {
1402 chained = 1;
1403 sg_index = 0;
1404 curr_sg = sa->cmd_sg_list[cp->cmdindex];
1405 }
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001406 addr64 = (__u64) sg_dma_address(sg);
1407 len = sg_dma_len(sg);
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001408 curr_sg[sg_index].Addr.lower =
1409 (__u32) (addr64 & 0x0FFFFFFFFULL);
1410 curr_sg[sg_index].Addr.upper =
1411 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1412 curr_sg[sg_index].Len = len;
1413 curr_sg[sg_index].Ext = 0;
1414 ++sg_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001416 if (chained)
1417 cciss_map_sg_chain_block(h, cp,
1418 sa->cmd_sg_list[cp->cmdindex],
1419 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1420 sizeof(SGDescriptor_struct));
FUJITA Tomonori41ce6392007-05-26 02:45:17 +09001421 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001422 /* track how many SG entries we are using */
1423 if (request_nsgs > h->maxSG)
1424 h->maxSG = request_nsgs;
1425 cp->Header.SGTotal = (__u8) request_nsgs + chained;
1426 if (request_nsgs > h->max_cmd_sgentries)
1427 cp->Header.SGList = h->max_cmd_sgentries;
1428 else
1429 cp->Header.SGList = cp->Header.SGTotal;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 return;
1431}
1432
1433
1434static int
1435cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1436{
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001437 ctlr_info_t *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 int ctlr, rc;
1439 unsigned char scsi3addr[8];
1440 CommandList_struct *cp;
1441 unsigned long flags;
1442
1443 // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1444 // We violate cmd->host privacy here. (Is there another way?)
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001445 c = (ctlr_info_t *) cmd->device->host->hostdata[0];
1446 ctlr = c->ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448 rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id,
1449 cmd->device->lun, scsi3addr);
1450 if (rc != 0) {
1451 /* the scsi nexus does not match any that we presented... */
1452 /* pretend to mid layer that we got selection timeout */
1453 cmd->result = DID_NO_CONNECT << 16;
1454 done(cmd);
1455 /* we might want to think about registering controller itself
1456 as a processor device on the bus so sg binds to it. */
1457 return 0;
1458 }
1459
1460 /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n",
1461 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1462 // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel,
1463 // cmd->target, cmd->lun);
1464
1465 /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1466 see what the device thinks of it. */
1467
1468 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001469 cp = scsi_cmd_alloc(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1471 if (cp == NULL) { /* trouble... */
1472 printk("scsi_cmd_alloc returned NULL!\n");
1473 /* FIXME: next 3 lines are -> BAD! <- */
1474 cmd->result = DID_NO_CONNECT << 16;
1475 done(cmd);
1476 return 0;
1477 }
1478
1479 // Fill in the command list header
1480
1481 cmd->scsi_done = done; // save this for use by completion code
1482
1483 // save cp in case we have to abort it
1484 cmd->host_scribble = (unsigned char *) cp;
1485
1486 cp->cmd_type = CMD_SCSI;
1487 cp->scsi_cmd = cmd;
1488 cp->Header.ReplyQueue = 0; // unused in simple mode
1489 memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1490 cp->Header.Tag.lower = cp->busaddr; // Use k. address of cmd as tag
1491
1492 // Fill in the request block...
1493
1494 cp->Request.Timeout = 0;
1495 memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
Eric Sesterhenn089fe1b2006-03-24 18:50:27 +01001496 BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 cp->Request.CDBLen = cmd->cmd_len;
1498 memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1499 cp->Request.Type.Type = TYPE_CMD;
1500 cp->Request.Type.Attribute = ATTR_SIMPLE;
1501 switch(cmd->sc_data_direction)
1502 {
1503 case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1504 case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1505 case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1506 case DMA_BIDIRECTIONAL:
1507 // This can happen if a buggy application does a scsi passthru
1508 // and sets both inlen and outlen to non-zero. ( see
1509 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1510
1511 cp->Request.Type.Direction = XFER_RSVD;
1512 // This is technically wrong, and cciss controllers should
1513 // reject it with CMD_INVALID, which is the most correct
1514 // response, but non-fibre backends appear to let it
1515 // slide by, and give the same results as if this field
1516 // were set correctly. Either way is acceptable for
1517 // our purposes here.
1518
1519 break;
1520
1521 default:
1522 printk("cciss: unknown data direction: %d\n",
1523 cmd->sc_data_direction);
1524 BUG();
1525 break;
1526 }
Stephen M. Cameron87c3a922010-02-26 16:01:53 -06001527 cciss_scatter_gather(c, cp, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
1529 /* Put the request on the tail of the request queue */
1530
1531 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001532 addQ(&c->reqQ, cp);
1533 c->Qdepth++;
1534 start_io(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1536
1537 /* the cmd'll come back via intr handler in complete_scsi_command() */
1538 return 0;
1539}
1540
1541static void
1542cciss_unregister_scsi(int ctlr)
1543{
1544 struct cciss_scsi_adapter_data_t *sa;
1545 struct cciss_scsi_cmd_stack_t *stk;
1546 unsigned long flags;
1547
1548 /* we are being forcibly unloaded, and may not refuse. */
1549
1550 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -06001551 sa = hba[ctlr]->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 stk = &sa->cmd_stack;
1553
1554 /* if we weren't ever actually registered, don't unregister */
1555 if (sa->registered) {
1556 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1557 scsi_remove_host(sa->scsi_host);
1558 scsi_host_put(sa->scsi_host);
1559 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1560 }
1561
1562 /* set scsi_host to NULL so our detect routine will
1563 find us on register */
1564 sa->scsi_host = NULL;
scameron@beardog.cca.cpqcorp.net61950572008-04-17 13:19:04 +02001565 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 scsi_cmd_stack_free(ctlr);
1567 kfree(sa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568}
1569
1570static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571cciss_engage_scsi(int ctlr)
1572{
1573 struct cciss_scsi_adapter_data_t *sa;
1574 struct cciss_scsi_cmd_stack_t *stk;
1575 unsigned long flags;
1576
1577 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
Stephen M. Cameronaad9fb62010-02-26 16:01:42 -06001578 sa = hba[ctlr]->scsi_ctlr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 stk = &sa->cmd_stack;
1580
Mike Millerf4a93bc2008-08-04 11:54:53 +02001581 if (sa->registered) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1583 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
Stephen M. Cameron8721c812009-11-12 12:50:06 -06001584 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
Mike Millerf4a93bc2008-08-04 11:54:53 +02001586 sa->registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1588 cciss_update_non_disk_devices(ctlr, -1);
Mike Millerf4a93bc2008-08-04 11:54:53 +02001589 cciss_scsi_detect(ctlr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 return 0;
1591}
1592
1593static void
Mike Miller89b6e742008-02-21 08:54:03 +01001594cciss_seq_tape_report(struct seq_file *seq, int ctlr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595{
1596 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598 CPQ_TAPE_LOCK(ctlr, flags);
Mike Miller89b6e742008-02-21 08:54:03 +01001599 seq_printf(seq,
Mike Millerb9f0bd02005-09-13 01:25:26 -07001600 "Sequential access devices: %d\n\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 ccissscsi[ctlr].ndevices);
1602 CPQ_TAPE_UNLOCK(ctlr, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603}
1604
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001605static int wait_for_device_to_become_ready(ctlr_info_t *h,
1606 unsigned char lunaddr[])
1607{
1608 int rc;
1609 int count = 0;
1610 int waittime = HZ;
1611 CommandList_struct *c;
1612
1613 c = cmd_alloc(h, 1);
1614 if (!c) {
1615 printk(KERN_WARNING "cciss%d: out of memory in "
1616 "wait_for_device_to_become_ready.\n", h->ctlr);
1617 return IO_ERROR;
1618 }
1619
1620 /* Send test unit ready until device ready, or give up. */
1621 while (count < 20) {
1622
1623 /* Wait for a bit. do this first, because if we send
1624 * the TUR right away, the reset will just abort it.
1625 */
scameron@beardog.cca.cpqcorp.net40df6ae2009-06-08 15:59:38 -05001626 schedule_timeout_uninterruptible(waittime);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001627 count++;
1628
1629 /* Increase wait time with each try, up to a point. */
1630 if (waittime < (HZ * 30))
1631 waittime = waittime * 2;
1632
1633 /* Send the Test Unit Ready */
scameron@beardog.cca.cpqcorp.netb57695f2009-06-08 16:02:17 -05001634 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001635 lunaddr, TYPE_CMD);
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001636 if (rc == 0)
1637 rc = sendcmd_withirq_core(h, c, 0);
1638
1639 (void) process_sendcmd_error(h, c);
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001640
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001641 if (rc != 0)
1642 goto retry_tur;
1643
1644 if (c->err_info->CommandStatus == CMD_SUCCESS)
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001645 break;
1646
scameron@beardog.cca.cpqcorp.net39692512009-06-08 16:10:57 -05001647 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1648 c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1649 if (c->err_info->SenseInfo[2] == NO_SENSE)
1650 break;
1651 if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1652 unsigned char asc;
1653 asc = c->err_info->SenseInfo[12];
1654 check_for_unit_attention(h, c);
1655 if (asc == POWER_OR_RESET)
1656 break;
1657 }
1658 }
1659retry_tur:
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001660 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1661 "for device to become ready.\n",
1662 h->ctlr, waittime / HZ);
1663 rc = 1; /* device not ready. */
1664 }
1665
1666 if (rc)
1667 printk("cciss%d: giving up on device.\n", h->ctlr);
1668 else
1669 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1670
1671 cmd_free(h, c, 1);
1672 return rc;
1673}
Mike Miller89b6e742008-02-21 08:54:03 +01001674
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001675/* Need at least one of these error handlers to keep ../scsi/hosts.c from
1676 * complaining. Doing a host- or bus-reset can't do anything good here.
1677 * Despite what it might say in scsi_error.c, there may well be commands
1678 * on the controller, as the cciss driver registers twice, once as a block
1679 * device for the logical drives, and once as a scsi device, for any tape
1680 * drives. So we know there are no commands out on the tape drives, but we
1681 * don't know there are no commands on the controller, and it is likely
1682 * that there probably are, as the cciss block device is most commonly used
1683 * as a boot device (embedded controller on HP/Compaq systems.)
1684*/
1685
1686static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1687{
1688 int rc;
1689 CommandList_struct *cmd_in_trouble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001690 unsigned char lunaddr[8];
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001691 ctlr_info_t *c;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001692 int ctlr;
1693
1694 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001695 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001696 if (c == NULL) /* paranoia */
1697 return FAILED;
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001698 ctlr = c->ctlr;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001699 printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001700 /* find the command that's giving us trouble */
1701 cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001702 if (cmd_in_trouble == NULL) /* paranoia */
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001703 return FAILED;
Stephen M. Cameron88f627a2009-06-02 14:48:11 +02001704 memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001705 /* send a reset to the SCSI LUN which the command was sent to */
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001706 rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001707 TYPE_MSG);
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001708 if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001709 return SUCCESS;
1710 printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1711 return FAILED;
1712}
1713
1714static int cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1715{
1716 int rc;
1717 CommandList_struct *cmd_to_abort;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001718 unsigned char lunaddr[8];
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001719 ctlr_info_t *c;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001720 int ctlr;
1721
1722 /* find the controller to which the command to be aborted was sent */
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001723 c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001724 if (c == NULL) /* paranoia */
1725 return FAILED;
Stephen M. Cameronbf887372010-02-26 16:01:47 -06001726 ctlr = c->ctlr;
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001727 printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1728
1729 /* find the command to be aborted */
1730 cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1731 if (cmd_to_abort == NULL) /* paranoia */
1732 return FAILED;
scameron@beardog.cca.cpqcorp.net85cc61a2009-06-08 16:07:45 -05001733 memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1734 rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1735 0, 0, lunaddr, TYPE_MSG);
mike.miller@hp.com3da8b712005-11-04 12:30:37 -06001736 if (rc == 0)
1737 return SUCCESS;
1738 return FAILED;
1739
1740}
1741
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742#else /* no CONFIG_CISS_SCSI_TAPE */
1743
1744/* If no tape support, then these become defined out of existence */
1745
1746#define cciss_scsi_setup(cntl_num)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
1748#endif /* CONFIG_CISS_SCSI_TAPE */