[SCSI] cciss: scsi error handling
[linux-2.6.git] / drivers / block / cciss_scsi.c
1 /*
2  *    Disk Array driver for Compaq SA53xx Controllers, SCSI Tape module
3  *    Copyright 2001 Compaq Computer Corporation
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; either version 2 of the License, or
8  *    (at your option) any later version.
9  *
10  *    This program is distributed in the hope that it will be useful,
11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13  *    NON INFRINGEMENT.  See the GNU General Public License for more details.
14  *
15  *    You should have received a copy of the GNU General Public License
16  *    along with this program; if not, write to the Free Software
17  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
20  *    
21  *    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.h> 
39 #include <scsi/scsi_cmnd.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_host.h> 
42
43 #include "cciss_scsi.h"
44
45 #define CCISS_ABORT_MSG 0x00
46 #define CCISS_RESET_MSG 0x01
47
48 /* some prototypes... */ 
49 static int sendcmd(
50         __u8    cmd,
51         int     ctlr,
52         void    *buff,
53         size_t  size,
54         unsigned int use_unit_num, /* 0: address the controller,
55                                       1: address logical volume log_unit, 
56                                       2: address is in scsi3addr */
57         unsigned int log_unit,
58         __u8    page_code,
59         unsigned char *scsi3addr,
60         int cmd_type);
61
62
63 static int cciss_scsi_proc_info(
64                 struct Scsi_Host *sh,
65                 char *buffer, /* data buffer */
66                 char **start,      /* where data in buffer starts */
67                 off_t offset,      /* offset from start of imaginary file */
68                 int length,        /* length of data in buffer */
69                 int func);         /* 0 == read, 1 == write */
70
71 static int cciss_scsi_queue_command (struct scsi_cmnd *cmd,
72                 void (* done)(struct scsi_cmnd *));
73 static int cciss_eh_device_reset_handler(struct scsi_cmnd *);
74 static int cciss_eh_abort_handler(struct scsi_cmnd *);
75
76 static struct cciss_scsi_hba_t ccissscsi[MAX_CTLR] = {
77         { .name = "cciss0", .ndevices = 0 },
78         { .name = "cciss1", .ndevices = 0 },
79         { .name = "cciss2", .ndevices = 0 },
80         { .name = "cciss3", .ndevices = 0 },
81         { .name = "cciss4", .ndevices = 0 },
82         { .name = "cciss5", .ndevices = 0 },
83         { .name = "cciss6", .ndevices = 0 },
84         { .name = "cciss7", .ndevices = 0 },
85 };
86
87 static struct scsi_host_template cciss_driver_template = {
88         .module                 = THIS_MODULE,
89         .name                   = "cciss",
90         .proc_name              = "cciss",
91         .proc_info              = cciss_scsi_proc_info,
92         .queuecommand           = cciss_scsi_queue_command,
93         .can_queue              = SCSI_CCISS_CAN_QUEUE,
94         .this_id                = 7,
95         .sg_tablesize           = MAXSGENTRIES,
96         .cmd_per_lun            = 1,
97         .use_clustering         = DISABLE_CLUSTERING,
98         /* Can't have eh_bus_reset_handler or eh_host_reset_handler for cciss */
99         .eh_device_reset_handler= cciss_eh_device_reset_handler,
100         .eh_abort_handler       = cciss_eh_abort_handler,
101 };
102
103 #pragma pack(1)
104 struct cciss_scsi_cmd_stack_elem_t {
105         CommandList_struct cmd;
106         ErrorInfo_struct Err;
107         __u32 busaddr;
108         __u32 pad;
109 };
110
111 #pragma pack()
112
113 #define CMD_STACK_SIZE (SCSI_CCISS_CAN_QUEUE * \
114                 CCISS_MAX_SCSI_DEVS_PER_HBA + 2)
115                         // plus two for init time usage
116
117 #pragma pack(1)
118 struct cciss_scsi_cmd_stack_t {
119         struct cciss_scsi_cmd_stack_elem_t *pool;
120         struct cciss_scsi_cmd_stack_elem_t *elem[CMD_STACK_SIZE];
121         dma_addr_t cmd_pool_handle;
122         int top;
123 };
124 #pragma pack()
125
126 struct cciss_scsi_adapter_data_t {
127         struct Scsi_Host *scsi_host;
128         struct cciss_scsi_cmd_stack_t cmd_stack;
129         int registered;
130         spinlock_t lock; // to protect ccissscsi[ctlr]; 
131 };
132
133 #define CPQ_TAPE_LOCK(ctlr, flags) spin_lock_irqsave( \
134         &(((struct cciss_scsi_adapter_data_t *) \
135         hba[ctlr]->scsi_ctlr)->lock), flags);
136 #define CPQ_TAPE_UNLOCK(ctlr, flags) spin_unlock_irqrestore( \
137         &(((struct cciss_scsi_adapter_data_t *) \
138         hba[ctlr]->scsi_ctlr)->lock), flags);
139
140 static CommandList_struct *
141 scsi_cmd_alloc(ctlr_info_t *h)
142 {
143         /* assume only one process in here at a time, locking done by caller. */
144         /* use CCISS_LOCK(ctlr) */
145         /* might be better to rewrite how we allocate scsi commands in a way that */
146         /* needs no locking at all. */
147
148         /* take the top memory chunk off the stack and return it, if any. */
149         struct cciss_scsi_cmd_stack_elem_t *c;
150         struct cciss_scsi_adapter_data_t *sa;
151         struct cciss_scsi_cmd_stack_t *stk;
152         u64bit temp64;
153
154         sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
155         stk = &sa->cmd_stack; 
156
157         if (stk->top < 0) 
158                 return NULL;
159         c = stk->elem[stk->top];        
160         /* memset(c, 0, sizeof(*c)); */
161         memset(&c->cmd, 0, sizeof(c->cmd));
162         memset(&c->Err, 0, sizeof(c->Err));
163         /* set physical addr of cmd and addr of scsi parameters */
164         c->cmd.busaddr = c->busaddr; 
165         /* (__u32) (stk->cmd_pool_handle + 
166                 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top)); */
167
168         temp64.val = (__u64) (c->busaddr + sizeof(CommandList_struct));
169         /* (__u64) (stk->cmd_pool_handle + 
170                 (sizeof(struct cciss_scsi_cmd_stack_elem_t)*stk->top) +
171                  sizeof(CommandList_struct)); */
172         stk->top--;
173         c->cmd.ErrDesc.Addr.lower = temp64.val32.lower;
174         c->cmd.ErrDesc.Addr.upper = temp64.val32.upper;
175         c->cmd.ErrDesc.Len = sizeof(ErrorInfo_struct);
176         
177         c->cmd.ctlr = h->ctlr;
178         c->cmd.err_info = &c->Err;
179
180         return (CommandList_struct *) c;
181 }
182
183 static void 
184 scsi_cmd_free(ctlr_info_t *h, CommandList_struct *cmd)
185 {
186         /* assume only one process in here at a time, locking done by caller. */
187         /* use CCISS_LOCK(ctlr) */
188         /* drop the free memory chunk on top of the stack. */
189
190         struct cciss_scsi_adapter_data_t *sa;
191         struct cciss_scsi_cmd_stack_t *stk;
192
193         sa = (struct cciss_scsi_adapter_data_t *) h->scsi_ctlr;
194         stk = &sa->cmd_stack; 
195         if (stk->top >= CMD_STACK_SIZE) {
196                 printk("cciss: scsi_cmd_free called too many times.\n");
197                 BUG();
198         }
199         stk->top++;
200         stk->elem[stk->top] = (struct cciss_scsi_cmd_stack_elem_t *) cmd;
201 }
202
203 static int
204 scsi_cmd_stack_setup(int ctlr, struct cciss_scsi_adapter_data_t *sa)
205 {
206         int i;
207         struct cciss_scsi_cmd_stack_t *stk;
208         size_t size;
209
210         stk = &sa->cmd_stack; 
211         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
212
213         // pci_alloc_consistent guarantees 32-bit DMA address will
214         // be used
215
216         stk->pool = (struct cciss_scsi_cmd_stack_elem_t *)
217                 pci_alloc_consistent(hba[ctlr]->pdev, size, &stk->cmd_pool_handle);
218
219         if (stk->pool == NULL) {
220                 printk("stk->pool is null\n");
221                 return -1;
222         }
223
224         for (i=0; i<CMD_STACK_SIZE; i++) {
225                 stk->elem[i] = &stk->pool[i];
226                 stk->elem[i]->busaddr = (__u32) (stk->cmd_pool_handle + 
227                         (sizeof(struct cciss_scsi_cmd_stack_elem_t) * i));
228         }
229         stk->top = CMD_STACK_SIZE-1;
230         return 0;
231 }
232
233 static void
234 scsi_cmd_stack_free(int ctlr)
235 {
236         struct cciss_scsi_adapter_data_t *sa;
237         struct cciss_scsi_cmd_stack_t *stk;
238         size_t size;
239
240         sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
241         stk = &sa->cmd_stack; 
242         if (stk->top != CMD_STACK_SIZE-1) {
243                 printk( "cciss: %d scsi commands are still outstanding.\n",
244                         CMD_STACK_SIZE - stk->top);
245                 // BUG();
246                 printk("WE HAVE A BUG HERE!!! stk=0x%p\n", stk);
247         }
248         size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE;
249
250         pci_free_consistent(hba[ctlr]->pdev, size, stk->pool, stk->cmd_pool_handle);
251         stk->pool = NULL;
252 }
253
254 /* scsi_device_types comes from scsi.h */
255 #define DEVICETYPE(n) (n<0 || n>MAX_SCSI_DEVICE_CODE) ? \
256         "Unknown" : scsi_device_types[n]
257
258 #if 1
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
367 static int 
368 cciss_scsi_add_entry(int ctlr, int hostno, 
369                 unsigned char *scsi3addr, int devtype)
370 {
371         /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 
372         int n = ccissscsi[ctlr].ndevices;
373         struct cciss_scsi_dev_t *sd;
374
375         if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
376                 printk("cciss%d: Too many devices, "
377                         "some will be inaccessible.\n", ctlr);
378                 return -1;
379         }
380         sd = &ccissscsi[ctlr].dev[n];
381         if (find_bus_target_lun(ctlr, &sd->bus, &sd->target, &sd->lun) != 0)
382                 return -1;
383         memcpy(&sd->scsi3addr[0], scsi3addr, 8);
384         sd->devtype = devtype;
385         ccissscsi[ctlr].ndevices++;
386
387         /* initially, (before registering with scsi layer) we don't 
388            know our hostno and we don't want to print anything first 
389            time anyway (the scsi layer's inquiries will show that info) */
390         if (hostno != -1)
391                 printk("cciss%d: %s device c%db%dt%dl%d added.\n", 
392                         ctlr, DEVICETYPE(sd->devtype), hostno, 
393                         sd->bus, sd->target, sd->lun);
394         return 0;
395 }
396
397 static void
398 cciss_scsi_remove_entry(int ctlr, int hostno, int entry)
399 {
400         /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 
401         int i;
402         struct cciss_scsi_dev_t sd;
403
404         if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
405         sd = ccissscsi[ctlr].dev[entry];
406         for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
407                 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
408         ccissscsi[ctlr].ndevices--;
409         printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
410                 ctlr, DEVICETYPE(sd.devtype), hostno, 
411                         sd.bus, sd.target, sd.lun);
412 }
413
414
415 #define SCSI3ADDR_EQ(a,b) ( \
416         (a)[7] == (b)[7] && \
417         (a)[6] == (b)[6] && \
418         (a)[5] == (b)[5] && \
419         (a)[4] == (b)[4] && \
420         (a)[3] == (b)[3] && \
421         (a)[2] == (b)[2] && \
422         (a)[1] == (b)[1] && \
423         (a)[0] == (b)[0])
424
425 static int
426 adjust_cciss_scsi_table(int ctlr, int hostno,
427         struct cciss_scsi_dev_t sd[], int nsds)
428 {
429         /* sd contains scsi3 addresses and devtypes, but
430            bus target and lun are not filled in.  This funciton
431            takes what's in sd to be the current and adjusts
432            ccissscsi[] to be in line with what's in sd. */ 
433
434         int i,j, found, changes=0;
435         struct cciss_scsi_dev_t *csd;
436         unsigned long flags;
437
438         CPQ_TAPE_LOCK(ctlr, flags);
439
440         /* find any devices in ccissscsi[] that are not in 
441            sd[] and remove them from ccissscsi[] */
442
443         i = 0;
444         while(i<ccissscsi[ctlr].ndevices) {
445                 csd = &ccissscsi[ctlr].dev[i];
446                 found=0;
447                 for (j=0;j<nsds;j++) {
448                         if (SCSI3ADDR_EQ(sd[j].scsi3addr,
449                                 csd->scsi3addr)) {
450                                 if (sd[j].devtype == csd->devtype)
451                                         found=2;
452                                 else
453                                         found=1;
454                                 break;
455                         }
456                 }
457
458                 if (found == 0) { /* device no longer present. */ 
459                         changes++;
460                         /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
461                                 ctlr, DEVICETYPE(csd->devtype), hostno, 
462                                         csd->bus, csd->target, csd->lun); */
463                         cciss_scsi_remove_entry(ctlr, hostno, i);
464                         /* note, i not incremented */
465                 } 
466                 else if (found == 1) { /* device is different kind */
467                         changes++;
468                         printk("cciss%d: device c%db%dt%dl%d type changed "
469                                 "(device type now %s).\n",
470                                 ctlr, hostno, csd->bus, csd->target, csd->lun,
471                                         DEVICETYPE(csd->devtype));
472                         csd->devtype = sd[j].devtype;
473                         i++;    /* so just move along. */
474                 } else          /* device is same as it ever was, */
475                         i++;    /* so just move along. */
476         }
477
478         /* Now, make sure every device listed in sd[] is also
479            listed in ccissscsi[], adding them if they aren't found */
480
481         for (i=0;i<nsds;i++) {
482                 found=0;
483                 for (j=0;j<ccissscsi[ctlr].ndevices;j++) {
484                         csd = &ccissscsi[ctlr].dev[j];
485                         if (SCSI3ADDR_EQ(sd[i].scsi3addr,
486                                 csd->scsi3addr)) {
487                                 if (sd[i].devtype == csd->devtype)
488                                         found=2;        /* found device */
489                                 else
490                                         found=1;        /* found a bug. */
491                                 break;
492                         }
493                 }
494                 if (!found) {
495                         changes++;
496                         if (cciss_scsi_add_entry(ctlr, hostno, 
497                                 &sd[i].scsi3addr[0], sd[i].devtype) != 0)
498                                 break;
499                 } else if (found == 1) {
500                         /* should never happen... */
501                         changes++;
502                         printk("cciss%d: device unexpectedly changed type\n",
503                                 ctlr);
504                         /* but if it does happen, we just ignore that device */
505                 }
506         }
507         CPQ_TAPE_UNLOCK(ctlr, flags);
508
509         if (!changes) 
510                 printk("cciss%d: No device changes detected.\n", ctlr);
511
512         return 0;
513 }
514
515 static int
516 lookup_scsi3addr(int ctlr, int bus, int target, int lun, char *scsi3addr)
517 {
518         int i;
519         struct cciss_scsi_dev_t *sd;
520         unsigned long flags;
521
522         CPQ_TAPE_LOCK(ctlr, flags);
523         for (i=0;i<ccissscsi[ctlr].ndevices;i++) {
524                 sd = &ccissscsi[ctlr].dev[i];
525                 if (sd->bus == bus &&
526                     sd->target == target &&
527                     sd->lun == lun) {
528                         memcpy(scsi3addr, &sd->scsi3addr[0], 8);
529                         CPQ_TAPE_UNLOCK(ctlr, flags);
530                         return 0;
531                 }
532         }
533         CPQ_TAPE_UNLOCK(ctlr, flags);
534         return -1;
535 }
536
537 static void 
538 cciss_scsi_setup(int cntl_num)
539 {
540         struct cciss_scsi_adapter_data_t * shba;
541
542         ccissscsi[cntl_num].ndevices = 0;
543         shba = (struct cciss_scsi_adapter_data_t *)
544                 kmalloc(sizeof(*shba), GFP_KERNEL);     
545         if (shba == NULL)
546                 return;
547         shba->scsi_host = NULL;
548         spin_lock_init(&shba->lock);
549         shba->registered = 0;
550         if (scsi_cmd_stack_setup(cntl_num, shba) != 0) {
551                 kfree(shba);
552                 shba = NULL;
553         }
554         hba[cntl_num]->scsi_ctlr = (void *) shba;
555         return;
556 }
557
558 static void
559 complete_scsi_command( CommandList_struct *cp, int timeout, __u32 tag)
560 {
561         struct scsi_cmnd *cmd;
562         ctlr_info_t *ctlr;
563         u64bit addr64;
564         ErrorInfo_struct *ei;
565
566         ei = cp->err_info;
567
568         /* First, see if it was a message rather than a command */
569         if (cp->Request.Type.Type == TYPE_MSG)  {
570                 cp->cmd_type = CMD_MSG_DONE;
571                 return;
572         }
573
574         cmd = (struct scsi_cmnd *) cp->scsi_cmd;        
575         ctlr = hba[cp->ctlr];
576
577         /* undo the DMA mappings */
578
579         if (cmd->use_sg) {
580                 pci_unmap_sg(ctlr->pdev,
581                         cmd->buffer, cmd->use_sg,
582                                 cmd->sc_data_direction); 
583         }
584         else if (cmd->request_bufflen) {
585                 addr64.val32.lower = cp->SG[0].Addr.lower;
586                 addr64.val32.upper = cp->SG[0].Addr.upper;
587                 pci_unmap_single(ctlr->pdev, (dma_addr_t) addr64.val,
588                         cmd->request_bufflen, 
589                                 cmd->sc_data_direction);
590         }
591
592         cmd->result = (DID_OK << 16);           /* host byte */
593         cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
594         /* cmd->result |= (GOOD < 1); */                /* status byte */
595
596         cmd->result |= (ei->ScsiStatus);
597         /* printk("Scsistatus is 0x%02x\n", ei->ScsiStatus);  */
598
599         /* copy the sense data whether we need to or not. */
600
601         memcpy(cmd->sense_buffer, ei->SenseInfo, 
602                 ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
603                         SCSI_SENSE_BUFFERSIZE : 
604                         ei->SenseLen);
605         cmd->resid = ei->ResidualCnt;
606
607         if(ei->CommandStatus != 0) 
608         { /* an error has occurred */ 
609                 switch(ei->CommandStatus)
610                 {
611                         case CMD_TARGET_STATUS:
612                                 /* Pass it up to the upper layers... */
613                                 if( ei->ScsiStatus)
614                                 {
615 #if 0
616                                         printk(KERN_WARNING "cciss: cmd %p "
617                                         "has SCSI Status = %x\n",
618                                                 cp,  
619                                                 ei->ScsiStatus); 
620 #endif
621                                         cmd->result |= (ei->ScsiStatus < 1);
622                                 }
623                                 else {  /* scsi status is zero??? How??? */
624                                         
625         /* Ordinarily, this case should never happen, but there is a bug
626            in some released firmware revisions that allows it to happen
627            if, for example, a 4100 backplane loses power and the tape
628            drive is in it.  We assume that it's a fatal error of some
629            kind because we can't show that it wasn't. We will make it
630            look like selection timeout since that is the most common
631            reason for this to occur, and it's severe enough. */
632
633                                         cmd->result = DID_NO_CONNECT << 16;
634                                 }
635                         break;
636                         case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
637                         break;
638                         case CMD_DATA_OVERRUN:
639                                 printk(KERN_WARNING "cciss: cp %p has"
640                                         " completed with data overrun "
641                                         "reported\n", cp);
642                         break;
643                         case CMD_INVALID: {
644                                 /* print_bytes(cp, sizeof(*cp), 1, 0);
645                                 print_cmd(cp); */
646      /* We get CMD_INVALID if you address a non-existent tape drive instead
647         of a selection timeout (no response).  You will see this if you yank 
648         out a tape drive, then try to access it. This is kind of a shame
649         because it means that any other CMD_INVALID (e.g. driver bug) will
650         get interpreted as a missing target. */
651                                 cmd->result = DID_NO_CONNECT << 16;
652                                 }
653                         break;
654                         case CMD_PROTOCOL_ERR:
655                                 printk(KERN_WARNING "cciss: cp %p has "
656                                         "protocol error \n", cp);
657                         break;
658                         case CMD_HARDWARE_ERR:
659                                 cmd->result = DID_ERROR << 16;
660                                 printk(KERN_WARNING "cciss: cp %p had " 
661                                         " hardware error\n", cp);
662                         break;
663                         case CMD_CONNECTION_LOST:
664                                 cmd->result = DID_ERROR << 16;
665                                 printk(KERN_WARNING "cciss: cp %p had "
666                                         "connection lost\n", cp);
667                         break;
668                         case CMD_ABORTED:
669                                 cmd->result = DID_ABORT << 16;
670                                 printk(KERN_WARNING "cciss: cp %p was "
671                                         "aborted\n", cp);
672                         break;
673                         case CMD_ABORT_FAILED:
674                                 cmd->result = DID_ERROR << 16;
675                                 printk(KERN_WARNING "cciss: cp %p reports "
676                                         "abort failed\n", cp);
677                         break;
678                         case CMD_UNSOLICITED_ABORT:
679                                 cmd->result = DID_ABORT << 16;
680                                 printk(KERN_WARNING "cciss: cp %p aborted "
681                                         "do to an unsolicited abort\n", cp);
682                         break;
683                         case CMD_TIMEOUT:
684                                 cmd->result = DID_TIME_OUT << 16;
685                                 printk(KERN_WARNING "cciss: cp %p timedout\n",
686                                         cp);
687                         break;
688                         default:
689                                 cmd->result = DID_ERROR << 16;
690                                 printk(KERN_WARNING "cciss: cp %p returned "
691                                         "unknown status %x\n", cp, 
692                                                 ei->CommandStatus); 
693                 }
694         }
695         // printk("c:%p:c%db%dt%dl%d ", cmd, ctlr->ctlr, cmd->channel, 
696         //      cmd->target, cmd->lun);
697         cmd->scsi_done(cmd);
698         scsi_cmd_free(ctlr, cp);
699 }
700
701 static int
702 cciss_scsi_detect(int ctlr)
703 {
704         struct Scsi_Host *sh;
705         int error;
706
707         sh = scsi_host_alloc(&cciss_driver_template, sizeof(struct ctlr_info *));
708         if (sh == NULL)
709                 goto fail;
710         sh->io_port = 0;        // good enough?  FIXME, 
711         sh->n_io_port = 0;      // I don't think we use these two...
712         sh->this_id = SELF_SCSI_ID;  
713
714         ((struct cciss_scsi_adapter_data_t *) 
715                 hba[ctlr]->scsi_ctlr)->scsi_host = (void *) sh;
716         sh->hostdata[0] = (unsigned long) hba[ctlr];
717         sh->irq = hba[ctlr]->intr;
718         sh->unique_id = sh->irq;
719         error = scsi_add_host(sh, &hba[ctlr]->pdev->dev);
720         if (error)
721                 goto fail_host_put;
722         scsi_scan_host(sh);
723         return 1;
724
725  fail_host_put:
726         scsi_host_put(sh);
727  fail:
728         return 0;
729 }
730
731 static void
732 cciss_unmap_one(struct pci_dev *pdev,
733                 CommandList_struct *cp,
734                 size_t buflen,
735                 int data_direction)
736 {
737         u64bit addr64;
738
739         addr64.val32.lower = cp->SG[0].Addr.lower;
740         addr64.val32.upper = cp->SG[0].Addr.upper;
741         pci_unmap_single(pdev, (dma_addr_t) addr64.val, buflen, data_direction);
742 }
743
744 static void
745 cciss_map_one(struct pci_dev *pdev,
746                 CommandList_struct *cp,
747                 unsigned char *buf,
748                 size_t buflen,
749                 int data_direction)
750 {
751         __u64 addr64;
752
753         addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
754         cp->SG[0].Addr.lower = 
755           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
756         cp->SG[0].Addr.upper =
757           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
758         cp->SG[0].Len = buflen;
759         cp->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
760         cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
761 }
762
763 static int
764 cciss_scsi_do_simple_cmd(ctlr_info_t *c,
765                         CommandList_struct *cp,
766                         unsigned char *scsi3addr, 
767                         unsigned char *cdb,
768                         unsigned char cdblen,
769                         unsigned char *buf, int bufsize,
770                         int direction)
771 {
772         unsigned long flags;
773         DECLARE_COMPLETION(wait);
774
775         cp->cmd_type = CMD_IOCTL_PEND;          // treat this like an ioctl 
776         cp->scsi_cmd = NULL;
777         cp->Header.ReplyQueue = 0;  // unused in simple mode
778         memcpy(&cp->Header.LUN, scsi3addr, sizeof(cp->Header.LUN));
779         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
780         // Fill in the request block...
781
782         /* printk("Using scsi3addr 0x%02x%0x2%0x2%0x2%0x2%0x2%0x2%0x2\n", 
783                 scsi3addr[0], scsi3addr[1], scsi3addr[2], scsi3addr[3],
784                 scsi3addr[4], scsi3addr[5], scsi3addr[6], scsi3addr[7]); */
785
786         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
787         memcpy(cp->Request.CDB, cdb, cdblen);
788         cp->Request.Timeout = 0;
789         cp->Request.CDBLen = cdblen;
790         cp->Request.Type.Type = TYPE_CMD;
791         cp->Request.Type.Attribute = ATTR_SIMPLE;
792         cp->Request.Type.Direction = direction;
793
794         /* Fill in the SG list and do dma mapping */
795         cciss_map_one(c->pdev, cp, (unsigned char *) buf,
796                         bufsize, DMA_FROM_DEVICE); 
797
798         cp->waiting = &wait;
799
800         /* Put the request on the tail of the request queue */
801         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
802         addQ(&c->reqQ, cp);
803         c->Qdepth++;
804         start_io(c);
805         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
806
807         wait_for_completion(&wait);
808
809         /* undo the dma mapping */
810         cciss_unmap_one(c->pdev, cp, bufsize, DMA_FROM_DEVICE);
811         return(0);
812 }
813
814 static void 
815 cciss_scsi_interpret_error(CommandList_struct *cp)
816 {
817         ErrorInfo_struct *ei;
818
819         ei = cp->err_info; 
820         switch(ei->CommandStatus)
821         {
822                 case CMD_TARGET_STATUS:
823                         printk(KERN_WARNING "cciss: cmd %p has "
824                                 "completed with errors\n", cp);
825                         printk(KERN_WARNING "cciss: cmd %p "
826                                 "has SCSI Status = %x\n",
827                                         cp,  
828                                         ei->ScsiStatus);
829                         if (ei->ScsiStatus == 0)
830                                 printk(KERN_WARNING 
831                                 "cciss:SCSI status is abnormally zero.  "
832                                 "(probably indicates selection timeout "
833                                 "reported incorrectly due to a known "
834                                 "firmware bug, circa July, 2001.)\n");
835                 break;
836                 case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
837                         printk("UNDERRUN\n");
838                 break;
839                 case CMD_DATA_OVERRUN:
840                         printk(KERN_WARNING "cciss: cp %p has"
841                                 " completed with data overrun "
842                                 "reported\n", cp);
843                 break;
844                 case CMD_INVALID: {
845                         /* controller unfortunately reports SCSI passthru's */
846                         /* to non-existent targets as invalid commands. */
847                         printk(KERN_WARNING "cciss: cp %p is "
848                                 "reported invalid (probably means "
849                                 "target device no longer present)\n", 
850                                 cp); 
851                         /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
852                         print_cmd(cp);  */
853                         }
854                 break;
855                 case CMD_PROTOCOL_ERR:
856                         printk(KERN_WARNING "cciss: cp %p has "
857                                 "protocol error \n", cp);
858                 break;
859                 case CMD_HARDWARE_ERR:
860                         /* cmd->result = DID_ERROR << 16; */
861                         printk(KERN_WARNING "cciss: cp %p had " 
862                                 " hardware error\n", cp);
863                 break;
864                 case CMD_CONNECTION_LOST:
865                         printk(KERN_WARNING "cciss: cp %p had "
866                                 "connection lost\n", cp);
867                 break;
868                 case CMD_ABORTED:
869                         printk(KERN_WARNING "cciss: cp %p was "
870                                 "aborted\n", cp);
871                 break;
872                 case CMD_ABORT_FAILED:
873                         printk(KERN_WARNING "cciss: cp %p reports "
874                                 "abort failed\n", cp);
875                 break;
876                 case CMD_UNSOLICITED_ABORT:
877                         printk(KERN_WARNING "cciss: cp %p aborted "
878                                 "do to an unsolicited abort\n", cp);
879                 break;
880                 case CMD_TIMEOUT:
881                         printk(KERN_WARNING "cciss: cp %p timedout\n",
882                                 cp);
883                 break;
884                 default:
885                         printk(KERN_WARNING "cciss: cp %p returned "
886                                 "unknown status %x\n", cp, 
887                                         ei->CommandStatus); 
888         }
889 }
890
891 static int
892 cciss_scsi_do_inquiry(ctlr_info_t *c, unsigned char *scsi3addr, 
893                  unsigned char *buf, unsigned char bufsize)
894 {
895         int rc;
896         CommandList_struct *cp;
897         char cdb[6];
898         ErrorInfo_struct *ei;
899         unsigned long flags;
900
901         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
902         cp = scsi_cmd_alloc(c);
903         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
904
905         if (cp == NULL) {                       /* trouble... */
906                 printk("cmd_alloc returned NULL!\n");
907                 return -1;
908         }
909
910         ei = cp->err_info; 
911
912         cdb[0] = CISS_INQUIRY;
913         cdb[1] = 0;
914         cdb[2] = 0;
915         cdb[3] = 0;
916         cdb[4] = bufsize;
917         cdb[5] = 0;
918         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, cdb, 
919                                 6, buf, bufsize, XFER_READ);
920
921         if (rc != 0) return rc; /* something went wrong */
922
923         if (ei->CommandStatus != 0 && 
924             ei->CommandStatus != CMD_DATA_UNDERRUN) {
925                 cciss_scsi_interpret_error(cp);
926                 rc = -1;
927         }
928         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
929         scsi_cmd_free(c, cp);
930         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
931         return rc;      
932 }
933
934 static int
935 cciss_scsi_do_report_phys_luns(ctlr_info_t *c, 
936                 ReportLunData_struct *buf, int bufsize)
937 {
938         int rc;
939         CommandList_struct *cp;
940         unsigned char cdb[12];
941         unsigned char scsi3addr[8]; 
942         ErrorInfo_struct *ei;
943         unsigned long flags;
944
945         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
946         cp = scsi_cmd_alloc(c);
947         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
948         if (cp == NULL) {                       /* trouble... */
949                 printk("cmd_alloc returned NULL!\n");
950                 return -1;
951         }
952
953         memset(&scsi3addr[0], 0, 8); /* address the controller */
954         cdb[0] = CISS_REPORT_PHYS;
955         cdb[1] = 0;
956         cdb[2] = 0;
957         cdb[3] = 0;
958         cdb[4] = 0;
959         cdb[5] = 0;
960         cdb[6] = (bufsize >> 24) & 0xFF;  //MSB
961         cdb[7] = (bufsize >> 16) & 0xFF;
962         cdb[8] = (bufsize >> 8) & 0xFF;
963         cdb[9] = bufsize & 0xFF;
964         cdb[10] = 0;
965         cdb[11] = 0;
966
967         rc = cciss_scsi_do_simple_cmd(c, cp, scsi3addr, 
968                                 cdb, 12, 
969                                 (unsigned char *) buf, 
970                                 bufsize, XFER_READ);
971
972         if (rc != 0) return rc; /* something went wrong */
973
974         ei = cp->err_info; 
975         if (ei->CommandStatus != 0 && 
976             ei->CommandStatus != CMD_DATA_UNDERRUN) {
977                 cciss_scsi_interpret_error(cp);
978                 rc = -1;
979         }
980         spin_lock_irqsave(CCISS_LOCK(c->ctlr), flags);
981         scsi_cmd_free(c, cp);
982         spin_unlock_irqrestore(CCISS_LOCK(c->ctlr), flags);
983         return rc;      
984 }
985
986 static void
987 cciss_update_non_disk_devices(int cntl_num, int hostno)
988 {
989         /* the idea here is we could get notified from /proc
990            that some devices have changed, so we do a report 
991            physical luns cmd, and adjust our list of devices 
992            accordingly.  (We can't rely on the scsi-mid layer just
993            doing inquiries, because the "busses" that the scsi 
994            mid-layer probes are totally fabricated by this driver,
995            so new devices wouldn't show up.
996
997            the scsi3addr's of devices won't change so long as the 
998            adapter is not reset.  That means we can rescan and 
999            tell which devices we already know about, vs. new 
1000            devices, vs.  disappearing devices.
1001
1002            Also, if you yank out a tape drive, then put in a disk
1003            in it's place, (say, a configured volume from another 
1004            array controller for instance)  _don't_ poke this driver 
1005            (so it thinks it's still a tape, but _do_ poke the scsi 
1006            mid layer, so it does an inquiry... the scsi mid layer 
1007            will see the physical disk.  This would be bad.  Need to
1008            think about how to prevent that.  One idea would be to 
1009            snoop all scsi responses and if an inquiry repsonse comes
1010            back that reports a disk, chuck it an return selection
1011            timeout instead and adjust our table...  Not sure i like
1012            that though.  
1013
1014          */
1015 #define OBDR_TAPE_INQ_SIZE 49
1016 #define OBDR_TAPE_SIG "$DR-10"
1017         ReportLunData_struct *ld_buff;
1018         unsigned char *inq_buff;
1019         unsigned char scsi3addr[8];
1020         ctlr_info_t *c;
1021         __u32 num_luns=0;
1022         unsigned char *ch;
1023         /* unsigned char found[CCISS_MAX_SCSI_DEVS_PER_HBA]; */
1024         struct cciss_scsi_dev_t currentsd[CCISS_MAX_SCSI_DEVS_PER_HBA];
1025         int ncurrent=0;
1026         int reportlunsize = sizeof(*ld_buff) + CISS_MAX_PHYS_LUN * 8;
1027         int i;
1028
1029         c = (ctlr_info_t *) hba[cntl_num];      
1030         ld_buff = kmalloc(reportlunsize, GFP_KERNEL);
1031         if (ld_buff == NULL) {
1032                 printk(KERN_ERR "cciss: out of memory\n");
1033                 return;
1034         }
1035         memset(ld_buff, 0, reportlunsize);
1036         inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
1037         if (inq_buff == NULL) {
1038                 printk(KERN_ERR "cciss: out of memory\n");
1039                 kfree(ld_buff);
1040                 return;
1041         }
1042
1043         if (cciss_scsi_do_report_phys_luns(c, ld_buff, reportlunsize) == 0) {
1044                 ch = &ld_buff->LUNListLength[0];
1045                 num_luns = ((ch[0]<<24) | (ch[1]<<16) | (ch[2]<<8) | ch[3]) / 8;
1046                 if (num_luns > CISS_MAX_PHYS_LUN) {
1047                         printk(KERN_WARNING 
1048                                 "cciss: Maximum physical LUNs (%d) exceeded.  "
1049                                 "%d LUNs ignored.\n", CISS_MAX_PHYS_LUN, 
1050                                 num_luns - CISS_MAX_PHYS_LUN);
1051                         num_luns = CISS_MAX_PHYS_LUN;
1052                 }
1053         }
1054         else {
1055                 printk(KERN_ERR  "cciss: Report physical LUNs failed.\n");
1056                 goto out;
1057         }
1058
1059
1060         /* adjust our table of devices */       
1061         for(i=0; i<num_luns; i++)
1062         {
1063                 int devtype;
1064
1065                 /* for each physical lun, do an inquiry */
1066                 if (ld_buff->LUN[i][3] & 0xC0) continue;
1067                 memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
1068                 memcpy(&scsi3addr[0], &ld_buff->LUN[i][0], 8);
1069
1070                 if (cciss_scsi_do_inquiry(hba[cntl_num], scsi3addr, inq_buff,
1071                         (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) {
1072                         /* Inquiry failed (msg printed already) */
1073                         devtype = 0; /* so we will skip this device. */
1074                 } else /* what kind of device is this? */
1075                         devtype = (inq_buff[0] & 0x1f);
1076
1077                 switch (devtype)
1078                 {
1079                   case 0x05: /* CD-ROM */ {
1080
1081                         /* We don't *really* support actual CD-ROM devices,
1082                          * just this "One Button Disaster Recovery" tape drive
1083                          * which temporarily pretends to be a CD-ROM drive.
1084                          * So we check that the device is really an OBDR tape
1085                          * device by checking for "$DR-10" in bytes 43-48 of
1086                          * the inquiry data.
1087                          */
1088                                 char obdr_sig[7];
1089
1090                                 strncpy(obdr_sig, &inq_buff[43], 6);
1091                                 obdr_sig[6] = '\0';
1092                                 if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
1093                                         /* Not OBDR device, ignore it. */
1094                                         break;
1095                         }
1096                         /* fall through . . . */
1097                   case 0x01: /* sequential access, (tape) */
1098                   case 0x08: /* medium changer */
1099                         if (ncurrent >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
1100                                 printk(KERN_INFO "cciss%d: %s ignored, "
1101                                         "too many devices.\n", cntl_num,
1102                                         DEVICETYPE(devtype));
1103                                 break;
1104                         }
1105                         memcpy(&currentsd[ncurrent].scsi3addr[0], 
1106                                 &scsi3addr[0], 8);
1107                         currentsd[ncurrent].devtype = devtype;
1108                         currentsd[ncurrent].bus = -1;
1109                         currentsd[ncurrent].target = -1;
1110                         currentsd[ncurrent].lun = -1;
1111                         ncurrent++;
1112                         break;
1113                   default: 
1114                         break;
1115                 }
1116         }
1117
1118         adjust_cciss_scsi_table(cntl_num, hostno, currentsd, ncurrent);
1119 out:
1120         kfree(inq_buff);
1121         kfree(ld_buff);
1122         return;
1123 }
1124
1125 static int
1126 is_keyword(char *ptr, int len, char *verb)  // Thanks to ncr53c8xx.c
1127 {
1128         int verb_len = strlen(verb);
1129         if (len >= verb_len && !memcmp(verb,ptr,verb_len))
1130                 return verb_len;
1131         else
1132                 return 0;
1133 }
1134
1135 static int
1136 cciss_scsi_user_command(int ctlr, int hostno, char *buffer, int length)
1137 {
1138         int arg_len;
1139
1140         if ((arg_len = is_keyword(buffer, length, "rescan")) != 0)
1141                 cciss_update_non_disk_devices(ctlr, hostno);
1142         else
1143                 return -EINVAL;
1144         return length;
1145 }
1146
1147
1148 static int
1149 cciss_scsi_proc_info(struct Scsi_Host *sh,
1150                 char *buffer, /* data buffer */
1151                 char **start,      /* where data in buffer starts */
1152                 off_t offset,      /* offset from start of imaginary file */
1153                 int length,        /* length of data in buffer */
1154                 int func)          /* 0 == read, 1 == write */
1155 {
1156
1157         int buflen, datalen;
1158         ctlr_info_t *ci;
1159         int i;
1160         int cntl_num;
1161
1162
1163         ci = (ctlr_info_t *) sh->hostdata[0];
1164         if (ci == NULL)  /* This really shouldn't ever happen. */
1165                 return -EINVAL;
1166
1167         cntl_num = ci->ctlr;    /* Get our index into the hba[] array */
1168
1169         if (func == 0) {        /* User is reading from /proc/scsi/ciss*?/?*  */
1170                 buflen = sprintf(buffer, "cciss%d: SCSI host: %d\n",
1171                                 cntl_num, sh->host_no);
1172
1173                 /* this information is needed by apps to know which cciss
1174                    device corresponds to which scsi host number without
1175                    having to open a scsi target device node.  The device
1176                    information is not a duplicate of /proc/scsi/scsi because
1177                    the two may be out of sync due to scsi hotplug, rather
1178                    this info is for an app to be able to use to know how to
1179                    get them back in sync. */
1180
1181                 for (i=0;i<ccissscsi[cntl_num].ndevices;i++) {
1182                         struct cciss_scsi_dev_t *sd = &ccissscsi[cntl_num].dev[i];
1183                         buflen += sprintf(&buffer[buflen], "c%db%dt%dl%d %02d "
1184                                 "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1185                                 sh->host_no, sd->bus, sd->target, sd->lun,
1186                                 sd->devtype,
1187                                 sd->scsi3addr[0], sd->scsi3addr[1],
1188                                 sd->scsi3addr[2], sd->scsi3addr[3],
1189                                 sd->scsi3addr[4], sd->scsi3addr[5],
1190                                 sd->scsi3addr[6], sd->scsi3addr[7]);
1191                 }
1192                 datalen = buflen - offset;
1193                 if (datalen < 0) {      /* they're reading past EOF. */
1194                         datalen = 0;
1195                         *start = buffer+buflen; 
1196                 } else
1197                         *start = buffer + offset;
1198                 return(datalen);
1199         } else  /* User is writing to /proc/scsi/cciss*?/?*  ... */
1200                 return cciss_scsi_user_command(cntl_num, sh->host_no,
1201                         buffer, length);        
1202
1203
1204 /* cciss_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci 
1205    dma mapping  and fills in the scatter gather entries of the 
1206    cciss command, cp. */
1207
1208 static void
1209 cciss_scatter_gather(struct pci_dev *pdev, 
1210                 CommandList_struct *cp, 
1211                 struct scsi_cmnd *cmd)
1212 {
1213         unsigned int use_sg, nsegs=0, len;
1214         struct scatterlist *scatter = (struct scatterlist *) cmd->buffer;
1215         __u64 addr64;
1216
1217         /* is it just one virtual address? */   
1218         if (!cmd->use_sg) {
1219                 if (cmd->request_bufflen) {     /* anything to xfer? */
1220
1221                         addr64 = (__u64) pci_map_single(pdev, 
1222                                 cmd->request_buffer, 
1223                                 cmd->request_bufflen, 
1224                                 cmd->sc_data_direction); 
1225         
1226                         cp->SG[0].Addr.lower = 
1227                           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1228                         cp->SG[0].Addr.upper =
1229                           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1230                         cp->SG[0].Len = cmd->request_bufflen;
1231                         nsegs=1;
1232                 }
1233         } /* else, must be a list of virtual addresses.... */
1234         else if (cmd->use_sg <= MAXSGENTRIES) { /* not too many addrs? */
1235
1236                 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, 
1237                         cmd->sc_data_direction);
1238
1239                 for (nsegs=0; nsegs < use_sg; nsegs++) {
1240                         addr64 = (__u64) sg_dma_address(&scatter[nsegs]);
1241                         len  = sg_dma_len(&scatter[nsegs]);
1242                         cp->SG[nsegs].Addr.lower =
1243                           (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
1244                         cp->SG[nsegs].Addr.upper =
1245                           (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
1246                         cp->SG[nsegs].Len = len;
1247                         cp->SG[nsegs].Ext = 0;  // we are not chaining
1248                 }
1249         } else BUG();
1250
1251         cp->Header.SGList = (__u8) nsegs;   /* no. SGs contig in this cmd */
1252         cp->Header.SGTotal = (__u16) nsegs; /* total sgs in this cmd list */
1253         return;
1254 }
1255
1256
1257 static int
1258 cciss_scsi_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
1259 {
1260         ctlr_info_t **c;
1261         int ctlr, rc;
1262         unsigned char scsi3addr[8];
1263         CommandList_struct *cp;
1264         unsigned long flags;
1265
1266         // Get the ptr to our adapter structure (hba[i]) out of cmd->host.
1267         // We violate cmd->host privacy here.  (Is there another way?)
1268         c = (ctlr_info_t **) &cmd->device->host->hostdata[0];   
1269         ctlr = (*c)->ctlr;
1270
1271         rc = lookup_scsi3addr(ctlr, cmd->device->channel, cmd->device->id, 
1272                         cmd->device->lun, scsi3addr);
1273         if (rc != 0) {
1274                 /* the scsi nexus does not match any that we presented... */
1275                 /* pretend to mid layer that we got selection timeout */
1276                 cmd->result = DID_NO_CONNECT << 16;
1277                 done(cmd);
1278                 /* we might want to think about registering controller itself
1279                    as a processor device on the bus so sg binds to it. */
1280                 return 0;
1281         }
1282
1283         /* printk("cciss_queue_command, p=%p, cmd=0x%02x, c%db%dt%dl%d\n", 
1284                 cmd, cmd->cmnd[0], ctlr, cmd->channel, cmd->target, cmd->lun);*/
1285         // printk("q:%p:c%db%dt%dl%d ", cmd, ctlr, cmd->channel, 
1286         //      cmd->target, cmd->lun);
1287
1288         /* Ok, we have a reasonable scsi nexus, so send the cmd down, and
1289            see what the device thinks of it. */
1290
1291         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1292         cp = scsi_cmd_alloc(*c);
1293         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1294         if (cp == NULL) {                       /* trouble... */
1295                 printk("scsi_cmd_alloc returned NULL!\n");
1296                 /* FIXME: next 3 lines are -> BAD! <- */
1297                 cmd->result = DID_NO_CONNECT << 16;
1298                 done(cmd);
1299                 return 0;
1300         }
1301
1302         // Fill in the command list header
1303
1304         cmd->scsi_done = done;    // save this for use by completion code 
1305
1306         // save cp in case we have to abort it 
1307         cmd->host_scribble = (unsigned char *) cp; 
1308
1309         cp->cmd_type = CMD_SCSI;
1310         cp->scsi_cmd = cmd;
1311         cp->Header.ReplyQueue = 0;  // unused in simple mode
1312         memcpy(&cp->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
1313         cp->Header.Tag.lower = cp->busaddr;  // Use k. address of cmd as tag
1314         
1315         // Fill in the request block...
1316
1317         cp->Request.Timeout = 0;
1318         memset(cp->Request.CDB, 0, sizeof(cp->Request.CDB));
1319         if (cmd->cmd_len > sizeof(cp->Request.CDB)) BUG();
1320         cp->Request.CDBLen = cmd->cmd_len;
1321         memcpy(cp->Request.CDB, cmd->cmnd, cmd->cmd_len);
1322         cp->Request.Type.Type = TYPE_CMD;
1323         cp->Request.Type.Attribute = ATTR_SIMPLE;
1324         switch(cmd->sc_data_direction)
1325         {
1326           case DMA_TO_DEVICE: cp->Request.Type.Direction = XFER_WRITE; break;
1327           case DMA_FROM_DEVICE: cp->Request.Type.Direction = XFER_READ; break;
1328           case DMA_NONE: cp->Request.Type.Direction = XFER_NONE; break;
1329           case DMA_BIDIRECTIONAL:
1330                 // This can happen if a buggy application does a scsi passthru
1331                 // and sets both inlen and outlen to non-zero. ( see
1332                 // ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
1333
1334                 cp->Request.Type.Direction = XFER_RSVD;
1335                 // This is technically wrong, and cciss controllers should
1336                 // reject it with CMD_INVALID, which is the most correct 
1337                 // response, but non-fibre backends appear to let it 
1338                 // slide by, and give the same results as if this field
1339                 // were set correctly.  Either way is acceptable for
1340                 // our purposes here.
1341
1342                 break;
1343
1344           default: 
1345                 printk("cciss: unknown data direction: %d\n", 
1346                         cmd->sc_data_direction);
1347                 BUG();
1348                 break;
1349         }
1350
1351         cciss_scatter_gather((*c)->pdev, cp, cmd); // Fill the SG list
1352
1353         /* Put the request on the tail of the request queue */
1354
1355         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1356         addQ(&(*c)->reqQ, cp);
1357         (*c)->Qdepth++;
1358         start_io(*c);
1359         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1360
1361         /* the cmd'll come back via intr handler in complete_scsi_command()  */
1362         return 0;
1363 }
1364
1365 static void 
1366 cciss_unregister_scsi(int ctlr)
1367 {
1368         struct cciss_scsi_adapter_data_t *sa;
1369         struct cciss_scsi_cmd_stack_t *stk;
1370         unsigned long flags;
1371
1372         /* we are being forcibly unloaded, and may not refuse. */
1373
1374         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1375         sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1376         stk = &sa->cmd_stack; 
1377
1378         /* if we weren't ever actually registered, don't unregister */ 
1379         if (sa->registered) {
1380                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1381                 scsi_remove_host(sa->scsi_host);
1382                 scsi_host_put(sa->scsi_host);
1383                 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1384         }
1385
1386         /* set scsi_host to NULL so our detect routine will 
1387            find us on register */
1388         sa->scsi_host = NULL;
1389         scsi_cmd_stack_free(ctlr);
1390         kfree(sa);
1391         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1392 }
1393
1394 static int 
1395 cciss_register_scsi(int ctlr)
1396 {
1397         unsigned long flags;
1398
1399         CPQ_TAPE_LOCK(ctlr, flags);
1400
1401         /* Since this is really a block driver, the SCSI core may not be 
1402            initialized at init time, in which case, calling scsi_register_host
1403            would hang.  Instead, we do it later, via /proc filesystem
1404            and rc scripts, when we know SCSI core is good to go. */
1405
1406         /* Only register if SCSI devices are detected. */
1407         if (ccissscsi[ctlr].ndevices != 0) {
1408                 ((struct cciss_scsi_adapter_data_t *) 
1409                         hba[ctlr]->scsi_ctlr)->registered = 1;
1410                 CPQ_TAPE_UNLOCK(ctlr, flags);
1411                 return cciss_scsi_detect(ctlr);
1412         }
1413         CPQ_TAPE_UNLOCK(ctlr, flags);
1414         printk(KERN_INFO 
1415                 "cciss%d: No appropriate SCSI device detected, "
1416                 "SCSI subsystem not engaged.\n", ctlr);
1417         return 0;
1418 }
1419
1420 static int 
1421 cciss_engage_scsi(int ctlr)
1422 {
1423         struct cciss_scsi_adapter_data_t *sa;
1424         struct cciss_scsi_cmd_stack_t *stk;
1425         unsigned long flags;
1426
1427         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1428         sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
1429         stk = &sa->cmd_stack; 
1430
1431         if (((struct cciss_scsi_adapter_data_t *) 
1432                 hba[ctlr]->scsi_ctlr)->registered) {
1433                 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
1434                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1435                 return ENXIO;
1436         }
1437         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1438         cciss_update_non_disk_devices(ctlr, -1);
1439         cciss_register_scsi(ctlr);
1440         return 0;
1441 }
1442
1443 static void
1444 cciss_proc_tape_report(int ctlr, unsigned char *buffer, off_t *pos, off_t *len)
1445 {
1446         unsigned long flags;
1447         int size;
1448
1449         *pos = *pos -1; *len = *len - 1; // cut off the last trailing newline
1450
1451         CPQ_TAPE_LOCK(ctlr, flags);
1452         size = sprintf(buffer + *len, 
1453                 "Sequential access devices: %d\n\n",
1454                         ccissscsi[ctlr].ndevices);
1455         CPQ_TAPE_UNLOCK(ctlr, flags);
1456         *pos += size; *len += size;
1457 }
1458
1459 /* Need at least one of these error handlers to keep ../scsi/hosts.c from 
1460  * complaining.  Doing a host- or bus-reset can't do anything good here. 
1461  * Despite what it might say in scsi_error.c, there may well be commands
1462  * on the controller, as the cciss driver registers twice, once as a block
1463  * device for the logical drives, and once as a scsi device, for any tape
1464  * drives.  So we know there are no commands out on the tape drives, but we
1465  * don't know there are no commands on the controller, and it is likely 
1466  * that there probably are, as the cciss block device is most commonly used
1467  * as a boot device (embedded controller on HP/Compaq systems.)
1468 */
1469
1470 static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
1471 {
1472         int rc;
1473         CommandList_struct *cmd_in_trouble;
1474         ctlr_info_t **c;
1475         int ctlr;
1476
1477         /* find the controller to which the command to be aborted was sent */
1478         c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];       
1479         if (c == NULL) /* paranoia */
1480                 return FAILED;
1481         ctlr = (*c)->ctlr;
1482         printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
1483
1484         /* find the command that's giving us trouble */
1485         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
1486         if (cmd_in_trouble == NULL) { /* paranoia */
1487                 return FAILED;
1488         }
1489         /* send a reset to the SCSI LUN which the command was sent to */
1490         rc = sendcmd(CCISS_RESET_MSG, ctlr, NULL, 0, 2, 0, 0, 
1491                 (unsigned char *) &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 
1492                 TYPE_MSG);
1493         /* sendcmd turned off interrputs on the board, turn 'em back on. */
1494         (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
1495         if (rc == 0)
1496                 return SUCCESS;
1497         printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
1498         return FAILED;
1499 }
1500
1501 static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
1502 {
1503         int rc;
1504         CommandList_struct *cmd_to_abort;
1505         ctlr_info_t **c;
1506         int ctlr;
1507
1508         /* find the controller to which the command to be aborted was sent */
1509         c = (ctlr_info_t **) &scsicmd->device->host->hostdata[0];       
1510         if (c == NULL) /* paranoia */
1511                 return FAILED;
1512         ctlr = (*c)->ctlr;
1513         printk(KERN_WARNING "cciss%d: aborting tardy SCSI cmd\n", ctlr);
1514
1515         /* find the command to be aborted */
1516         cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
1517         if (cmd_to_abort == NULL) /* paranoia */
1518                 return FAILED;
1519         rc = sendcmd(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag, 
1520                 0, 2, 0, 0, 
1521                 (unsigned char *) &cmd_to_abort->Header.LUN.LunAddrBytes[0], 
1522                 TYPE_MSG);
1523         /* sendcmd turned off interrputs on the board, turn 'em back on. */
1524         (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
1525         if (rc == 0)
1526                 return SUCCESS;
1527         return FAILED;
1528
1529 }
1530
1531 #else /* no CONFIG_CISS_SCSI_TAPE */
1532
1533 /* If no tape support, then these become defined out of existence */
1534
1535 #define cciss_scsi_setup(cntl_num)
1536 #define cciss_unregister_scsi(ctlr)
1537 #define cciss_register_scsi(ctlr)
1538 #define cciss_proc_tape_report(ctlr, buffer, pos, len)
1539
1540 #endif /* CONFIG_CISS_SCSI_TAPE */