ixgbe: filter FIP frames into the FCoE offload queues
[linux-2.6.git] / drivers / block / cciss_scsi.c
1 /*
2  *    Disk Array driver for HP Smart Array controllers, SCSI Tape module.
3  *    (C) Copyright 2001, 2007 Hewlett-Packard Development Company, L.P.
4  *
5  *    This program is free software; you can redistribute it and/or modify
6  *    it under the terms of the GNU General Public License as published by
7  *    the Free Software Foundation; version 2 of the License.
8  *
9  *    This program is distributed in the hope that it will be useful,
10  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  *    General Public License for more details.
13  *
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
16  *    Foundation, Inc., 59 Temple Place, Suite 300, Boston, MA
17  *    02111-1307, USA.
18  *
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
31 #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
38 #include <scsi/scsi_cmnd.h>
39 #include <scsi/scsi_device.h>
40 #include <scsi/scsi_host.h> 
41
42 #include "cciss_scsi.h"
43
44 #define CCISS_ABORT_MSG 0x00
45 #define CCISS_RESET_MSG 0x01
46
47 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
48         size_t size,
49         __u8 page_code, unsigned char *scsi3addr,
50         int cmd_type);
51
52 static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
53 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
54
55 static 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
63 static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
64                 void (* done)(struct scsi_cmnd *));
65 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
66 static int cciss_eh_abort_handler(struct scsi_cmnd *);
67
68 static 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
79 static 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,
87         .cmd_per_lun            = 1,
88         .use_clustering         = DISABLE_CLUSTERING,
89         /* 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,
92 };
93
94 #pragma pack(1)
95
96 #define SCSI_PAD_32 0
97 #define SCSI_PAD_64 0
98
99 struct cciss_scsi_cmd_stack_elem_t {
100         CommandList_struct cmd;
101         ErrorInfo_struct Err;
102         __u32 busaddr;
103         int cmdindex;
104         u8 pad[IS_32_BIT * SCSI_PAD_32 + IS_64_BIT * SCSI_PAD_64];
105 };
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)
114 struct 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
122 struct cciss_scsi_adapter_data_t {
123         struct Scsi_Host *scsi_host;
124         struct cciss_scsi_cmd_stack_t cmd_stack;
125         SGDescriptor_struct **cmd_sg_list;
126         int registered;
127         spinlock_t lock; // to protect ccissscsi[ctlr]; 
128 };
129
130 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
131         &hba[ctlr]->scsi_ctlr->lock, flags);
132 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
133         &hba[ctlr]->scsi_ctlr->lock, flags);
134
135 static CommandList_struct *
136 scsi_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
149         sa = h->scsi_ctlr;
150         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; 
160         c->cmd.cmdindex = c->cmdindex;
161         /* (__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
179 static void 
180 scsi_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
189         sa = h->scsi_ctlr;
190         stk = &sa->cmd_stack; 
191         if (stk->top >= CMD_STACK_SIZE) {
192                 printk("cciss: scsi_cmd_free called too many times.\n");
193                 BUG();
194         }
195         stk->top++;
196         stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
197 }
198
199 static int
200 scsi_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
206         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
211         stk = &sa->cmd_stack; 
212         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
213
214         /* 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 */
217         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) {
221                 cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
222                 sa->cmd_sg_list = NULL;
223                 return -ENOMEM;
224         }
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));
230                 stk->elem[i]->cmdindex = i;
231         }
232         stk->top = CMD_STACK_SIZE-1;
233         return 0;
234 }
235
236 static void
237 scsi_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
243         sa = hba[ctlr]->scsi_ctlr;
244         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;
255         cciss_free_sg_chain_blocks(sa->cmd_sg_list, CMD_STACK_SIZE);
256 }
257
258 #if 0
259 static int xmargin=8;
260 static int amargin=60;
261
262 static void
263 print_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
296 static void
297 print_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
344 static int 
345 find_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 }
366 struct scsi2map {
367         char scsi3addr[8];
368         int bus, target, lun;
369 };
370
371 static int 
372 cciss_scsi_add_entry(int ctlr, int hostno, 
373                 struct cciss_scsi_dev_t *device,
374                 struct scsi2map *added, int *nadded)
375 {
376         /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 
377         int n = ccissscsi[ctlr].ndevices;
378         struct cciss_scsi_dev_t *sd;
379         int i, bus, target, lun;
380         unsigned char addr1[8], addr2[8];
381
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         }
387
388         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. */
392         if (device->scsi3addr[4] != 0) {
393                 /* 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. */
397                 memcpy(addr1, device->scsi3addr, 8);
398                 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;
407                                 lun = device->scsi3addr[4];
408                                 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         }
423         added[*nadded].bus = sd->bus;
424         added[*nadded].target = sd->target;
425         added[*nadded].lun = sd->lun;
426         (*nadded)++;
427
428         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
434         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", 
441                         ctlr, scsi_device_type(sd->devtype), hostno,
442                         sd->bus, sd->target, sd->lun);
443         return 0;
444 }
445
446 static void
447 cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
448         struct scsi2map *removed, int *nremoved)
449 {
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];
456         removed[*nremoved].bus    = sd.bus;
457         removed[*nremoved].target = sd.target;
458         removed[*nremoved].lun    = sd.lun;
459         (*nremoved)++;
460         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",
464                 ctlr, scsi_device_type(sd.devtype), hostno,
465                         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
479 static 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
499 static 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
515 static int
516 adjust_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;
527         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         }
541
542         CPQ_TAPE_LOCK(ctlr, flags);
543
544         if (hostno != -1)  /* if it's not the first time... */
545                 sh = hba[ctlr]->scsi_ctlr->scsi_host;
546
547         /* find any devices in ccissscsi[] that are not in 
548            sd[] and remove them from ccissscsi[] */
549
550         i = 0;
551         nremoved = 0;
552         nadded = 0;
553         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)) {
559                                 if (device_is_the_same(&sd[j], csd))
560                                         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",
570                                 ctlr, scsi_device_type(csd->devtype), hostno,
571                                         csd->bus, csd->target, csd->lun); */
572                         cciss_scsi_remove_entry(ctlr, hostno, i,
573                                 removed, &nremoved);
574                         /* remove ^^^, hence i not incremented */
575                 } else if (found == 1) { /* device is different in some way */
576                         changes++;
577                         printk("cciss%d: device c%db%dt%dl%d has changed.\n",
578                                 ctlr, hostno, csd->bus, csd->target, csd->lun);
579                         cciss_scsi_remove_entry(ctlr, hostno, i,
580                                 removed, &nremoved);
581                         /* remove ^^^, hence i not incremented */
582                         if (cciss_scsi_add_entry(ctlr, hostno, &sd[j],
583                                 added, &nadded) != 0)
584                                 /* we just removed one, so add can't fail. */
585                                         BUG();
586                         csd->devtype = sd[j].devtype;
587                         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));
595                 } 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)) {
608                                 if (device_is_the_same(&sd[i], csd))
609                                         found=2;        /* found device */
610                                 else
611                                         found=1;        /* found a bug. */
612                                 break;
613                         }
614                 }
615                 if (!found) {
616                         changes++;
617                         if (cciss_scsi_add_entry(ctlr, hostno, &sd[i],
618                                 added, &nadded) != 0)
619                                 break;
620                 } else if (found == 1) {
621                         /* should never happen... */
622                         changes++;
623                         printk(KERN_WARNING "cciss%d: device "
624                                 "unexpectedly changed\n", ctlr);
625                         /* but if it does happen, we just ignore that device */
626                 }
627         }
628         CPQ_TAPE_UNLOCK(ctlr, flags);
629
630         /* 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;
635
636         /* 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
671 free_and_out:
672         kfree(added);
673         kfree(removed);
674         return 0;
675 }
676
677 static int
678 lookup_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
699 static void 
700 cciss_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         }
716         hba[cntl_num]->scsi_ctlr = shba;
717         return;
718 }
719
720 static void
721 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
722 {
723         struct scsi_cmnd *cmd;
724         ctlr_info_t *ctlr;
725         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
738         scsi_dma_unmap(cmd);
739         if (cp->Header.SGTotal > ctlr->max_cmd_sgentries)
740                 cciss_unmap_sg_chain_block(ctlr, cp);
741
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);
755         scsi_set_resid(cmd, ei->ResidualCnt);
756
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
771                                         cmd->result |= (ei->ScsiStatus << 1);
772                                 }
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
851 static int
852 cciss_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;  
863         sh->sg_tablesize = hba[ctlr]->maxsgentries;
864
865         ((struct cciss_scsi_adapter_data_t *) 
866                 hba[ctlr]->scsi_ctlr)->scsi_host = sh;
867         sh->hostdata[0] = (unsigned long) hba[ctlr];
868         sh->irq = hba[ctlr]->intr[SIMPLE_MODE_INT];
869         sh->unique_id = sh->irq;
870         error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
871         if (error)
872                 goto fail_host_put;
873         scsi_scan_host(sh);
874         return 1;
875
876  fail_host_put:
877         scsi_host_put(sh);
878  fail:
879         return 0;
880 }
881
882 static void
883 cciss_unmap_one(struct pci_dev *pdev,
884                 CommandList_struct *cp,
885                 size_t buflen,
886                 int data_direction)
887 {
888         u64bit addr64;
889
890         addr64.val32.lower = cp->SG[0].Addr.lower;
891         addr64.val32.upper = cp->SG[0].Addr.upper;
892         pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
893 }
894
895 static void
896 cciss_map_one(struct pci_dev *pdev,
897                 CommandList_struct *cp,
898                 unsigned char *buf,
899                 size_t buflen,
900                 int data_direction)
901 {
902         __u64 addr64;
903
904         addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
905         cp->SG[0].Addr.lower = 
906           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
907         cp->SG[0].Addr.upper =
908           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
909         cp->SG[0].Len = buflen;
910         cp->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
911         cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
912 }
913
914 static int
915 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
916                         CommandList_struct *cp,
917                         unsigned char *scsi3addr, 
918                         unsigned char *cdb,
919                         unsigned char cdblen,
920                         unsigned char *buf, int bufsize,
921                         int direction)
922 {
923         unsigned long flags;
924         DECLARE_COMPLETION_ONSTACK(wait);
925
926         cp->cmd_type = CMD_IOCTL_PEND;          // treat this like an ioctl 
927         cp->scsi_cmd = NULL;
928         cp->Header.ReplyQueue = 0;  // unused in simple mode
929         memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
930         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
931         // Fill in the request block...
932
933         /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", 
934                 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
935                 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
936
937         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
938         memcpy(cp->Request.CDB, cdb, cdblen);
939         cp->Request.Timeout = 0;
940         cp->Request.CDBLen = cdblen;
941         cp->Request.Type.Type = TYPE_CMD;
942         cp->Request.Type.Attribute = ATTR_SIMPLE;
943         cp->Request.Type.Direction = direction;
944
945         /* Fill in the SG list and do dma mapping */
946         cciss_map_one(c->pdev, cp, (unsigned char *) buf,
947                         bufsize, DMA_FROM_DEVICE); 
948
949         cp->waiting = &wait;
950
951         /* Put the request on the tail of the request queue */
952         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
953         addQ(&c->reqQ, cp);
954         c->Qdepth++;
955         start_io(c);
956         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
957
958         wait_for_completion(&wait);
959
960         /* undo the dma mapping */
961         cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
962         return(0);
963 }
964
965 static void 
966 cciss_scsi_interpret_error(CommandList_struct *cp)
967 {
968         ErrorInfo_struct *ei;
969
970         ei = cp->err_info; 
971         switch(ei->CommandStatus)
972         {
973                 case CMD_TARGET_STATUS:
974                         printk(KERN_WARNING "cciss: cmd %p has "
975                                 "completed with errors\n", cp);
976                         printk(KERN_WARNING "cciss: cmd %p "
977                                 "has SCSI Status = %x\n",
978                                         cp,  
979                                         ei->ScsiStatus);
980                         if (ei->ScsiStatus == 0)
981                                 printk(KERN_WARNING 
982                                 "cciss:SCSI status is abnormally zero.  "
983                                 "(probably indicates selection timeout "
984                                 "reported incorrectly due to a known "
985                                 "firmware bug, circa July, 2001.)\n");
986                 break;
987                 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
988                         printk("UNDERRUN\n");
989                 break;
990                 case CMD_DATA_OVERRUN:
991                         printk(KERN_WARNING "cciss: cp %p has"
992                                 " completed with data overrun "
993                                 "reported\n", cp);
994                 break;
995                 case CMD_INVALID: {
996                         /* controller unfortunately reports SCSI passthru's */
997                         /* to non-existent targets as invalid commands. */
998                         printk(KERN_WARNING "cciss: cp %p is "
999                                 "reported invalid (probably means "
1000                                 "target device no longer present)\n", 
1001                                 cp); 
1002                         /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
1003                         print_cmd(cp);  */
1004                         }
1005                 break;
1006                 case CMD_PROTOCOL_ERR:
1007                         printk(KERN_WARNING "cciss: cp %p has "
1008                                 "protocol error \n", cp);
1009                 break;
1010                 case CMD_HARDWARE_ERR:
1011                         /* cmd->result = DID_ERROR << 16; */
1012                         printk(KERN_WARNING "cciss: cp %p had " 
1013                                 " hardware error\n", cp);
1014                 break;
1015                 case CMD_CONNECTION_LOST:
1016                         printk(KERN_WARNING "cciss: cp %p had "
1017                                 "connection lost\n", cp);
1018                 break;
1019                 case CMD_ABORTED:
1020                         printk(KERN_WARNING "cciss: cp %p was "
1021                                 "aborted\n", cp);
1022                 break;
1023                 case CMD_ABORT_FAILED:
1024                         printk(KERN_WARNING "cciss: cp %p reports "
1025                                 "abort failed\n", cp);
1026                 break;
1027                 case CMD_UNSOLICITED_ABORT:
1028                         printk(KERN_WARNING "cciss: cp %p aborted "
1029                                 "do to an unsolicited abort\n", cp);
1030                 break;
1031                 case CMD_TIMEOUT:
1032                         printk(KERN_WARNING "cciss: cp %p timedout\n",
1033                                 cp);
1034                 break;
1035                 default:
1036                         printk(KERN_WARNING "cciss: cp %p returned "
1037                                 "unknown status %x\n", cp, 
1038                                         ei->CommandStatus); 
1039         }
1040 }
1041
1042 static int
1043 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr, 
1044         unsigned char page, unsigned char *buf,
1045         unsigned char bufsize)
1046 {
1047         int rc;
1048         CommandList_struct *cp;
1049         char cdb[6];
1050         ErrorInfo_struct *ei;
1051         unsigned long flags;
1052
1053         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1054         cp = scsi_cmd_alloc(c);
1055         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1056
1057         if (cp == NULL) {                       /* trouble... */
1058                 printk("cmd_alloc returned NULL!\n");
1059                 return -1;
1060         }
1061
1062         ei = cp->err_info; 
1063
1064         cdb[0] = CISS_INQUIRY;
1065         cdb[1] = (page != 0);
1066         cdb[2] = page;
1067         cdb[3] = 0;
1068         cdb[4] = bufsize;
1069         cdb[5] = 0;
1070         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb, 
1071                                 6, buf, bufsize, XFER_READ);
1072
1073         if (rc != 0) return rc; /* something went wrong */
1074
1075         if (ei->CommandStatus != 0 && 
1076             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1077                 cciss_scsi_interpret_error(cp);
1078                 rc = -1;
1079         }
1080         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1081         scsi_cmd_free(c, cp);
1082         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1083         return rc;      
1084 }
1085
1086 /* Get the device id from inquiry page 0x83 */
1087 static int cciss_scsi_get_device_id(ctlr_info_t *c, unsigned char *scsi3addr,
1088         unsigned char *device_id, int buflen)
1089 {
1090         int rc;
1091         unsigned char *buf;
1092
1093         if (buflen > 16)
1094                 buflen = 16;
1095         buf = kzalloc(64, GFP_KERNEL);
1096         if (!buf)
1097                 return -1;
1098         rc = cciss_scsi_do_inquiry(c, scsi3addr, 0x83, buf, 64);
1099         if (rc == 0)
1100                 memcpy(device_id, &buf[8], buflen);
1101         kfree(buf);
1102         return rc != 0;
1103 }
1104
1105 static int
1106 cciss_scsi_do_report_phys_luns(ctlr_info_t *c, 
1107                 ReportLunData_struct *buf, int bufsize)
1108 {
1109         int rc;
1110         CommandList_struct *cp;
1111         unsigned char cdb[12];
1112         unsigned char scsi3addr[8]; 
1113         ErrorInfo_struct *ei;
1114         unsigned long flags;
1115
1116         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1117         cp = scsi_cmd_alloc(c);
1118         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1119         if (cp == NULL) {                       /* trouble... */
1120                 printk("cmd_alloc returned NULL!\n");
1121                 return -1;
1122         }
1123
1124         memset(&scsi3addr[0], 0, 8); /* address the controller */
1125         cdb[0] = CISS_REPORT_PHYS;
1126         cdb[1] = 0;
1127         cdb[2] = 0;
1128         cdb[3] = 0;
1129         cdb[4] = 0;
1130         cdb[5] = 0;
1131         cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
1132         cdb[7] = (bufsize >> 16) & 0xFF;
1133         cdb[8] = (bufsize >> 8) & 0xFF;
1134         cdb[9] = bufsize & 0xFF;
1135         cdb[10] = 0;
1136         cdb[11] = 0;
1137
1138         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, 
1139                                 cdb, 12, 
1140                                 (unsigned char *) buf, 
1141                                 bufsize, XFER_READ);
1142
1143         if (rc != 0) return rc; /* something went wrong */
1144
1145         ei = cp->err_info; 
1146         if (ei->CommandStatus != 0 && 
1147             ei->CommandStatus != CMD_DATA_UNDERRUN) {
1148                 cciss_scsi_interpret_error(cp);
1149                 rc = -1;
1150         }
1151         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
1152         scsi_cmd_free(c, cp);
1153         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
1154         return rc;      
1155 }
1156
1157 static void
1158 cciss_update_non_disk_devices(int cntl_num, int hostno)
1159 {
1160         /* the idea here is we could get notified from /proc
1161            that some devices have changed, so we do a report 
1162            physical luns cmd, and adjust our list of devices 
1163            accordingly.  (We can't rely on the scsi-mid layer just
1164            doing inquiries, because the "busses" that the scsi 
1165            mid-layer probes are totally fabricated by this driver,
1166            so new devices wouldn't show up.
1167
1168            the scsi3addr's of devices won't change so long as the 
1169            adapter is not reset.  That means we can rescan and 
1170            tell which devices we already know about, vs. new 
1171            devices, vs.  disappearing devices.
1172
1173            Also, if you yank out a tape drive, then put in a disk
1174            in it's place, (say, a configured volume from another 
1175            array controller for instance)  _don't_ poke this driver 
1176            (so it thinks it's still a tape, but _do_ poke the scsi 
1177            mid layer, so it does an inquiry... the scsi mid layer 
1178            will see the physical disk.  This would be bad.  Need to
1179            think about how to prevent that.  One idea would be to 
1180            snoop all scsi responses and if an inquiry repsonse comes
1181            back that reports a disk, chuck it an return selection
1182            timeout instead and adjust our table...  Not sure i like
1183            that though.  
1184
1185          */
1186 #define OBDR_TAPE_INQ_SIZE 49
1187 #define OBDR_TAPE_SIG "$DR-10"
1188         ReportLunData_struct *ld_buff;
1189         unsigned char *inq_buff;
1190         unsigned char scsi3addr[8];
1191         ctlr_info_t *c;
1192         __u32 num_luns=0;
1193         unsigned char *ch;
1194         struct cciss_scsi_dev_t *currentsd, *this_device;
1195         int ncurrent=0;
1196         int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1197         int i;
1198
1199         c = (ctlr_info_t *) hba[cntl_num];      
1200         ld_buff = kzalloc(reportlunsize, GFP_KERNEL);
1201         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1202         currentsd = kzalloc(sizeof(*currentsd) *
1203                         (CCISS_MAX_SCSI_DEVS_PER_HBA+1), GFP_KERNEL);
1204         if (ld_buff == NULL || inq_buff == NULL || currentsd == NULL) {
1205                 printk(KERN_ERR "cciss: out of memory\n");
1206                 goto out;
1207         }
1208         this_device = &currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1209         if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1210                 ch = &ld_buff->LUNListLength[0];
1211                 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1212                 if (num_luns > CISS_MAX_PHYS_LUN) {
1213                         printk(KERN_WARNING 
1214                                 "cciss: Maximum physical LUNs (%d) exceeded.  "
1215                                 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN, 
1216                                 num_luns - CISS_MAX_PHYS_LUN);
1217                         num_luns = CISS_MAX_PHYS_LUN;
1218                 }
1219         }
1220         else {
1221                 printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1222                 goto out;
1223         }
1224
1225
1226         /* adjust our table of devices */       
1227         for (i = 0; i < num_luns; i++) {
1228                 /* for each physical lun, do an inquiry */
1229                 if (ld_buff->LUN[i][3] & 0xC0) continue;
1230                 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1231                 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1232
1233                 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, 0, inq_buff,
1234                         (unsigned char) OBDR_TAPE_INQ_SIZE) != 0)
1235                         /* Inquiry failed (msg printed already) */
1236                         continue; /* so we will skip this device. */
1237
1238                 this_device->devtype = (inq_buff[0] & 0x1f);
1239                 this_device->bus = -1;
1240                 this_device->target = -1;
1241                 this_device->lun = -1;
1242                 memcpy(this_device->scsi3addr, scsi3addr, 8);
1243                 memcpy(this_device->vendor, &inq_buff[8],
1244                         sizeof(this_device->vendor));
1245                 memcpy(this_device->model, &inq_buff[16],
1246                         sizeof(this_device->model));
1247                 memcpy(this_device->revision, &inq_buff[32],
1248                         sizeof(this_device->revision));
1249                 memset(this_device->device_id, 0,
1250                         sizeof(this_device->device_id));
1251                 cciss_scsi_get_device_id(hba[cntl_num], scsi3addr,
1252                         this_device->device_id, sizeof(this_device->device_id));
1253
1254                 switch (this_device->devtype)
1255                 {
1256                   case 0x05: /* CD-ROM */ {
1257
1258                         /* We don't *really* support actual CD-ROM devices,
1259                          * just this "One Button Disaster Recovery" tape drive
1260                          * which temporarily pretends to be a CD-ROM drive.
1261                          * So we check that the device is really an OBDR tape
1262                          * device by checking for "$DR-10" in bytes 43-48 of
1263                          * the inquiry data.
1264                          */
1265                                 char obdr_sig[7];
1266
1267                                 strncpy(obdr_sig, &inq_buff[43], 6);
1268                                 obdr_sig[6] = '\0';
1269                                 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1270                                         /* Not OBDR device, ignore it. */
1271                                         break;
1272                         }
1273                         /* fall through . . . */
1274                   case 0x01: /* sequential access, (tape) */
1275                   case 0x08: /* medium changer */
1276                         if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1277                                 printk(KERN_INFO "cciss%d: %s ignored, "
1278                                         "too many devices.\n", cntl_num,
1279                                         scsi_device_type(this_device->devtype));
1280                                 break;
1281                         }
1282                         currentsd[ncurrent] = *this_device;
1283                         ncurrent++;
1284                         break;
1285                   default: 
1286                         break;
1287                 }
1288         }
1289
1290         adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1291 out:
1292         kfree(inq_buff);
1293         kfree(ld_buff);
1294         kfree(currentsd);
1295         return;
1296 }
1297
1298 static int
1299 is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1300 {
1301         int verb_len = strlen(verb);
1302         if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1303                 return verb_len;
1304         else
1305                 return 0;
1306 }
1307
1308 static int
1309 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1310 {
1311         int arg_len;
1312
1313         if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1314                 cciss_update_non_disk_devices(ctlr, hostno);
1315         else
1316                 return -EINVAL;
1317         return length;
1318 }
1319
1320
1321 static int
1322 cciss_scsi_proc_info(struct Scsi_Host *sh,
1323                 char *buffer, /* data buffer */
1324                 char **start,      /* where data in buffer starts */
1325                 off_t offset,      /* offset from start of imaginary file */
1326                 int length,        /* length of data in buffer */
1327                 int func)          /* 0 == read, 1 == write */
1328 {
1329
1330         int buflen, datalen;
1331         ctlr_info_t *ci;
1332         int i;
1333         int cntl_num;
1334
1335
1336         ci = (ctlr_info_t *) sh->hostdata[0];
1337         if (ci == NULL)  /* This really shouldn't ever happen. */
1338                 return -EINVAL;
1339
1340         cntl_num = ci->ctlr;    /* Get our index into the hba[] array */
1341
1342         if (func == 0) {        /* User is reading from /proc/scsi/ciss*?/?*  */
1343                 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1344                                 cntl_num, sh->host_no);
1345
1346                 /* this information is needed by apps to know which cciss
1347                    device corresponds to which scsi host number without
1348                    having to open a scsi target device node.  The device
1349                    information is not a duplicate of /proc/scsi/scsi because
1350                    the two may be out of sync due to scsi hotplug, rather
1351                    this info is for an app to be able to use to know how to
1352                    get them back in sync. */
1353
1354                 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1355                         struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1356                         buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1357                                 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1358                                 sh->host_no, sd->bus, sd->target, sd->lun,
1359                                 sd->devtype,
1360                                 sd->scsi3addr[0], sd->scsi3addr[1],
1361                                 sd->scsi3addr[2], sd->scsi3addr[3],
1362                                 sd->scsi3addr[4], sd->scsi3addr[5],
1363                                 sd->scsi3addr[6], sd->scsi3addr[7]);
1364                 }
1365                 datalen = buflen - offset;
1366                 if (datalen < 0) {      /* they're reading past EOF. */
1367                         datalen = 0;
1368                         *start = buffer+buflen; 
1369                 } else
1370                         *start = buffer + offset;
1371                 return(datalen);
1372         } else  /* User is writing to /proc/scsi/cciss*?/?*  ... */
1373                 return cciss_scsi_user_command(cntl_num, sh->host_no,
1374                         buffer, length);        
1375
1376
1377 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci 
1378    dma mapping  and fills in the scatter gather entries of the 
1379    cciss command, cp. */
1380
1381 static void cciss_scatter_gather(ctlr_info_t *h, CommandList_struct *cp,
1382         struct scsi_cmnd *cmd)
1383 {
1384         unsigned int len;
1385         struct scatterlist *sg;
1386         __u64 addr64;
1387         int request_nsgs, i, chained, sg_index;
1388         struct cciss_scsi_adapter_data_t *sa = h->scsi_ctlr;
1389         SGDescriptor_struct *curr_sg;
1390
1391         BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
1392
1393         chained = 0;
1394         sg_index = 0;
1395         curr_sg = cp->SG;
1396         request_nsgs = scsi_dma_map(cmd);
1397         if (request_nsgs) {
1398                 scsi_for_each_sg(cmd, sg, request_nsgs, i) {
1399                         if (sg_index + 1 == h->max_cmd_sgentries &&
1400                                 !chained && request_nsgs - i > 1) {
1401                                 chained = 1;
1402                                 sg_index = 0;
1403                                 curr_sg = sa->cmd_sg_list[cp->cmdindex];
1404                         }
1405                         addr64 = (__u64) sg_dma_address(sg);
1406                         len  = sg_dma_len(sg);
1407                         curr_sg[sg_index].Addr.lower =
1408                                 (__u32) (addr64 & 0x0FFFFFFFFULL);
1409                         curr_sg[sg_index].Addr.upper =
1410                                 (__u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
1411                         curr_sg[sg_index].Len = len;
1412                         curr_sg[sg_index].Ext = 0;
1413                         ++sg_index;
1414                 }
1415                 if (chained)
1416                         cciss_map_sg_chain_block(h, cp,
1417                                 sa->cmd_sg_list[cp->cmdindex],
1418                                 (request_nsgs - (h->max_cmd_sgentries - 1)) *
1419                                         sizeof(SGDescriptor_struct));
1420         }
1421         /* track how many SG entries we are using */
1422         if (request_nsgs > h->maxSG)
1423                 h->maxSG = request_nsgs;
1424         cp->Header.SGTotal = (__u8) request_nsgs + chained;
1425         if (request_nsgs > h->max_cmd_sgentries)
1426                 cp->Header.SGList = h->max_cmd_sgentries;
1427         else
1428                 cp->Header.SGList = cp->Header.SGTotal;
1429         return;
1430 }
1431
1432
1433 static int
1434 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1435 {
1436         ctlr_info_t *c;
1437         int ctlr, rc;
1438         unsigned char scsi3addr[8];
1439         CommandList_struct *cp;
1440         unsigned long flags;
1441
1442         // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1443         // We violate cmd->host privacy here.  (Is there another way?)
1444         c = (ctlr_info_t *) cmd->device->host->hostdata[0];
1445         ctlr = c->ctlr;
1446
1447         rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, 
1448                         cmd->device->lun, scsi3addr);
1449         if (rc != 0) {
1450                 /* the scsi nexus does not match any that we presented... */
1451                 /* pretend to mid layer that we got selection timeout */
1452                 cmd->result = DID_NO_CONNECT << 16;
1453                 done(cmd);
1454                 /* we might want to think about registering controller itself
1455                    as a processor device on the bus so sg binds to it. */
1456                 return 0;
1457         }
1458
1459         /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n", 
1460                 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1461         // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel, 
1462         //      cmd->target, cmd->lun);
1463
1464         /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1465            see what the device thinks of it. */
1466
1467         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1468         cp = scsi_cmd_alloc(c);
1469         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1470         if (cp == NULL) {                       /* trouble... */
1471                 printk("scsi_cmd_alloc returned NULL!\n");
1472                 /* FIXME: next 3 lines are -> BAD! <- */
1473                 cmd->result = DID_NO_CONNECT << 16;
1474                 done(cmd);
1475                 return 0;
1476         }
1477
1478         // Fill in the command list header
1479
1480         cmd->scsi_done = done;    // save this for use by completion code 
1481
1482         // save cp in case we have to abort it 
1483         cmd->host_scribble = (unsigned char *) cp; 
1484
1485         cp->cmd_type = CMD_SCSI;
1486         cp->scsi_cmd = cmd;
1487         cp->Header.ReplyQueue = 0;  // unused in simple mode
1488         memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1489         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
1490         
1491         // Fill in the request block...
1492
1493         cp->Request.Timeout = 0;
1494         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1495         BUG_ON(cmd->cmd_len > sizeof(cp->Request.CDB));
1496         cp->Request.CDBLen = cmd->cmd_len;
1497         memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1498         cp->Request.Type.Type = TYPE_CMD;
1499         cp->Request.Type.Attribute = ATTR_SIMPLE;
1500         switch(cmd->sc_data_direction)
1501         {
1502           case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1503           case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1504           case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1505           case DMA_BIDIRECTIONAL:
1506                 // This can happen if a buggy application does a scsi passthru
1507                 // and sets both inlen and outlen to non-zero. ( see
1508                 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1509
1510                 cp->Request.Type.Direction = XFER_RSVD;
1511                 // This is technically wrong, and cciss controllers should
1512                 // reject it with CMD_INVALID, which is the most correct 
1513                 // response, but non-fibre backends appear to let it 
1514                 // slide by, and give the same results as if this field
1515                 // were set correctly.  Either way is acceptable for
1516                 // our purposes here.
1517
1518                 break;
1519
1520           default: 
1521                 printk("cciss: unknown data direction: %d\n", 
1522                         cmd->sc_data_direction);
1523                 BUG();
1524                 break;
1525         }
1526         cciss_scatter_gather(c, cp, cmd);
1527
1528         /* Put the request on the tail of the request queue */
1529
1530         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1531         addQ(&c->reqQ, cp);
1532         c->Qdepth++;
1533         start_io(c);
1534         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1535
1536         /* the cmd'll come back via intr handler in complete_scsi_command()  */
1537         return 0;
1538 }
1539
1540 static void 
1541 cciss_unregister_scsi(int ctlr)
1542 {
1543         struct cciss_scsi_adapter_data_t *sa;
1544         struct cciss_scsi_cmd_stack_t *stk;
1545         unsigned long flags;
1546
1547         /* we are being forcibly unloaded, and may not refuse. */
1548
1549         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1550         sa = hba[ctlr]->scsi_ctlr;
1551         stk = &sa->cmd_stack; 
1552
1553         /* if we weren't ever actually registered, don't unregister */ 
1554         if (sa->registered) {
1555                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1556                 scsi_remove_host(sa->scsi_host);
1557                 scsi_host_put(sa->scsi_host);
1558                 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1559         }
1560
1561         /* set scsi_host to NULL so our detect routine will 
1562            find us on register */
1563         sa->scsi_host = NULL;
1564         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1565         scsi_cmd_stack_free(ctlr);
1566         kfree(sa);
1567 }
1568
1569 static int 
1570 cciss_engage_scsi(int ctlr)
1571 {
1572         struct cciss_scsi_adapter_data_t *sa;
1573         struct cciss_scsi_cmd_stack_t *stk;
1574         unsigned long flags;
1575
1576         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1577         sa = hba[ctlr]->scsi_ctlr;
1578         stk = &sa->cmd_stack; 
1579
1580         if (sa->registered) {
1581                 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1582                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1583                 return -ENXIO;
1584         }
1585         sa->registered = 1;
1586         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1587         cciss_update_non_disk_devices(ctlr, -1);
1588         cciss_scsi_detect(ctlr);
1589         return 0;
1590 }
1591
1592 static void
1593 cciss_seq_tape_report(struct seq_file *seq, int ctlr)
1594 {
1595         unsigned long flags;
1596
1597         CPQ_TAPE_LOCK(ctlr, flags);
1598         seq_printf(seq,
1599                 "Sequential access devices: %d\n\n",
1600                         ccissscsi[ctlr].ndevices);
1601         CPQ_TAPE_UNLOCK(ctlr, flags);
1602 }
1603
1604 static int wait_for_device_to_become_ready(ctlr_info_t *h,
1605         unsigned char lunaddr[])
1606 {
1607         int rc;
1608         int count = 0;
1609         int waittime = HZ;
1610         CommandList_struct *c;
1611
1612         c = cmd_alloc(h, 1);
1613         if (!c) {
1614                 printk(KERN_WARNING "cciss%d: out of memory in "
1615                         "wait_for_device_to_become_ready.\n", h->ctlr);
1616                 return IO_ERROR;
1617         }
1618
1619         /* Send test unit ready until device ready, or give up. */
1620         while (count < 20) {
1621
1622                 /* Wait for a bit.  do this first, because if we send
1623                  * the TUR right away, the reset will just abort it.
1624                  */
1625                 schedule_timeout_uninterruptible(waittime);
1626                 count++;
1627
1628                 /* Increase wait time with each try, up to a point. */
1629                 if (waittime < (HZ * 30))
1630                         waittime = waittime * 2;
1631
1632                 /* Send the Test Unit Ready */
1633                 rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
1634                         lunaddr, TYPE_CMD);
1635                 if (rc == 0)
1636                         rc = sendcmd_withirq_core(h, c, 0);
1637
1638                 (void) process_sendcmd_error(h, c);
1639
1640                 if (rc != 0)
1641                         goto retry_tur;
1642
1643                 if (c->err_info->CommandStatus == CMD_SUCCESS)
1644                         break;
1645
1646                 if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
1647                         c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
1648                         if (c->err_info->SenseInfo[2] == NO_SENSE)
1649                                 break;
1650                         if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
1651                                 unsigned char asc;
1652                                 asc = c->err_info->SenseInfo[12];
1653                                 check_for_unit_attention(h, c);
1654                                 if (asc == POWER_OR_RESET)
1655                                         break;
1656                         }
1657                 }
1658 retry_tur:
1659                 printk(KERN_WARNING "cciss%d: Waiting %d secs "
1660                         "for device to become ready.\n",
1661                         h->ctlr, waittime / HZ);
1662                 rc = 1; /* device not ready. */
1663         }
1664
1665         if (rc)
1666                 printk("cciss%d: giving up on device.\n", h->ctlr);
1667         else
1668                 printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
1669
1670         cmd_free(h, c, 1);
1671         return rc;
1672 }
1673
1674 /* Need at least one of these error handlers to keep ../scsi/hosts.c from 
1675  * complaining.  Doing a host- or bus-reset can't do anything good here. 
1676  * Despite what it might say in scsi_error.c, there may well be commands
1677  * on the controller, as the cciss driver registers twice, once as a block
1678  * device for the logical drives, and once as a scsi device, for any tape
1679  * drives.  So we know there are no commands out on the tape drives, but we
1680  * don't know there are no commands on the controller, and it is likely 
1681  * that there probably are, as the cciss block device is most commonly used
1682  * as a boot device (embedded controller on HP/Compaq systems.)
1683 */
1684
1685 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1686 {
1687         int rc;
1688         CommandList_struct *cmd_in_trouble;
1689         unsigned char lunaddr[8];
1690         ctlr_info_t *c;
1691         int ctlr;
1692
1693         /* find the controller to which the command to be aborted was sent */
1694         c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1695         if (c == NULL) /* paranoia */
1696                 return FAILED;
1697         ctlr = c->ctlr;
1698         printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1699         /* find the command that's giving us trouble */
1700         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1701         if (cmd_in_trouble == NULL) /* paranoia */
1702                 return FAILED;
1703         memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
1704         /* send a reset to the SCSI LUN which the command was sent to */
1705         rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
1706                 TYPE_MSG);
1707         if (rc == 0 && wait_for_device_to_become_ready(c, lunaddr) == 0)
1708                 return SUCCESS;
1709         printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1710         return FAILED;
1711 }
1712
1713 static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1714 {
1715         int rc;
1716         CommandList_struct *cmd_to_abort;
1717         unsigned char lunaddr[8];
1718         ctlr_info_t *c;
1719         int ctlr;
1720
1721         /* find the controller to which the command to be aborted was sent */
1722         c = (ctlr_info_t *) scsicmd->device->host->hostdata[0];
1723         if (c == NULL) /* paranoia */
1724                 return FAILED;
1725         ctlr = c->ctlr;
1726         printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1727
1728         /* find the command to be aborted */
1729         cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1730         if (cmd_to_abort == NULL) /* paranoia */
1731                 return FAILED;
1732         memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
1733         rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
1734                 0, 0, lunaddr, TYPE_MSG);
1735         if (rc == 0)
1736                 return SUCCESS;
1737         return FAILED;
1738
1739 }
1740
1741 #else /* no CONFIG_CISS_SCSI_TAPE */
1742
1743 /* If no tape support, then these become defined out of existence */
1744
1745 #define cciss_scsi_setup(cntl_num)
1746
1747 #endif /* CONFIG_CISS_SCSI_TAPE */