]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/scsi/aacraid/aachba.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix common misspellings
[mirror_ubuntu-jammy-kernel.git] / drivers / scsi / aacraid / aachba.c
CommitLineData
1da177e4
LT		 1/*
2 * Adaptec AAC series RAID controller driver
fa195afe 3 * (c) Copyright 2001 Red Hat Inc.
1da177e4
LT		 4 *
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
7 *
e8b12f0f
MR		 8 * Copyright (c) 2000-2010 Adaptec, Inc.
9 * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
1da177e4
LT		 10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 */
26
27#include <linux/kernel.h>
28#include <linux/init.h>
29#include <linux/types.h>
1da177e4
LT		 30#include <linux/pci.h>
31#include <linux/spinlock.h>
32#include <linux/slab.h>
33#include <linux/completion.h>
34#include <linux/blkdev.h>
1da177e4 35#include <asm/uaccess.h>
3a0086a8 36#include <linux/highmem.h> /* For flush_kernel_dcache_page */
1da177e4
LT		 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 "aacraid.h"
44
45/* values for inqd_pdt: Peripheral device type in plain English */
46#define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */
47#define INQD_PDT_PROC 0x03 /* Processor device */
48#define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */
49#define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */
50#define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */
51#define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */
52
53#define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */
54#define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */
55
1da177e4
LT		 56/*
57 * Sense codes
58 */
8ce3eca4
SM		 59
60#define SENCODE_NO_SENSE 0x00
61#define SENCODE_END_OF_DATA 0x00
62#define SENCODE_BECOMING_READY 0x04
63#define SENCODE_INIT_CMD_REQUIRED 0x04
64#define SENCODE_PARAM_LIST_LENGTH_ERROR 0x1A
65#define SENCODE_INVALID_COMMAND 0x20
66#define SENCODE_LBA_OUT_OF_RANGE 0x21
67#define SENCODE_INVALID_CDB_FIELD 0x24
68#define SENCODE_LUN_NOT_SUPPORTED 0x25
69#define SENCODE_INVALID_PARAM_FIELD 0x26
70#define SENCODE_PARAM_NOT_SUPPORTED 0x26
71#define SENCODE_PARAM_VALUE_INVALID 0x26
72#define SENCODE_RESET_OCCURRED 0x29
73#define SENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x3E
74#define SENCODE_INQUIRY_DATA_CHANGED 0x3F
75#define SENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x39
76#define SENCODE_DIAGNOSTIC_FAILURE 0x40
77#define SENCODE_INTERNAL_TARGET_FAILURE 0x44
78#define SENCODE_INVALID_MESSAGE_ERROR 0x49
79#define SENCODE_LUN_FAILED_SELF_CONFIG 0x4c
80#define SENCODE_OVERLAPPED_COMMAND 0x4E
1da177e4
LT		 81
82/*
83 * Additional sense codes
84 */
8ce3eca4
SM		 85
86#define ASENCODE_NO_SENSE 0x00
87#define ASENCODE_END_OF_DATA 0x05
88#define ASENCODE_BECOMING_READY 0x01
89#define ASENCODE_INIT_CMD_REQUIRED 0x02
90#define ASENCODE_PARAM_LIST_LENGTH_ERROR 0x00
91#define ASENCODE_INVALID_COMMAND 0x00
92#define ASENCODE_LBA_OUT_OF_RANGE 0x00
93#define ASENCODE_INVALID_CDB_FIELD 0x00
94#define ASENCODE_LUN_NOT_SUPPORTED 0x00
95#define ASENCODE_INVALID_PARAM_FIELD 0x00
96#define ASENCODE_PARAM_NOT_SUPPORTED 0x01
97#define ASENCODE_PARAM_VALUE_INVALID 0x02
98#define ASENCODE_RESET_OCCURRED 0x00
99#define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x00
100#define ASENCODE_INQUIRY_DATA_CHANGED 0x03
101#define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x00
102#define ASENCODE_DIAGNOSTIC_FAILURE 0x80
103#define ASENCODE_INTERNAL_TARGET_FAILURE 0x00
104#define ASENCODE_INVALID_MESSAGE_ERROR 0x00
105#define ASENCODE_LUN_FAILED_SELF_CONFIG 0x00
106#define ASENCODE_OVERLAPPED_COMMAND 0x00
1da177e4
LT		 107
108#define BYTE0(x) (unsigned char)(x)
109#define BYTE1(x) (unsigned char)((x) >> 8)
110#define BYTE2(x) (unsigned char)((x) >> 16)
111#define BYTE3(x) (unsigned char)((x) >> 24)
112
113/*------------------------------------------------------------------------------
114 * S T R U C T S / T Y P E D E F S
115 *----------------------------------------------------------------------------*/
116/* SCSI inquiry data */
117struct inquiry_data {
8ce3eca4
SM		 118 u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */
119 u8 inqd_dtq; /* RMB | Device Type Qualifier */
1da177e4
LT		 120 u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */
121 u8 inqd_rdf; /* AENC | TrmIOP | Response data format */
122 u8 inqd_len; /* Additional length (n-4) */
123 u8 inqd_pad1[2];/* Reserved - must be zero */
124 u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */
125 u8 inqd_vid[8]; /* Vendor ID */
126 u8 inqd_pid[16];/* Product ID */
127 u8 inqd_prl[4]; /* Product Revision Level */
128};
129
130/*
131 * M O D U L E G L O B A L S
132 */
8ce3eca4 133
1da177e4
LT		 134static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap);
135static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg);
0e68c003 136static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg);
1da177e4
LT		 137static int aac_send_srb_fib(struct scsi_cmnd* scsicmd);
138#ifdef AAC_DETAILED_STATUS_INFO
139static char *aac_get_status_string(u32 status);
140#endif
141
142/*
143 * Non dasd selection is handled entirely in aachba now
8ce3eca4
SM		 144 */
145
1da177e4 146static int nondasd = -1;
d8e96507 147static int aac_cache = 2; /* WCE=0 to avoid performance problems */
1da177e4 148static int dacmode = -1;
8ef22247 149int aac_msi;
1208bab5 150int aac_commit = -1;
404d9a90
MH		 151int startup_timeout = 180;
152int aif_timeout = 120;
1da177e4 153
9a72f976 154module_param(nondasd, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 155MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices."
156 " 0=off, 1=on");
95e852e1 157module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 158MODULE_PARM_DESC(cache, "Disable Queue Flush commands:\n"
159 "\tbit 0 - Disable FUA in WRITE SCSI commands\n"
160 "\tbit 1 - Disable SYNCHRONIZE_CACHE SCSI command\n"
d8e96507 161 "\tbit 2 - Disable only if Battery is protecting Cache");
9a72f976 162module_param(dacmode, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 163MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC."
164 " 0=off, 1=on");
1208bab5 165module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 166MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the"
167 " adapter for foreign arrays.\n"
168 "This is typically needed in systems that do not have a BIOS."
169 " 0=off, 1=on");
170module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR);
171MODULE_PARM_DESC(msi, "IRQ handling."
172 " 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)");
404d9a90 173module_param(startup_timeout, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 174MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for"
175 " adapter to have it's kernel up and\n"
176 "running. This is typically adjusted for large systems that do not"
177 " have a BIOS.");
404d9a90 178module_param(aif_timeout, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 179MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for"
180 " applications to pick up AIFs before\n"
181 "deregistering them. This is typically adjusted for heavily burdened"
182 " systems.");
1da177e4 183
7c00ffa3
MH		 184int numacb = -1;
185module_param(numacb, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 186MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control"
187 " blocks (FIB) allocated. Valid values are 512 and down. Default is"
188 " to use suggestion from Firmware.");
7c00ffa3
MH		 189
190int acbsize = -1;
191module_param(acbsize, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 192MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB)"
193 " size. Valid values are 512, 2048, 4096 and 8192. Default is to use"
194 " suggestion from Firmware.");
653ba58d 195
29c97684
SM		 196int update_interval = 30 * 60;
197module_param(update_interval, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 198MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync"
199 " updates issued to adapter.");
29c97684
SM		 200
201int check_interval = 24 * 60 * 60;
202module_param(check_interval, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 203MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health"
204 " checks.");
29c97684 205
87f3bda3
AM		 206int aac_check_reset = 1;
207module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR);
95e7a8ef 208MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the"
8ef22247
SM		 209 " adapter. a value of -1 forces the reset to adapters programmed to"
210 " ignore it.");
29c97684 211
e37ee4be 212int expose_physicals = -1;
653ba58d 213module_param(expose_physicals, int, S_IRUGO|S_IWUSR);
8ef22247
SM		 214MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays."
215 " -1=protect 0=off, 1=on");
03d44337 216
8ef22247 217int aac_reset_devices;
1208bab5
SM		 218module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR);
219MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization.");
03d44337 220
d8e96507
LA		 221int aac_wwn = 1;
222module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR);
223MODULE_PARM_DESC(wwn, "Select a WWN type for the arrays:\n"
224 "\t0 - Disable\n"
225 "\t1 - Array Meta Data Signature (default)\n"
226 "\t2 - Adapter Serial Number");
227
228
03d44337
MH		 229static inline int aac_valid_context(struct scsi_cmnd *scsicmd,
230 struct fib *fibptr) {
231 struct scsi_device *device;
232
8ce3eca4 233 if (unlikely(!scsicmd || !scsicmd->scsi_done)) {
c835e372 234 dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n"));
8ce3eca4
SM		 235 aac_fib_complete(fibptr);
236 aac_fib_free(fibptr);
237 return 0;
238 }
03d44337
MH		 239 scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL;
240 device = scsicmd->device;
241 if (unlikely(!device || !scsi_device_online(device))) {
242 dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n"));
243 aac_fib_complete(fibptr);
244 aac_fib_free(fibptr);
245 return 0;
246 }
247 return 1;
248}
249
1da177e4
LT		 250/**
251 * aac_get_config_status - check the adapter configuration
252 * @common: adapter to query
253 *
254 * Query config status, and commit the configuration if needed.
255 */
8c867b25 256int aac_get_config_status(struct aac_dev *dev, int commit_flag)
1da177e4
LT		 257{
258 int status = 0;
259 struct fib * fibptr;
260
bfb35aa8 261 if (!(fibptr = aac_fib_alloc(dev)))
1da177e4
LT		 262 return -ENOMEM;
263
bfb35aa8 264 aac_fib_init(fibptr);
1da177e4
LT		 265 {
266 struct aac_get_config_status *dinfo;
267 dinfo = (struct aac_get_config_status *) fib_data(fibptr);
268
269 dinfo->command = cpu_to_le32(VM_ContainerConfig);
270 dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS);
271 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data));
272 }
273
bfb35aa8 274 status = aac_fib_send(ContainerCommand,
1da177e4
LT		 275 fibptr,
276 sizeof (struct aac_get_config_status),
277 FsaNormal,
278 1, 1,
279 NULL, NULL);
8ce3eca4 280 if (status < 0) {
1da177e4
LT		 281 printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n");
282 } else {
283 struct aac_get_config_status_resp *reply
284 = (struct aac_get_config_status_resp *) fib_data(fibptr);
285 dprintk((KERN_WARNING
286 "aac_get_config_status: response=%d status=%d action=%d\n",
287 le32_to_cpu(reply->response),
288 le32_to_cpu(reply->status),
289 le32_to_cpu(reply->data.action)));
290 if ((le32_to_cpu(reply->response) != ST_OK) ||
291 (le32_to_cpu(reply->status) != CT_OK) ||
292 (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) {
293 printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n");
294 status = -EINVAL;
295 }
296 }
cacb6dc3
PNRCEH		 297 /* Do not set XferState to zero unless receives a response from F/W */
298 if (status >= 0)
299 aac_fib_complete(fibptr);
300
1da177e4
LT		 301 /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
302 if (status >= 0) {
1208bab5 303 if ((aac_commit == 1) || commit_flag) {
1da177e4 304 struct aac_commit_config * dinfo;
bfb35aa8 305 aac_fib_init(fibptr);
1da177e4 306 dinfo = (struct aac_commit_config *) fib_data(fibptr);
8ce3eca4 307
1da177e4
LT		 308 dinfo->command = cpu_to_le32(VM_ContainerConfig);
309 dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG);
8ce3eca4 310
bfb35aa8 311 status = aac_fib_send(ContainerCommand,
1da177e4
LT		 312 fibptr,
313 sizeof (struct aac_commit_config),
314 FsaNormal,
315 1, 1,
316 NULL, NULL);
cacb6dc3
PNRCEH		 317 /* Do not set XferState to zero unless
318 * receives a response from F/W */
319 if (status >= 0)
320 aac_fib_complete(fibptr);
1208bab5 321 } else if (aac_commit == 0) {
1da177e4
LT		 322 printk(KERN_WARNING
323 "aac_get_config_status: Foreign device configurations are being ignored\n");
324 }
325 }
cacb6dc3
PNRCEH		 326 /* FIB should be freed only after getting the response from the F/W */
327 if (status != -ERESTARTSYS)
328 aac_fib_free(fibptr);
1da177e4
LT		 329 return status;
330}
331
e3cc268f
RM		 332static void aac_expose_phy_device(struct scsi_cmnd *scsicmd)
333{
334 char inq_data;
335 scsi_sg_copy_to_buffer(scsicmd, &inq_data, sizeof(inq_data));
336 if ((inq_data & 0x20) && (inq_data & 0x1f) == TYPE_DISK) {
337 inq_data &= 0xdf;
338 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data));
339 }
340}
341
1da177e4
LT		 342/**
343 * aac_get_containers - list containers
344 * @common: adapter to probe
345 *
346 * Make a list of all containers on this controller
347 */
348int aac_get_containers(struct aac_dev *dev)
349{
350 struct fsa_dev_info *fsa_dev_ptr;
8ce3eca4 351 u32 index;
1da177e4
LT		 352 int status = 0;
353 struct fib * fibptr;
1da177e4
LT		 354 struct aac_get_container_count *dinfo;
355 struct aac_get_container_count_resp *dresp;
356 int maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
357
bfb35aa8 358 if (!(fibptr = aac_fib_alloc(dev)))
1da177e4
LT		 359 return -ENOMEM;
360
bfb35aa8 361 aac_fib_init(fibptr);
1da177e4
LT		 362 dinfo = (struct aac_get_container_count *) fib_data(fibptr);
363 dinfo->command = cpu_to_le32(VM_ContainerConfig);
364 dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT);
365
bfb35aa8 366 status = aac_fib_send(ContainerCommand,
1da177e4
LT		 367 fibptr,
368 sizeof (struct aac_get_container_count),
369 FsaNormal,
370 1, 1,
371 NULL, NULL);
372 if (status >= 0) {
373 dresp = (struct aac_get_container_count_resp *)fib_data(fibptr);
374 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
bfb35aa8 375 aac_fib_complete(fibptr);
1da177e4 376 }
cacb6dc3
PNRCEH		 377 /* FIB should be freed only after getting the response from the F/W */
378 if (status != -ERESTARTSYS)
379 aac_fib_free(fibptr);
1da177e4
LT		 380
381 if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
382 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
1a655040 383 fsa_dev_ptr = kzalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers,
fe76df42
MH		 384 GFP_KERNEL);
385 if (!fsa_dev_ptr)
1da177e4 386 return -ENOMEM;
1da177e4
LT		 387
388 dev->fsa_dev = fsa_dev_ptr;
389 dev->maximum_num_containers = maximum_num_containers;
390
fe76df42 391 for (index = 0; index < dev->maximum_num_containers; ) {
1da177e4
LT		 392 fsa_dev_ptr[index].devname[0] = '\0';
393
fe76df42 394 status = aac_probe_container(dev, index);
1da177e4 395
fe76df42 396 if (status < 0) {
1da177e4
LT		 397 printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n");
398 break;
399 }
7a8cf29d 400
1da177e4
LT		 401 /*
402 * If there are no more containers, then stop asking.
403 */
fe76df42 404 if (++index >= status)
1da177e4 405 break;
1da177e4 406 }
1da177e4
LT		 407 return status;
408}
409
1da177e4
LT		 410static void get_container_name_callback(void *context, struct fib * fibptr)
411{
412 struct aac_get_name_resp * get_name_reply;
413 struct scsi_cmnd * scsicmd;
414
415 scsicmd = (struct scsi_cmnd *) context;
416
03d44337
MH		 417 if (!aac_valid_context(scsicmd, fibptr))
418 return;
419
1da177e4 420 dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies));
125e1874 421 BUG_ON(fibptr == NULL);
1da177e4
LT		 422
423 get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr);
424 /* Failure is irrelevant, using default value instead */
425 if ((le32_to_cpu(get_name_reply->status) == CT_OK)
426 && (get_name_reply->data[0] != '\0')) {
3b2946cc 427 char *sp = get_name_reply->data;
1da177e4
LT		 428 sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0';
429 while (*sp == ' ')
430 ++sp;
3b2946cc 431 if (*sp) {
d4345028 432 struct inquiry_data inq;
3b2946cc
MH		 433 char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)];
434 int count = sizeof(d);
435 char *dp = d;
436 do {
437 *dp++ = (*sp) ? *sp++ : ' ';
438 } while (--count > 0);
d4345028
FT		 439
440 scsi_sg_copy_to_buffer(scsicmd, &inq, sizeof(inq));
441 memcpy(inq.inqd_pid, d, sizeof(d));
442 scsi_sg_copy_from_buffer(scsicmd, &inq, sizeof(inq));
3b2946cc 443 }
1da177e4 444 }
3b2946cc 445
1da177e4
LT		 446 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
447
bfb35aa8
MH		 448 aac_fib_complete(fibptr);
449 aac_fib_free(fibptr);
8e0c5ebd 450 scsicmd->scsi_done(scsicmd);
1da177e4
LT		 451}
452
453/**
454 * aac_get_container_name - get container name, none blocking.
455 */
9e7c349c 456static int aac_get_container_name(struct scsi_cmnd * scsicmd)
1da177e4
LT		 457{
458 int status;
459 struct aac_get_name *dinfo;
460 struct fib * cmd_fibcontext;
461 struct aac_dev * dev;
462
463 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
464
bfb35aa8 465 if (!(cmd_fibcontext = aac_fib_alloc(dev)))
1da177e4
LT		 466 return -ENOMEM;
467
bfb35aa8 468 aac_fib_init(cmd_fibcontext);
1da177e4
LT		 469 dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext);
470
471 dinfo->command = cpu_to_le32(VM_ContainerConfig);
472 dinfo->type = cpu_to_le32(CT_READ_NAME);
9e7c349c 473 dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
1da177e4
LT		 474 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
475
bfb35aa8 476 status = aac_fib_send(ContainerCommand,
8ce3eca4 477 cmd_fibcontext,
1da177e4 478 sizeof (struct aac_get_name),
8ce3eca4
SM		 479 FsaNormal,
480 0, 1,
481 (fib_callback)get_container_name_callback,
1da177e4 482 (void *) scsicmd);
8ce3eca4 483
1da177e4
LT		 484 /*
485 * Check that the command queued to the controller
486 */
77d644d4
MH		 487 if (status == -EINPROGRESS) {
488 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1da177e4 489 return 0;
77d644d4 490 }
8ce3eca4 491
bfb35aa8
MH		 492 printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status);
493 aac_fib_complete(cmd_fibcontext);
494 aac_fib_free(cmd_fibcontext);
1da177e4
LT		 495 return -1;
496}
497
fe76df42 498static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd)
1da177e4 499{
fe76df42 500 struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
1da177e4 501
1a655040 502 if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1))
fe76df42 503 return aac_scsi_cmd(scsicmd);
1da177e4 504
fe76df42
MH		 505 scsicmd->result = DID_NO_CONNECT << 16;
506 scsicmd->scsi_done(scsicmd);
507 return 0;
508}
509
1a655040 510static void _aac_probe_container2(void * context, struct fib * fibptr)
fe76df42 511{
03d44337 512 struct fsa_dev_info *fsa_dev_ptr;
fe76df42 513 int (*callback)(struct scsi_cmnd *);
03d44337
MH		 514 struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context;
515
03d44337 516
1a655040
SM		 517 if (!aac_valid_context(scsicmd, fibptr))
518 return;
fe76df42
MH		 519
520 scsicmd->SCp.Status = 0;
1a655040 521 fsa_dev_ptr = fibptr->dev->fsa_dev;
fe76df42
MH		 522 if (fsa_dev_ptr) {
523 struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr);
524 fsa_dev_ptr += scmd_id(scsicmd);
525
526 if ((le32_to_cpu(dresp->status) == ST_OK) &&
527 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
528 (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
529 fsa_dev_ptr->valid = 1;
655d722c
MS		 530 /* sense_key holds the current state of the spin-up */
531 if (dresp->mnt[0].state & cpu_to_le32(FSCS_NOT_READY))
532 fsa_dev_ptr->sense_data.sense_key = NOT_READY;
533 else if (fsa_dev_ptr->sense_data.sense_key == NOT_READY)
534 fsa_dev_ptr->sense_data.sense_key = NO_SENSE;
fe76df42
MH		 535 fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol);
536 fsa_dev_ptr->size
537 = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
538 (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
539 fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0);
540 }
541 if ((fsa_dev_ptr->valid & 1) == 0)
542 fsa_dev_ptr->valid = 0;
543 scsicmd->SCp.Status = le32_to_cpu(dresp->count);
544 }
545 aac_fib_complete(fibptr);
546 aac_fib_free(fibptr);
547 callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr);
548 scsicmd->SCp.ptr = NULL;
1a655040
SM		 549 (*callback)(scsicmd);
550 return;
fe76df42
MH		 551}
552
1a655040 553static void _aac_probe_container1(void * context, struct fib * fibptr)
fe76df42
MH		 554{
555 struct scsi_cmnd * scsicmd;
556 struct aac_mount * dresp;
557 struct aac_query_mount *dinfo;
558 int status;
559
560 dresp = (struct aac_mount *) fib_data(fibptr);
561 dresp->mnt[0].capacityhigh = 0;
562 if ((le32_to_cpu(dresp->status) != ST_OK) ||
1a655040
SM		 563 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) {
564 _aac_probe_container2(context, fibptr);
565 return;
566 }
fe76df42 567 scsicmd = (struct scsi_cmnd *) context;
1da177e4 568
03d44337 569 if (!aac_valid_context(scsicmd, fibptr))
1a655040 570 return;
03d44337 571
bfb35aa8 572 aac_fib_init(fibptr);
1da177e4
LT		 573
574 dinfo = (struct aac_query_mount *)fib_data(fibptr);
575
fe76df42
MH		 576 dinfo->command = cpu_to_le32(VM_NameServe64);
577 dinfo->count = cpu_to_le32(scmd_id(scsicmd));
1da177e4
LT		 578 dinfo->type = cpu_to_le32(FT_FILESYS);
579
bfb35aa8 580 status = aac_fib_send(ContainerCommand,
fe76df42
MH		 581 fibptr,
582 sizeof(struct aac_query_mount),
583 FsaNormal,
584 0, 1,
1a655040 585 _aac_probe_container2,
fe76df42
MH		 586 (void *) scsicmd);
587 /*
588 * Check that the command queued to the controller
589 */
1a655040 590 if (status == -EINPROGRESS)
fe76df42 591 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1a655040 592 else if (status < 0) {
fe76df42
MH		 593 /* Inherit results from VM_NameServe, if any */
594 dresp->status = cpu_to_le32(ST_OK);
1a655040 595 _aac_probe_container2(context, fibptr);
1da177e4 596 }
fe76df42 597}
1da177e4 598
fe76df42
MH		 599static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *))
600{
601 struct fib * fibptr;
602 int status = -ENOMEM;
603
604 if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) {
605 struct aac_query_mount *dinfo;
606
607 aac_fib_init(fibptr);
608
609 dinfo = (struct aac_query_mount *)fib_data(fibptr);
1da177e4 610
fe76df42
MH		 611 dinfo->command = cpu_to_le32(VM_NameServe);
612 dinfo->count = cpu_to_le32(scmd_id(scsicmd));
7a8cf29d 613 dinfo->type = cpu_to_le32(FT_FILESYS);
fe76df42 614 scsicmd->SCp.ptr = (char *)callback;
7a8cf29d 615
fe76df42
MH		 616 status = aac_fib_send(ContainerCommand,
617 fibptr,
618 sizeof(struct aac_query_mount),
619 FsaNormal,
620 0, 1,
1a655040 621 _aac_probe_container1,
fe76df42
MH		 622 (void *) scsicmd);
623 /*
624 * Check that the command queued to the controller
625 */
626 if (status == -EINPROGRESS) {
627 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
628 return 0;
629 }
630 if (status < 0) {
631 scsicmd->SCp.ptr = NULL;
632 aac_fib_complete(fibptr);
633 aac_fib_free(fibptr);
634 }
635 }
636 if (status < 0) {
637 struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
638 if (fsa_dev_ptr) {
639 fsa_dev_ptr += scmd_id(scsicmd);
640 if ((fsa_dev_ptr->valid & 1) == 0) {
641 fsa_dev_ptr->valid = 0;
642 return (*callback)(scsicmd);
643 }
644 }
1da177e4 645 }
fe76df42
MH		 646 return status;
647}
1da177e4 648
fe76df42
MH		 649/**
650 * aac_probe_container - query a logical volume
651 * @dev: device to query
652 * @cid: container identifier
653 *
654 * Queries the controller about the given volume. The volume information
655 * is updated in the struct fsa_dev_info structure rather than returned.
656 */
657static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd)
658{
659 scsicmd->device = NULL;
660 return 0;
661}
1da177e4 662
fe76df42
MH		 663int aac_probe_container(struct aac_dev *dev, int cid)
664{
665 struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL);
666 struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL);
667 int status;
668
669 if (!scsicmd || !scsidev) {
670 kfree(scsicmd);
671 kfree(scsidev);
672 return -ENOMEM;
673 }
674 scsicmd->list.next = NULL;
1a655040 675 scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1;
fe76df42
MH		 676
677 scsicmd->device = scsidev;
678 scsidev->sdev_state = 0;
679 scsidev->id = cid;
680 scsidev->host = dev->scsi_host_ptr;
681
682 if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0)
683 while (scsicmd->device == scsidev)
684 schedule();
802ae2f0 685 kfree(scsidev);
fe76df42
MH		 686 status = scsicmd->SCp.Status;
687 kfree(scsicmd);
1da177e4
LT		 688 return status;
689}
690
691/* Local Structure to set SCSI inquiry data strings */
692struct scsi_inq {
693 char vid[8]; /* Vendor ID */
694 char pid[16]; /* Product ID */
695 char prl[4]; /* Product Revision Level */
696};
697
698/**
699 * InqStrCopy - string merge
700 * @a: string to copy from
701 * @b: string to copy to
702 *
8ce3eca4 703 * Copy a String from one location to another
1da177e4
LT		 704 * without copying \0
705 */
706
707static void inqstrcpy(char *a, char *b)
708{
709
8ce3eca4 710 while (*a != (char)0)
1da177e4
LT		 711 *b++ = *a++;
712}
713
714static char *container_types[] = {
8ce3eca4
SM		 715 "None",
716 "Volume",
717 "Mirror",
718 "Stripe",
719 "RAID5",
720 "SSRW",
721 "SSRO",
722 "Morph",
723 "Legacy",
724 "RAID4",
725 "RAID10",
726 "RAID00",
727 "V-MIRRORS",
728 "PSEUDO R4",
1da177e4 729 "RAID50",
84971738
MH		 730 "RAID5D",
731 "RAID5D0",
732 "RAID1E",
733 "RAID6",
734 "RAID60",
8ce3eca4 735 "Unknown"
1da177e4
LT		 736};
737
17eaacee
SM		 738char * get_container_type(unsigned tindex)
739{
740 if (tindex >= ARRAY_SIZE(container_types))
741 tindex = ARRAY_SIZE(container_types) - 1;
742 return container_types[tindex];
743}
1da177e4
LT		 744
745/* Function: setinqstr
746 *
747 * Arguments: [1] pointer to void [1] int
748 *
749 * Purpose: Sets SCSI inquiry data strings for vendor, product
25985edc
LDM		 750 * and revision level. Allows strings to be set in platform dependent
751 * files instead of in OS dependent driver source.
1da177e4
LT		 752 */
753
794d0601 754static void setinqstr(struct aac_dev *dev, void *data, int tindex)
1da177e4
LT		 755{
756 struct scsi_inq *str;
1da177e4 757
1da177e4 758 str = (struct scsi_inq *)(data); /* cast data to scsi inq block */
794d0601
MH		 759 memset(str, ' ', sizeof(*str));
760
761 if (dev->supplement_adapter_info.AdapterTypeText[0]) {
762 char * cp = dev->supplement_adapter_info.AdapterTypeText;
3bc8070f
SM		 763 int c;
764 if ((cp[0] == 'A') && (cp[1] == 'O') && (cp[2] == 'C'))
765 inqstrcpy("SMC", str->vid);
766 else {
767 c = sizeof(str->vid);
768 while (*cp && *cp != ' ' && --c)
769 ++cp;
770 c = *cp;
771 *cp = '\0';
772 inqstrcpy (dev->supplement_adapter_info.AdapterTypeText,
773 str->vid);
774 *cp = c;
775 while (*cp && *cp != ' ')
776 ++cp;
777 }
794d0601
MH		 778 while (*cp == ' ')
779 ++cp;
780 /* last six chars reserved for vol type */
781 c = 0;
782 if (strlen(cp) > sizeof(str->pid)) {
783 c = cp[sizeof(str->pid)];
784 cp[sizeof(str->pid)] = '\0';
785 }
786 inqstrcpy (cp, str->pid);
787 if (c)
788 cp[sizeof(str->pid)] = c;
789 } else {
790 struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype);
6391a113
TK		 791
792 inqstrcpy (mp->vname, str->vid);
794d0601
MH		 793 /* last six chars reserved for vol type */
794 inqstrcpy (mp->model, str->pid);
795 }
1da177e4 796
6391a113 797 if (tindex < ARRAY_SIZE(container_types)){
1da177e4
LT		 798 char *findit = str->pid;
799
800 for ( ; *findit != ' '; findit++); /* walk till we find a space */
801 /* RAID is superfluous in the context of a RAID device */
802 if (memcmp(findit-4, "RAID", 4) == 0)
803 *(findit -= 4) = ' ';
794d0601
MH		 804 if (((findit - str->pid) + strlen(container_types[tindex]))
805 < (sizeof(str->pid) + sizeof(str->prl)))
806 inqstrcpy (container_types[tindex], findit + 1);
1da177e4
LT		 807 }
808 inqstrcpy ("V1.0", str->prl);
809}
810
88e2f98e
SM		 811static void get_container_serial_callback(void *context, struct fib * fibptr)
812{
813 struct aac_get_serial_resp * get_serial_reply;
814 struct scsi_cmnd * scsicmd;
815
816 BUG_ON(fibptr == NULL);
817
818 scsicmd = (struct scsi_cmnd *) context;
819 if (!aac_valid_context(scsicmd, fibptr))
820 return;
821
822 get_serial_reply = (struct aac_get_serial_resp *) fib_data(fibptr);
823 /* Failure is irrelevant, using default value instead */
824 if (le32_to_cpu(get_serial_reply->status) == CT_OK) {
825 char sp[13];
826 /* EVPD bit set */
827 sp[0] = INQD_PDT_DA;
828 sp[1] = scsicmd->cmnd[2];
829 sp[2] = 0;
830 sp[3] = snprintf(sp+4, sizeof(sp)-4, "%08X",
831 le32_to_cpu(get_serial_reply->uid));
d4345028 832 scsi_sg_copy_from_buffer(scsicmd, sp, sizeof(sp));
88e2f98e
SM		 833 }
834
835 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
836
837 aac_fib_complete(fibptr);
838 aac_fib_free(fibptr);
839 scsicmd->scsi_done(scsicmd);
840}
841
842/**
843 * aac_get_container_serial - get container serial, none blocking.
844 */
845static int aac_get_container_serial(struct scsi_cmnd * scsicmd)
846{
847 int status;
848 struct aac_get_serial *dinfo;
849 struct fib * cmd_fibcontext;
850 struct aac_dev * dev;
851
852 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
853
854 if (!(cmd_fibcontext = aac_fib_alloc(dev)))
855 return -ENOMEM;
856
857 aac_fib_init(cmd_fibcontext);
858 dinfo = (struct aac_get_serial *) fib_data(cmd_fibcontext);
859
860 dinfo->command = cpu_to_le32(VM_ContainerConfig);
861 dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID);
862 dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
863
864 status = aac_fib_send(ContainerCommand,
865 cmd_fibcontext,
866 sizeof (struct aac_get_serial),
867 FsaNormal,
868 0, 1,
869 (fib_callback) get_container_serial_callback,
870 (void *) scsicmd);
871
872 /*
873 * Check that the command queued to the controller
874 */
875 if (status == -EINPROGRESS) {
876 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
877 return 0;
878 }
879
880 printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status);
881 aac_fib_complete(cmd_fibcontext);
882 aac_fib_free(cmd_fibcontext);
883 return -1;
884}
885
886/* Function: setinqserial
887 *
888 * Arguments: [1] pointer to void [1] int
889 *
890 * Purpose: Sets SCSI Unit Serial number.
891 * This is a fake. We should read a proper
892 * serial number from the container. <SuSE>But
893 * without docs it's quite hard to do it :-)
894 * So this will have to do in the meantime.</SuSE>
895 */
896
897static int setinqserial(struct aac_dev *dev, void *data, int cid)
898{
899 /*
900 * This breaks array migration.
901 */
902 return snprintf((char *)(data), sizeof(struct scsi_inq) - 4, "%08X%02X",
903 le32_to_cpu(dev->adapter_info.serial[0]), cid);
904}
905
8e31e607
SM		 906static inline void set_sense(struct sense_data *sense_data, u8 sense_key,
907 u8 sense_code, u8 a_sense_code, u8 bit_pointer, u16 field_pointer)
1da177e4 908{
8e31e607
SM		 909 u8 *sense_buf = (u8 *)sense_data;
910 /* Sense data valid, err code 70h */
911 sense_buf[0] = 0x70; /* No info field */
1da177e4
LT		 912 sense_buf[1] = 0; /* Segment number, always zero */
913
8e31e607 914 sense_buf[2] = sense_key; /* Sense key */
1da177e4
LT		 915
916 sense_buf[12] = sense_code; /* Additional sense code */
917 sense_buf[13] = a_sense_code; /* Additional sense code qualifier */
8e31e607 918
1da177e4 919 if (sense_key == ILLEGAL_REQUEST) {
8e31e607 920 sense_buf[7] = 10; /* Additional sense length */
1da177e4 921
8e31e607 922 sense_buf[15] = bit_pointer;
1da177e4 923 /* Illegal parameter is in the parameter block */
1da177e4 924 if (sense_code == SENCODE_INVALID_CDB_FIELD)
8e31e607 925 sense_buf[15] |= 0xc0;/* Std sense key specific field */
1da177e4 926 /* Illegal parameter is in the CDB block */
1da177e4
LT		 927 sense_buf[16] = field_pointer >> 8; /* MSB */
928 sense_buf[17] = field_pointer; /* LSB */
8e31e607
SM		 929 } else
930 sense_buf[7] = 6; /* Additional sense length */
1da177e4
LT		 931}
932
e8f32de5
MH		 933static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba)
934{
935 if (lba & 0xffffffff00000000LL) {
936 int cid = scmd_id(cmd);
937 dprintk((KERN_DEBUG "aacraid: Illegal lba\n"));
938 cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
939 SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 940 set_sense(&dev->fsa_dev[cid].sense_data,
941 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
942 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
e8f32de5 943 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
3ace426f
SM		 944 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
945 SCSI_SENSE_BUFFERSIZE));
e8f32de5
MH		 946 cmd->scsi_done(cmd);
947 return 1;
948 }
949 return 0;
950}
951
952static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba)
953{
954 return 0;
955}
956
957static void io_callback(void *context, struct fib * fibptr);
958
959static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count)
960{
961 u16 fibsize;
962 struct aac_raw_io *readcmd;
963 aac_fib_init(fib);
964 readcmd = (struct aac_raw_io *) fib_data(fib);
965 readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff));
966 readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32));
967 readcmd->count = cpu_to_le32(count<<9);
968 readcmd->cid = cpu_to_le16(scmd_id(cmd));
9d399cc7 969 readcmd->flags = cpu_to_le16(IO_TYPE_READ);
e8f32de5
MH		 970 readcmd->bpTotal = 0;
971 readcmd->bpComplete = 0;
972
973 aac_build_sgraw(cmd, &readcmd->sg);
974 fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw));
975 BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr)));
976 /*
977 * Now send the Fib to the adapter
978 */
979 return aac_fib_send(ContainerRawIo,
980 fib,
981 fibsize,
982 FsaNormal,
983 0, 1,
984 (fib_callback) io_callback,
985 (void *) cmd);
986}
987
988static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count)
989{
990 u16 fibsize;
991 struct aac_read64 *readcmd;
992 aac_fib_init(fib);
993 readcmd = (struct aac_read64 *) fib_data(fib);
994 readcmd->command = cpu_to_le32(VM_CtHostRead64);
995 readcmd->cid = cpu_to_le16(scmd_id(cmd));
996 readcmd->sector_count = cpu_to_le16(count);
997 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff));
998 readcmd->pad = 0;
999 readcmd->flags = 0;
1000
1001 aac_build_sg64(cmd, &readcmd->sg);
1002 fibsize = sizeof(struct aac_read64) +
1003 ((le32_to_cpu(readcmd->sg.count) - 1) *
1004 sizeof (struct sgentry64));
1005 BUG_ON (fibsize > (fib->dev->max_fib_size -
1006 sizeof(struct aac_fibhdr)));
1007 /*
1008 * Now send the Fib to the adapter
1009 */
1010 return aac_fib_send(ContainerCommand64,
1011 fib,
1012 fibsize,
1013 FsaNormal,
1014 0, 1,
1015 (fib_callback) io_callback,
1016 (void *) cmd);
1017}
1018
1019static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count)
1020{
1021 u16 fibsize;
1022 struct aac_read *readcmd;
1023 aac_fib_init(fib);
1024 readcmd = (struct aac_read *) fib_data(fib);
1025 readcmd->command = cpu_to_le32(VM_CtBlockRead);
f3307f72 1026 readcmd->cid = cpu_to_le32(scmd_id(cmd));
e8f32de5
MH		 1027 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff));
1028 readcmd->count = cpu_to_le32(count * 512);
1029
1030 aac_build_sg(cmd, &readcmd->sg);
1031 fibsize = sizeof(struct aac_read) +
1032 ((le32_to_cpu(readcmd->sg.count) - 1) *
1033 sizeof (struct sgentry));
1034 BUG_ON (fibsize > (fib->dev->max_fib_size -
1035 sizeof(struct aac_fibhdr)));
1036 /*
1037 * Now send the Fib to the adapter
1038 */
1039 return aac_fib_send(ContainerCommand,
1040 fib,
1041 fibsize,
1042 FsaNormal,
1043 0, 1,
1044 (fib_callback) io_callback,
1045 (void *) cmd);
1046}
1047
9d399cc7 1048static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
e8f32de5
MH		 1049{
1050 u16 fibsize;
1051 struct aac_raw_io *writecmd;
1052 aac_fib_init(fib);
1053 writecmd = (struct aac_raw_io *) fib_data(fib);
1054 writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff));
1055 writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32));
1056 writecmd->count = cpu_to_le32(count<<9);
1057 writecmd->cid = cpu_to_le16(scmd_id(cmd));
95e852e1
SM		 1058 writecmd->flags = (fua && ((aac_cache & 5) != 1) &&
1059 (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ?
9d399cc7
SM		 1060 cpu_to_le16(IO_TYPE_WRITE|IO_SUREWRITE) :
1061 cpu_to_le16(IO_TYPE_WRITE);
e8f32de5
MH		 1062 writecmd->bpTotal = 0;
1063 writecmd->bpComplete = 0;
1064
1065 aac_build_sgraw(cmd, &writecmd->sg);
1066 fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw));
1067 BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr)));
1068 /*
1069 * Now send the Fib to the adapter
1070 */
1071 return aac_fib_send(ContainerRawIo,
1072 fib,
1073 fibsize,
1074 FsaNormal,
1075 0, 1,
1076 (fib_callback) io_callback,
1077 (void *) cmd);
1078}
1079
9d399cc7 1080static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
e8f32de5
MH		 1081{
1082 u16 fibsize;
1083 struct aac_write64 *writecmd;
1084 aac_fib_init(fib);
1085 writecmd = (struct aac_write64 *) fib_data(fib);
1086 writecmd->command = cpu_to_le32(VM_CtHostWrite64);
1087 writecmd->cid = cpu_to_le16(scmd_id(cmd));
1088 writecmd->sector_count = cpu_to_le16(count);
1089 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff));
1090 writecmd->pad = 0;
1091 writecmd->flags = 0;
1092
1093 aac_build_sg64(cmd, &writecmd->sg);
1094 fibsize = sizeof(struct aac_write64) +
1095 ((le32_to_cpu(writecmd->sg.count) - 1) *
1096 sizeof (struct sgentry64));
1097 BUG_ON (fibsize > (fib->dev->max_fib_size -
1098 sizeof(struct aac_fibhdr)));
1099 /*
1100 * Now send the Fib to the adapter
1101 */
1102 return aac_fib_send(ContainerCommand64,
1103 fib,
1104 fibsize,
1105 FsaNormal,
1106 0, 1,
1107 (fib_callback) io_callback,
1108 (void *) cmd);
1109}
1110
9d399cc7 1111static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
e8f32de5
MH		 1112{
1113 u16 fibsize;
1114 struct aac_write *writecmd;
1115 aac_fib_init(fib);
1116 writecmd = (struct aac_write *) fib_data(fib);
1117 writecmd->command = cpu_to_le32(VM_CtBlockWrite);
f3307f72 1118 writecmd->cid = cpu_to_le32(scmd_id(cmd));
e8f32de5
MH		 1119 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff));
1120 writecmd->count = cpu_to_le32(count * 512);
1121 writecmd->sg.count = cpu_to_le32(1);
1122 /* ->stable is not used - it did mean which type of write */
1123
1124 aac_build_sg(cmd, &writecmd->sg);
1125 fibsize = sizeof(struct aac_write) +
1126 ((le32_to_cpu(writecmd->sg.count) - 1) *
1127 sizeof (struct sgentry));
1128 BUG_ON (fibsize > (fib->dev->max_fib_size -
1129 sizeof(struct aac_fibhdr)));
1130 /*
1131 * Now send the Fib to the adapter
1132 */
1133 return aac_fib_send(ContainerCommand,
1134 fib,
1135 fibsize,
1136 FsaNormal,
1137 0, 1,
1138 (fib_callback) io_callback,
1139 (void *) cmd);
1140}
1141
1142static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd)
1143{
1144 struct aac_srb * srbcmd;
1145 u32 flag;
1146 u32 timeout;
1147
1148 aac_fib_init(fib);
1149 switch(cmd->sc_data_direction){
1150 case DMA_TO_DEVICE:
1151 flag = SRB_DataOut;
1152 break;
1153 case DMA_BIDIRECTIONAL:
1154 flag = SRB_DataIn | SRB_DataOut;
1155 break;
1156 case DMA_FROM_DEVICE:
1157 flag = SRB_DataIn;
1158 break;
1159 case DMA_NONE:
1160 default: /* shuts up some versions of gcc */
1161 flag = SRB_NoDataXfer;
1162 break;
1163 }
1164
1165 srbcmd = (struct aac_srb*) fib_data(fib);
1166 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi);
1167 srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd)));
1168 srbcmd->id = cpu_to_le32(scmd_id(cmd));
1169 srbcmd->lun = cpu_to_le32(cmd->device->lun);
1170 srbcmd->flags = cpu_to_le32(flag);
242f9dcb 1171 timeout = cmd->request->timeout/HZ;
e8f32de5
MH		 1172 if (timeout == 0)
1173 timeout = 1;
1174 srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds
1175 srbcmd->retry_limit = 0; /* Obsolete parameter */
1176 srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len);
1177 return srbcmd;
1178}
1179
1180static void aac_srb_callback(void *context, struct fib * fibptr);
1181
1182static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd)
1183{
1184 u16 fibsize;
1185 struct aac_srb * srbcmd = aac_scsi_common(fib, cmd);
1186
1187 aac_build_sg64(cmd, (struct sgmap64*) &srbcmd->sg);
727eead6 1188 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd));
e8f32de5
MH		 1189
1190 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb));
1191 memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len);
1192 /*
1193 * Build Scatter/Gather list
1194 */
1195 fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) +
1196 ((le32_to_cpu(srbcmd->sg.count) & 0xff) *
1197 sizeof (struct sgentry64));
1198 BUG_ON (fibsize > (fib->dev->max_fib_size -
1199 sizeof(struct aac_fibhdr)));
1200
1201 /*
1202 * Now send the Fib to the adapter
1203 */
1204 return aac_fib_send(ScsiPortCommand64, fib,
1205 fibsize, FsaNormal, 0, 1,
1206 (fib_callback) aac_srb_callback,
1207 (void *) cmd);
1208}
1209
1210static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd)
1211{
1212 u16 fibsize;
1213 struct aac_srb * srbcmd = aac_scsi_common(fib, cmd);
1214
1215 aac_build_sg(cmd, (struct sgmap*)&srbcmd->sg);
727eead6 1216 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd));
e8f32de5
MH		 1217
1218 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb));
1219 memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len);
1220 /*
1221 * Build Scatter/Gather list
1222 */
1223 fibsize = sizeof (struct aac_srb) +
1224 (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) *
1225 sizeof (struct sgentry));
1226 BUG_ON (fibsize > (fib->dev->max_fib_size -
1227 sizeof(struct aac_fibhdr)));
1228
1229 /*
1230 * Now send the Fib to the adapter
1231 */
1232 return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1,
1233 (fib_callback) aac_srb_callback, (void *) cmd);
1234}
1235
94cf6ba1
SM		 1236static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd)
1237{
d8e96507
LA		 1238 if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac &&
1239 (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64))
94cf6ba1
SM		 1240 return FAILED;
1241 return aac_scsi_32(fib, cmd);
1242}
1243
1da177e4
LT		 1244int aac_get_adapter_info(struct aac_dev* dev)
1245{
1246 struct fib* fibptr;
1da177e4
LT		 1247 int rcode;
1248 u32 tmp;
84971738
MH		 1249 struct aac_adapter_info *info;
1250 struct aac_bus_info *command;
1251 struct aac_bus_info_response *bus_info;
7c00ffa3 1252
bfb35aa8 1253 if (!(fibptr = aac_fib_alloc(dev)))
1da177e4
LT		 1254 return -ENOMEM;
1255
bfb35aa8 1256 aac_fib_init(fibptr);
7c00ffa3
MH		 1257 info = (struct aac_adapter_info *) fib_data(fibptr);
1258 memset(info,0,sizeof(*info));
1da177e4 1259
bfb35aa8 1260 rcode = aac_fib_send(RequestAdapterInfo,
8ce3eca4 1261 fibptr,
7c00ffa3 1262 sizeof(*info),
8ce3eca4 1263 FsaNormal,
9203344c 1264 -1, 1, /* First `interrupt' command uses special wait */
8ce3eca4 1265 NULL,
7c00ffa3
MH		 1266 NULL);
1267
1268 if (rcode < 0) {
cacb6dc3
PNRCEH		 1269 /* FIB should be freed only after
1270 * getting the response from the F/W */
1271 if (rcode != -ERESTARTSYS) {
1272 aac_fib_complete(fibptr);
1273 aac_fib_free(fibptr);
1274 }
7c00ffa3
MH		 1275 return rcode;
1276 }
1277 memcpy(&dev->adapter_info, info, sizeof(*info));
1da177e4 1278
7c00ffa3 1279 if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) {
06a43d17 1280 struct aac_supplement_adapter_info * sinfo;
7c00ffa3 1281
bfb35aa8 1282 aac_fib_init(fibptr);
7c00ffa3 1283
06a43d17 1284 sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr);
7c00ffa3 1285
06a43d17 1286 memset(sinfo,0,sizeof(*sinfo));
7c00ffa3 1287
bfb35aa8 1288 rcode = aac_fib_send(RequestSupplementAdapterInfo,
7c00ffa3 1289 fibptr,
06a43d17 1290 sizeof(*sinfo),
7c00ffa3
MH		 1291 FsaNormal,
1292 1, 1,
1293 NULL,
1294 NULL);
1295
1296 if (rcode >= 0)
06a43d17 1297 memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
cacb6dc3
PNRCEH		 1298 if (rcode == -ERESTARTSYS) {
1299 fibptr = aac_fib_alloc(dev);
1300 if (!fibptr)
1301 return -ENOMEM;
1302 }
1303
7c00ffa3 1304 }
1da177e4 1305
84971738 1306
8ce3eca4
SM		 1307 /*
1308 * GetBusInfo
84971738
MH		 1309 */
1310
bfb35aa8 1311 aac_fib_init(fibptr);
84971738
MH		 1312
1313 bus_info = (struct aac_bus_info_response *) fib_data(fibptr);
1314
1315 memset(bus_info, 0, sizeof(*bus_info));
1316
1317 command = (struct aac_bus_info *)bus_info;
1318
1319 command->Command = cpu_to_le32(VM_Ioctl);
1320 command->ObjType = cpu_to_le32(FT_DRIVE);
1321 command->MethodId = cpu_to_le32(1);
1322 command->CtlCmd = cpu_to_le32(GetBusInfo);
1323
bfb35aa8 1324 rcode = aac_fib_send(ContainerCommand,
84971738
MH		 1325 fibptr,
1326 sizeof (*bus_info),
1327 FsaNormal,
1328 1, 1,
1329 NULL, NULL);
1330
94cf6ba1
SM		 1331 /* reasoned default */
1332 dev->maximum_num_physicals = 16;
84971738
MH		 1333 if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) {
1334 dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus);
1335 dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount);
1336 }
1337
8c867b25 1338 if (!dev->in_reset) {
24f02e1d 1339 char buffer[16];
8c867b25
MH		 1340 tmp = le32_to_cpu(dev->adapter_info.kernelrev);
1341 printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n",
8ce3eca4 1342 dev->name,
1da177e4
LT		 1343 dev->id,
1344 tmp>>24,
1345 (tmp>>16)&0xff,
1346 tmp&0xff,
7c00ffa3
MH		 1347 le32_to_cpu(dev->adapter_info.kernelbuild),
1348 (int)sizeof(dev->supplement_adapter_info.BuildDate),
1349 dev->supplement_adapter_info.BuildDate);
8c867b25
MH		 1350 tmp = le32_to_cpu(dev->adapter_info.monitorrev);
1351 printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n",
1da177e4
LT		 1352 dev->name, dev->id,
1353 tmp>>24,(tmp>>16)&0xff,tmp&0xff,
1354 le32_to_cpu(dev->adapter_info.monitorbuild));
8c867b25
MH		 1355 tmp = le32_to_cpu(dev->adapter_info.biosrev);
1356 printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n",
1da177e4
LT		 1357 dev->name, dev->id,
1358 tmp>>24,(tmp>>16)&0xff,tmp&0xff,
1359 le32_to_cpu(dev->adapter_info.biosbuild));
24f02e1d 1360 buffer[0] = '\0';
ee959b00 1361 if (aac_get_serial_number(
24f02e1d
SM		 1362 shost_to_class(dev->scsi_host_ptr), buffer))
1363 printk(KERN_INFO "%s%d: serial %s",
1364 dev->name, dev->id, buffer);
a45c863f
SM		 1365 if (dev->supplement_adapter_info.VpdInfo.Tsid[0]) {
1366 printk(KERN_INFO "%s%d: TSID %.*s\n",
1367 dev->name, dev->id,
1368 (int)sizeof(dev->supplement_adapter_info.VpdInfo.Tsid),
1369 dev->supplement_adapter_info.VpdInfo.Tsid);
1370 }
2f7ecc55 1371 if (!aac_check_reset || ((aac_check_reset == 1) &&
a3940da5
SM		 1372 (dev->supplement_adapter_info.SupportedOptions2 &
1373 AAC_OPTION_IGNORE_RESET))) {
29c97684
SM		 1374 printk(KERN_INFO "%s%d: Reset Adapter Ignored\n",
1375 dev->name, dev->id);
1376 }
8c867b25 1377 }
1da177e4 1378
95e852e1 1379 dev->cache_protected = 0;
cb1042f2
SM		 1380 dev->jbod = ((dev->supplement_adapter_info.FeatureBits &
1381 AAC_FEATURE_JBOD) != 0);
1da177e4
LT		 1382 dev->nondasd_support = 0;
1383 dev->raid_scsi_mode = 0;
95e852e1 1384 if(dev->adapter_info.options & AAC_OPT_NONDASD)
1da177e4 1385 dev->nondasd_support = 1;
1da177e4
LT		 1386
1387 /*
1388 * If the firmware supports ROMB RAID/SCSI mode and we are currently
1389 * in RAID/SCSI mode, set the flag. For now if in this mode we will
1390 * force nondasd support on. If we decide to allow the non-dasd flag
1391 * additional changes changes will have to be made to support
1392 * RAID/SCSI. the function aac_scsi_cmd in this module will have to be
1393 * changed to support the new dev->raid_scsi_mode flag instead of
1394 * leaching off of the dev->nondasd_support flag. Also in linit.c the
1395 * function aac_detect will have to be modified where it sets up the
1396 * max number of channels based on the aac->nondasd_support flag only.
1397 */
1398 if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) &&
1399 (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) {
1400 dev->nondasd_support = 1;
1401 dev->raid_scsi_mode = 1;
1402 }
1403 if (dev->raid_scsi_mode != 0)
1404 printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n",
1405 dev->name, dev->id);
8ce3eca4 1406
95e852e1 1407 if (nondasd != -1)
1da177e4 1408 dev->nondasd_support = (nondasd!=0);
2f7ecc55 1409 if (dev->nondasd_support && !dev->in_reset)
1da177e4 1410 printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id);
1da177e4 1411
e930438c 1412 if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32))
d8e96507 1413 dev->needs_dac = 1;
1da177e4 1414 dev->dac_support = 0;
d8e96507
LA		 1415 if ((sizeof(dma_addr_t) > 4) && dev->needs_dac &&
1416 (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) {
2f7ecc55
SM		 1417 if (!dev->in_reset)
1418 printk(KERN_INFO "%s%d: 64bit support enabled.\n",
1419 dev->name, dev->id);
1da177e4
LT		 1420 dev->dac_support = 1;
1421 }
1422
1423 if(dacmode != -1) {
1424 dev->dac_support = (dacmode!=0);
1425 }
d8e96507
LA		 1426
1427 /* avoid problems with AAC_QUIRK_SCSI_32 controllers */
1428 if (dev->dac_support && (aac_get_driver_ident(dev->cardtype)->quirks
1429 & AAC_QUIRK_SCSI_32)) {
1430 dev->nondasd_support = 0;
1431 dev->jbod = 0;
1432 expose_physicals = 0;
1433 }
1434
1da177e4 1435 if(dev->dac_support != 0) {
6a35528a
YH		 1436 if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) &&
1437 !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) {
2f7ecc55
SM		 1438 if (!dev->in_reset)
1439 printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n",
1440 dev->name, dev->id);
284901a9
YH		 1441 } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) &&
1442 !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) {
1da177e4
LT		 1443 printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n",
1444 dev->name, dev->id);
1445 dev->dac_support = 0;
1446 } else {
1447 printk(KERN_WARNING"%s%d: No suitable DMA available.\n",
1448 dev->name, dev->id);
1449 rcode = -ENOMEM;
1450 }
1451 }
8ce3eca4 1452 /*
e8f32de5
MH		 1453 * Deal with configuring for the individualized limits of each packet
1454 * interface.
7c00ffa3 1455 */
e8f32de5 1456 dev->a_ops.adapter_scsi = (dev->dac_support)
94cf6ba1
SM		 1457 ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32)
1458 ? aac_scsi_32_64
1459 : aac_scsi_64)
e8f32de5
MH		 1460 : aac_scsi_32;
1461 if (dev->raw_io_interface) {
1462 dev->a_ops.adapter_bounds = (dev->raw_io_64)
1463 ? aac_bounds_64
1464 : aac_bounds_32;
1465 dev->a_ops.adapter_read = aac_read_raw_io;
1466 dev->a_ops.adapter_write = aac_write_raw_io;
1467 } else {
1468 dev->a_ops.adapter_bounds = aac_bounds_32;
0e68c003 1469 dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size -
7c00ffa3 1470 sizeof(struct aac_fibhdr) -
63a70eea
MH		 1471 sizeof(struct aac_write) + sizeof(struct sgentry)) /
1472 sizeof(struct sgentry);
0e68c003 1473 if (dev->dac_support) {
e8f32de5
MH		 1474 dev->a_ops.adapter_read = aac_read_block64;
1475 dev->a_ops.adapter_write = aac_write_block64;
8ce3eca4
SM		 1476 /*
1477 * 38 scatter gather elements
0e68c003
MH		 1478 */
1479 dev->scsi_host_ptr->sg_tablesize =
1480 (dev->max_fib_size -
1481 sizeof(struct aac_fibhdr) -
1482 sizeof(struct aac_write64) +
63a70eea
MH		 1483 sizeof(struct sgentry64)) /
1484 sizeof(struct sgentry64);
e8f32de5
MH		 1485 } else {
1486 dev->a_ops.adapter_read = aac_read_block;
1487 dev->a_ops.adapter_write = aac_write_block;
0e68c003
MH		 1488 }
1489 dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT;
e8b12f0f
MR		 1490 if (dev->adapter_info.options & AAC_OPT_NEW_COMM_TYPE1)
1491 dev->adapter_info.options |= AAC_OPT_NEW_COMM;
1492 if (!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) {
0e68c003
MH		 1493 /*
1494 * Worst case size that could cause sg overflow when
1495 * we break up SG elements that are larger than 64KB.
1496 * Would be nice if we could tell the SCSI layer what
1497 * the maximum SG element size can be. Worst case is
1498 * (sg_tablesize-1) 4KB elements with one 64KB
1499 * element.
1500 * 32bit -> 468 or 238KB 64bit -> 424 or 212KB
1501 */
1502 dev->scsi_host_ptr->max_sectors =
1503 (dev->scsi_host_ptr->sg_tablesize * 8) + 112;
1504 }
7c00ffa3 1505 }
cacb6dc3
PNRCEH		 1506 /* FIB should be freed only after getting the response from the F/W */
1507 if (rcode != -ERESTARTSYS) {
1508 aac_fib_complete(fibptr);
1509 aac_fib_free(fibptr);
1510 }
1da177e4
LT		 1511
1512 return rcode;
1513}
1514
1515
e53cb35a 1516static void io_callback(void *context, struct fib * fibptr)
1da177e4
LT		 1517{
1518 struct aac_dev *dev;
1519 struct aac_read_reply *readreply;
1520 struct scsi_cmnd *scsicmd;
1da177e4
LT		 1521 u32 cid;
1522
1523 scsicmd = (struct scsi_cmnd *) context;
1524
03d44337
MH		 1525 if (!aac_valid_context(scsicmd, fibptr))
1526 return;
1527
1a655040 1528 dev = fibptr->dev;
e5718774 1529 cid = scmd_id(scsicmd);
1da177e4 1530
7a8cf29d
MH		 1531 if (nblank(dprintk(x))) {
1532 u64 lba;
1533 switch (scsicmd->cmnd[0]) {
1534 case WRITE_6:
1535 case READ_6:
1536 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) |
1537 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
1538 break;
1539 case WRITE_16:
1540 case READ_16:
1541 lba = ((u64)scsicmd->cmnd[2] << 56) |
1542 ((u64)scsicmd->cmnd[3] << 48) |
1543 ((u64)scsicmd->cmnd[4] << 40) |
1544 ((u64)scsicmd->cmnd[5] << 32) |
1545 ((u64)scsicmd->cmnd[6] << 24) |
1546 (scsicmd->cmnd[7] << 16) |
1547 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
1548 break;
1549 case WRITE_12:
1550 case READ_12:
1551 lba = ((u64)scsicmd->cmnd[2] << 24) |
1552 (scsicmd->cmnd[3] << 16) |
1553 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1554 break;
1555 default:
1556 lba = ((u64)scsicmd->cmnd[2] << 24) |
1557 (scsicmd->cmnd[3] << 16) |
1558 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1559 break;
1560 }
1561 printk(KERN_DEBUG
1562 "io_callback[cpu %d]: lba = %llu, t = %ld.\n",
1563 smp_processor_id(), (unsigned long long)lba, jiffies);
1564 }
1da177e4 1565
125e1874 1566 BUG_ON(fibptr == NULL);
727eead6
FT		 1567
1568 scsi_dma_unmap(scsicmd);
1569
1da177e4 1570 readreply = (struct aac_read_reply *)fib_data(fibptr);
655d722c
MS		 1571 switch (le32_to_cpu(readreply->status)) {
1572 case ST_OK:
1573 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1574 SAM_STAT_GOOD;
1575 dev->fsa_dev[cid].sense_data.sense_key = NO_SENSE;
1576 break;
1577 case ST_NOT_READY:
1578 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1579 SAM_STAT_CHECK_CONDITION;
1580 set_sense(&dev->fsa_dev[cid].sense_data, NOT_READY,
1581 SENCODE_BECOMING_READY, ASENCODE_BECOMING_READY, 0, 0);
1582 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
1583 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1584 SCSI_SENSE_BUFFERSIZE));
1585 break;
1586 default:
7c00ffa3 1587#ifdef AAC_DETAILED_STATUS_INFO
e53cb35a 1588 printk(KERN_WARNING "io_callback: io failed, status = %d\n",
7c00ffa3
MH		 1589 le32_to_cpu(readreply->status));
1590#endif
655d722c
MS		 1591 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1592 SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 1593 set_sense(&dev->fsa_dev[cid].sense_data,
1594 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1595 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1da177e4 1596 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
3ace426f
SM		 1597 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1598 SCSI_SENSE_BUFFERSIZE));
655d722c 1599 break;
1da177e4 1600 }
bfb35aa8
MH		 1601 aac_fib_complete(fibptr);
1602 aac_fib_free(fibptr);
1da177e4 1603
8e0c5ebd 1604 scsicmd->scsi_done(scsicmd);
1da177e4
LT		 1605}
1606
9e7c349c 1607static int aac_read(struct scsi_cmnd * scsicmd)
1da177e4 1608{
7a8cf29d 1609 u64 lba;
1da177e4
LT		 1610 u32 count;
1611 int status;
1da177e4
LT		 1612 struct aac_dev *dev;
1613 struct fib * cmd_fibcontext;
da3cc679 1614 int cid;
1da177e4
LT		 1615
1616 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
1617 /*
1618 * Get block address and transfer length
1619 */
7a8cf29d
MH		 1620 switch (scsicmd->cmnd[0]) {
1621 case READ_6:
9e7c349c 1622 dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd)));
1da177e4 1623
8ce3eca4 1624 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) |
7a8cf29d 1625 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
1da177e4
LT		 1626 count = scsicmd->cmnd[4];
1627
1628 if (count == 0)
1629 count = 256;
7a8cf29d
MH		 1630 break;
1631 case READ_16:
9e7c349c 1632 dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd)));
7a8cf29d 1633
8ce3eca4
SM		 1634 lba = ((u64)scsicmd->cmnd[2] << 56) |
1635 ((u64)scsicmd->cmnd[3] << 48) |
7a8cf29d
MH		 1636 ((u64)scsicmd->cmnd[4] << 40) |
1637 ((u64)scsicmd->cmnd[5] << 32) |
8ce3eca4 1638 ((u64)scsicmd->cmnd[6] << 24) |
7a8cf29d
MH		 1639 (scsicmd->cmnd[7] << 16) |
1640 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
8ce3eca4 1641 count = (scsicmd->cmnd[10] << 24) |
7a8cf29d
MH		 1642 (scsicmd->cmnd[11] << 16) |
1643 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
1644 break;
1645 case READ_12:
9e7c349c 1646 dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd)));
7a8cf29d 1647
8ce3eca4 1648 lba = ((u64)scsicmd->cmnd[2] << 24) |
7a8cf29d 1649 (scsicmd->cmnd[3] << 16) |
8ce3eca4
SM		 1650 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1651 count = (scsicmd->cmnd[6] << 24) |
7a8cf29d 1652 (scsicmd->cmnd[7] << 16) |
8ce3eca4 1653 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
7a8cf29d
MH		 1654 break;
1655 default:
9e7c349c 1656 dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd)));
1da177e4 1657
8ce3eca4
SM		 1658 lba = ((u64)scsicmd->cmnd[2] << 24) |
1659 (scsicmd->cmnd[3] << 16) |
7a8cf29d 1660 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1da177e4 1661 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
7a8cf29d 1662 break;
1da177e4 1663 }
da3cc679
RM		 1664
1665 if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) {
1666 cid = scmd_id(scsicmd);
1667 dprintk((KERN_DEBUG "aacraid: Illegal lba\n"));
1668 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1669 SAM_STAT_CHECK_CONDITION;
1670 set_sense(&dev->fsa_dev[cid].sense_data,
1671 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1672 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1673 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
1674 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1675 SCSI_SENSE_BUFFERSIZE));
1676 scsicmd->scsi_done(scsicmd);
1677 return 1;
1678 }
1679
7a8cf29d 1680 dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n",
7c00ffa3 1681 smp_processor_id(), (unsigned long long)lba, jiffies));
e8f32de5 1682 if (aac_adapter_bounds(dev,scsicmd,lba))
7a8cf29d 1683 return 0;
1da177e4
LT		 1684 /*
1685 * Alocate and initialize a Fib
1686 */
bfb35aa8 1687 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
cacb6dc3 1688 printk(KERN_WARNING "aac_read: fib allocation failed\n");
1da177e4
LT		 1689 return -1;
1690 }
1691
e8f32de5 1692 status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count);
1da177e4
LT		 1693
1694 /*
1695 * Check that the command queued to the controller
1696 */
77d644d4
MH		 1697 if (status == -EINPROGRESS) {
1698 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1da177e4 1699 return 0;
77d644d4 1700 }
8ce3eca4 1701
bfb35aa8 1702 printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status);
1da177e4
LT		 1703 /*
1704 * For some reason, the Fib didn't queue, return QUEUE_FULL
1705 */
1706 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
8e0c5ebd 1707 scsicmd->scsi_done(scsicmd);
bfb35aa8
MH		 1708 aac_fib_complete(cmd_fibcontext);
1709 aac_fib_free(cmd_fibcontext);
1da177e4
LT		 1710 return 0;
1711}
1712
9e7c349c 1713static int aac_write(struct scsi_cmnd * scsicmd)
1da177e4 1714{
7a8cf29d 1715 u64 lba;
1da177e4 1716 u32 count;
9d399cc7 1717 int fua;
1da177e4 1718 int status;
1da177e4
LT		 1719 struct aac_dev *dev;
1720 struct fib * cmd_fibcontext;
da3cc679 1721 int cid;
1da177e4
LT		 1722
1723 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
1724 /*
1725 * Get block address and transfer length
1726 */
1727 if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */
1728 {
1729 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
1730 count = scsicmd->cmnd[4];
1731 if (count == 0)
1732 count = 256;
9d399cc7 1733 fua = 0;
7a8cf29d 1734 } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */
9e7c349c 1735 dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd)));
7a8cf29d 1736
8ce3eca4 1737 lba = ((u64)scsicmd->cmnd[2] << 56) |
7a8cf29d
MH		 1738 ((u64)scsicmd->cmnd[3] << 48) |
1739 ((u64)scsicmd->cmnd[4] << 40) |
1740 ((u64)scsicmd->cmnd[5] << 32) |
8ce3eca4 1741 ((u64)scsicmd->cmnd[6] << 24) |
7a8cf29d
MH		 1742 (scsicmd->cmnd[7] << 16) |
1743 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
1744 count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) |
1745 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
9d399cc7 1746 fua = scsicmd->cmnd[1] & 0x8;
7a8cf29d 1747 } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */
9e7c349c 1748 dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd)));
7a8cf29d
MH		 1749
1750 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16)
1751 | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1752 count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
1753 | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
9d399cc7 1754 fua = scsicmd->cmnd[1] & 0x8;
1da177e4 1755 } else {
9e7c349c 1756 dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd)));
7a8cf29d 1757 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1da177e4 1758 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
9d399cc7 1759 fua = scsicmd->cmnd[1] & 0x8;
1da177e4 1760 }
da3cc679
RM		 1761
1762 if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) {
1763 cid = scmd_id(scsicmd);
1764 dprintk((KERN_DEBUG "aacraid: Illegal lba\n"));
1765 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1766 SAM_STAT_CHECK_CONDITION;
1767 set_sense(&dev->fsa_dev[cid].sense_data,
1768 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1769 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1770 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
1771 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1772 SCSI_SENSE_BUFFERSIZE));
1773 scsicmd->scsi_done(scsicmd);
1774 return 1;
1775 }
1776
7a8cf29d 1777 dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n",
1da177e4 1778 smp_processor_id(), (unsigned long long)lba, jiffies));
e8f32de5 1779 if (aac_adapter_bounds(dev,scsicmd,lba))
7a8cf29d 1780 return 0;
1da177e4
LT		 1781 /*
1782 * Allocate and initialize a Fib then setup a BlockWrite command
1783 */
bfb35aa8 1784 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
cacb6dc3
PNRCEH		 1785 /* FIB temporarily unavailable,not catastrophic failure */
1786
1787 /* scsicmd->result = DID_ERROR << 16;
1788 * scsicmd->scsi_done(scsicmd);
1789 * return 0;
1790 */
1791 printk(KERN_WARNING "aac_write: fib allocation failed\n");
1792 return -1;
1da177e4 1793 }
1da177e4 1794
9d399cc7 1795 status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
1da177e4
LT		 1796
1797 /*
1798 * Check that the command queued to the controller
1799 */
77d644d4
MH		 1800 if (status == -EINPROGRESS) {
1801 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1da177e4
LT		 1802 return 0;
1803 }
1804
bfb35aa8 1805 printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status);
1da177e4
LT		 1806 /*
1807 * For some reason, the Fib didn't queue, return QUEUE_FULL
1808 */
1809 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
8e0c5ebd 1810 scsicmd->scsi_done(scsicmd);
1da177e4 1811
bfb35aa8
MH		 1812 aac_fib_complete(cmd_fibcontext);
1813 aac_fib_free(cmd_fibcontext);
1da177e4
LT		 1814 return 0;
1815}
1816
1817static void synchronize_callback(void *context, struct fib *fibptr)
1818{
1819 struct aac_synchronize_reply *synchronizereply;
1820 struct scsi_cmnd *cmd;
1821
1822 cmd = context;
1823
03d44337
MH		 1824 if (!aac_valid_context(cmd, fibptr))
1825 return;
1826
b90f90d2 1827 dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n",
1da177e4
LT		 1828 smp_processor_id(), jiffies));
1829 BUG_ON(fibptr == NULL);
1830
1831
1832 synchronizereply = fib_data(fibptr);
1833 if (le32_to_cpu(synchronizereply->status) == CT_OK)
b90f90d2 1834 cmd->result = DID_OK << 16 |
1da177e4
LT		 1835 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
1836 else {
1837 struct scsi_device *sdev = cmd->device;
1a655040 1838 struct aac_dev *dev = fibptr->dev;
e5718774 1839 u32 cid = sdev_id(sdev);
b90f90d2 1840 printk(KERN_WARNING
1da177e4
LT		 1841 "synchronize_callback: synchronize failed, status = %d\n",
1842 le32_to_cpu(synchronizereply->status));
b90f90d2 1843 cmd->result = DID_OK << 16 |
1da177e4 1844 COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 1845 set_sense(&dev->fsa_dev[cid].sense_data,
1846 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1847 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1da177e4 1848 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
b80ca4f7
FT		 1849 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1850 SCSI_SENSE_BUFFERSIZE));
1da177e4
LT		 1851 }
1852
bfb35aa8
MH		 1853 aac_fib_complete(fibptr);
1854 aac_fib_free(fibptr);
8e0c5ebd 1855 cmd->scsi_done(cmd);
1da177e4
LT		 1856}
1857
9e7c349c 1858static int aac_synchronize(struct scsi_cmnd *scsicmd)
1da177e4
LT		 1859{
1860 int status;
1861 struct fib *cmd_fibcontext;
1862 struct aac_synchronize *synchronizecmd;
1863 struct scsi_cmnd *cmd;
1864 struct scsi_device *sdev = scsicmd->device;
1865 int active = 0;
90ee3466 1866 struct aac_dev *aac;
b90f90d2
SM		 1867 u64 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) |
1868 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1869 u32 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
1da177e4
LT		 1870 unsigned long flags;
1871
1872 /*
77d644d4
MH		 1873 * Wait for all outstanding queued commands to complete to this
1874 * specific target (block).
1da177e4
LT		 1875 */
1876 spin_lock_irqsave(&sdev->list_lock, flags);
1877 list_for_each_entry(cmd, &sdev->cmd_list, list)
b90f90d2
SM		 1878 if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) {
1879 u64 cmnd_lba;
1880 u32 cmnd_count;
1881
1882 if (cmd->cmnd[0] == WRITE_6) {
1883 cmnd_lba = ((cmd->cmnd[1] & 0x1F) << 16) |
1884 (cmd->cmnd[2] << 8) |
1885 cmd->cmnd[3];
1886 cmnd_count = cmd->cmnd[4];
1887 if (cmnd_count == 0)
1888 cmnd_count = 256;
1889 } else if (cmd->cmnd[0] == WRITE_16) {
1890 cmnd_lba = ((u64)cmd->cmnd[2] << 56) |
1891 ((u64)cmd->cmnd[3] << 48) |
1892 ((u64)cmd->cmnd[4] << 40) |
1893 ((u64)cmd->cmnd[5] << 32) |
1894 ((u64)cmd->cmnd[6] << 24) |
1895 (cmd->cmnd[7] << 16) |
1896 (cmd->cmnd[8] << 8) |
1897 cmd->cmnd[9];
1898 cmnd_count = (cmd->cmnd[10] << 24) |
1899 (cmd->cmnd[11] << 16) |
1900 (cmd->cmnd[12] << 8) |
1901 cmd->cmnd[13];
1902 } else if (cmd->cmnd[0] == WRITE_12) {
1903 cmnd_lba = ((u64)cmd->cmnd[2] << 24) |
1904 (cmd->cmnd[3] << 16) |
1905 (cmd->cmnd[4] << 8) |
1906 cmd->cmnd[5];
1907 cmnd_count = (cmd->cmnd[6] << 24) |
1908 (cmd->cmnd[7] << 16) |
1909 (cmd->cmnd[8] << 8) |
1910 cmd->cmnd[9];
1911 } else if (cmd->cmnd[0] == WRITE_10) {
1912 cmnd_lba = ((u64)cmd->cmnd[2] << 24) |
1913 (cmd->cmnd[3] << 16) |
1914 (cmd->cmnd[4] << 8) |
1915 cmd->cmnd[5];
1916 cmnd_count = (cmd->cmnd[7] << 8) |
1917 cmd->cmnd[8];
1918 } else
1919 continue;
1920 if (((cmnd_lba + cmnd_count) < lba) ||
1921 (count && ((lba + count) < cmnd_lba)))
1922 continue;
1da177e4
LT		 1923 ++active;
1924 break;
1925 }
1926
1927 spin_unlock_irqrestore(&sdev->list_lock, flags);
1928
1929 /*
1930 * Yield the processor (requeue for later)
1931 */
1932 if (active)
1933 return SCSI_MLQUEUE_DEVICE_BUSY;
1934
f858317d 1935 aac = (struct aac_dev *)sdev->host->hostdata;
8c867b25
MH		 1936 if (aac->in_reset)
1937 return SCSI_MLQUEUE_HOST_BUSY;
1938
1da177e4 1939 /*
7c00ffa3 1940 * Allocate and initialize a Fib
1da177e4 1941 */
90ee3466 1942 if (!(cmd_fibcontext = aac_fib_alloc(aac)))
1da177e4
LT		 1943 return SCSI_MLQUEUE_HOST_BUSY;
1944
bfb35aa8 1945 aac_fib_init(cmd_fibcontext);
1da177e4
LT		 1946
1947 synchronizecmd = fib_data(cmd_fibcontext);
1948 synchronizecmd->command = cpu_to_le32(VM_ContainerConfig);
1949 synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE);
9e7c349c 1950 synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd));
b90f90d2 1951 synchronizecmd->count =
1da177e4
LT		 1952 cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
1953
1954 /*
1955 * Now send the Fib to the adapter
1956 */
bfb35aa8 1957 status = aac_fib_send(ContainerCommand,
1da177e4
LT		 1958 cmd_fibcontext,
1959 sizeof(struct aac_synchronize),
1960 FsaNormal,
1961 0, 1,
1962 (fib_callback)synchronize_callback,
1963 (void *)scsicmd);
1964
1965 /*
1966 * Check that the command queued to the controller
1967 */
77d644d4
MH		 1968 if (status == -EINPROGRESS) {
1969 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1da177e4 1970 return 0;
77d644d4 1971 }
1da177e4 1972
b90f90d2 1973 printk(KERN_WARNING
bfb35aa8
MH		 1974 "aac_synchronize: aac_fib_send failed with status: %d.\n", status);
1975 aac_fib_complete(cmd_fibcontext);
1976 aac_fib_free(cmd_fibcontext);
1da177e4
LT		 1977 return SCSI_MLQUEUE_HOST_BUSY;
1978}
1979
655d722c
MS		 1980static void aac_start_stop_callback(void *context, struct fib *fibptr)
1981{
1982 struct scsi_cmnd *scsicmd = context;
1983
1984 if (!aac_valid_context(scsicmd, fibptr))
1985 return;
1986
1987 BUG_ON(fibptr == NULL);
1988
1989 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
1990
1991 aac_fib_complete(fibptr);
1992 aac_fib_free(fibptr);
1993 scsicmd->scsi_done(scsicmd);
1994}
1995
1996static int aac_start_stop(struct scsi_cmnd *scsicmd)
1997{
1998 int status;
1999 struct fib *cmd_fibcontext;
2000 struct aac_power_management *pmcmd;
2001 struct scsi_device *sdev = scsicmd->device;
2002 struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata;
2003
2004 if (!(aac->supplement_adapter_info.SupportedOptions2 &
2005 AAC_OPTION_POWER_MANAGEMENT)) {
2006 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
2007 SAM_STAT_GOOD;
2008 scsicmd->scsi_done(scsicmd);
2009 return 0;
2010 }
2011
2012 if (aac->in_reset)
2013 return SCSI_MLQUEUE_HOST_BUSY;
2014
2015 /*
2016 * Allocate and initialize a Fib
2017 */
2018 cmd_fibcontext = aac_fib_alloc(aac);
2019 if (!cmd_fibcontext)
2020 return SCSI_MLQUEUE_HOST_BUSY;
2021
2022 aac_fib_init(cmd_fibcontext);
2023
2024 pmcmd = fib_data(cmd_fibcontext);
2025 pmcmd->command = cpu_to_le32(VM_ContainerConfig);
2026 pmcmd->type = cpu_to_le32(CT_POWER_MANAGEMENT);
2027 /* Eject bit ignored, not relevant */
2028 pmcmd->sub = (scsicmd->cmnd[4] & 1) ?
2029 cpu_to_le32(CT_PM_START_UNIT) : cpu_to_le32(CT_PM_STOP_UNIT);
2030 pmcmd->cid = cpu_to_le32(sdev_id(sdev));
2031 pmcmd->parm = (scsicmd->cmnd[1] & 1) ?
2032 cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0;
2033
2034 /*
2035 * Now send the Fib to the adapter
2036 */
2037 status = aac_fib_send(ContainerCommand,
2038 cmd_fibcontext,
2039 sizeof(struct aac_power_management),
2040 FsaNormal,
2041 0, 1,
2042 (fib_callback)aac_start_stop_callback,
2043 (void *)scsicmd);
2044
2045 /*
2046 * Check that the command queued to the controller
2047 */
2048 if (status == -EINPROGRESS) {
2049 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
2050 return 0;
2051 }
2052
2053 aac_fib_complete(cmd_fibcontext);
2054 aac_fib_free(cmd_fibcontext);
2055 return SCSI_MLQUEUE_HOST_BUSY;
2056}
2057
1da177e4
LT		 2058/**
2059 * aac_scsi_cmd() - Process SCSI command
2060 * @scsicmd: SCSI command block
2061 *
2062 * Emulate a SCSI command and queue the required request for the
2063 * aacraid firmware.
2064 */
8ce3eca4 2065
1da177e4
LT		 2066int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
2067{
1a655040 2068 u32 cid;
1da177e4
LT		 2069 struct Scsi_Host *host = scsicmd->device->host;
2070 struct aac_dev *dev = (struct aac_dev *)host->hostdata;
2071 struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev;
8ce3eca4 2072
90ee3466
MH		 2073 if (fsa_dev_ptr == NULL)
2074 return -1;
1da177e4
LT		 2075 /*
2076 * If the bus, id or lun is out of range, return fail
2077 * Test does not apply to ID 16, the pseudo id for the controller
2078 * itself.
2079 */
1a655040
SM		 2080 cid = scmd_id(scsicmd);
2081 if (cid != host->this_id) {
2082 if (scmd_channel(scsicmd) == CONTAINER_CHANNEL) {
2083 if((cid >= dev->maximum_num_containers) ||
e5718774 2084 (scsicmd->device->lun != 0)) {
1da177e4
LT		 2085 scsicmd->result = DID_NO_CONNECT << 16;
2086 scsicmd->scsi_done(scsicmd);
2087 return 0;
2088 }
1da177e4
LT		 2089
2090 /*
2091 * If the target container doesn't exist, it may have
2092 * been newly created
2093 */
655d722c
MS		 2094 if (((fsa_dev_ptr[cid].valid & 1) == 0) ||
2095 (fsa_dev_ptr[cid].sense_data.sense_key ==
2096 NOT_READY)) {
1da177e4 2097 switch (scsicmd->cmnd[0]) {
7a8cf29d
MH		 2098 case SERVICE_ACTION_IN:
2099 if (!(dev->raw_io_interface) ||
2100 !(dev->raw_io_64) ||
2101 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
2102 break;
1da177e4
LT		 2103 case INQUIRY:
2104 case READ_CAPACITY:
2105 case TEST_UNIT_READY:
8c867b25
MH		 2106 if (dev->in_reset)
2107 return -1;
fe76df42
MH		 2108 return _aac_probe_container(scsicmd,
2109 aac_probe_container_callback2);
1da177e4
LT		 2110 default:
2111 break;
2112 }
2113 }
1da177e4 2114 } else { /* check for physical non-dasd devices */
cb1042f2
SM		 2115 if (dev->nondasd_support || expose_physicals ||
2116 dev->jbod) {
8c867b25
MH		 2117 if (dev->in_reset)
2118 return -1;
1da177e4
LT		 2119 return aac_send_srb_fib(scsicmd);
2120 } else {
2121 scsicmd->result = DID_NO_CONNECT << 16;
2122 scsicmd->scsi_done(scsicmd);
2123 return 0;
2124 }
2125 }
2126 }
2127 /*
2128 * else Command for the controller itself
2129 */
2130 else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */
8ce3eca4 2131 (scsicmd->cmnd[0] != TEST_UNIT_READY))
1da177e4
LT		 2132 {
2133 dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0]));
2134 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 2135 set_sense(&dev->fsa_dev[cid].sense_data,
2136 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND,
2137 ASENCODE_INVALID_COMMAND, 0, 0);
1da177e4 2138 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
3ace426f
SM		 2139 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
2140 SCSI_SENSE_BUFFERSIZE));
1da177e4
LT		 2141 scsicmd->scsi_done(scsicmd);
2142 return 0;
2143 }
2144
2145
2146 /* Handle commands here that don't really require going out to the adapter */
2147 switch (scsicmd->cmnd[0]) {
2148 case INQUIRY:
2149 {
3b2946cc 2150 struct inquiry_data inq_data;
1da177e4 2151
1a655040 2152 dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid));
3b2946cc 2153 memset(&inq_data, 0, sizeof (struct inquiry_data));
1da177e4 2154
d8e96507 2155 if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) {
88e2f98e
SM		 2156 char *arr = (char *)&inq_data;
2157
2158 /* EVPD bit set */
2159 arr[0] = (scmd_id(scsicmd) == host->this_id) ?
2160 INQD_PDT_PROC : INQD_PDT_DA;
2161 if (scsicmd->cmnd[2] == 0) {
2162 /* supported vital product data pages */
2163 arr[3] = 2;
2164 arr[4] = 0x0;
2165 arr[5] = 0x80;
2166 arr[1] = scsicmd->cmnd[2];
d4345028
FT		 2167 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2168 sizeof(inq_data));
88e2f98e
SM		 2169 scsicmd->result = DID_OK << 16 |
2170 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2171 } else if (scsicmd->cmnd[2] == 0x80) {
2172 /* unit serial number page */
2173 arr[3] = setinqserial(dev, &arr[4],
2174 scmd_id(scsicmd));
2175 arr[1] = scsicmd->cmnd[2];
d4345028
FT		 2176 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2177 sizeof(inq_data));
d8e96507
LA		 2178 if (aac_wwn != 2)
2179 return aac_get_container_serial(
2180 scsicmd);
2181 /* SLES 10 SP1 special */
2182 scsicmd->result = DID_OK << 16 |
2183 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
88e2f98e
SM		 2184 } else {
2185 /* vpd page not implemented */
2186 scsicmd->result = DID_OK << 16 |
2187 COMMAND_COMPLETE << 8 |
2188 SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 2189 set_sense(&dev->fsa_dev[cid].sense_data,
2190 ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD,
2191 ASENCODE_NO_SENSE, 7, 2);
88e2f98e
SM		 2192 memcpy(scsicmd->sense_buffer,
2193 &dev->fsa_dev[cid].sense_data,
3ace426f
SM		 2194 min_t(size_t,
2195 sizeof(dev->fsa_dev[cid].sense_data),
2196 SCSI_SENSE_BUFFERSIZE));
88e2f98e
SM		 2197 }
2198 scsicmd->scsi_done(scsicmd);
2199 return 0;
2200 }
3b2946cc 2201 inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */
3b2946cc
MH		 2202 inq_data.inqd_rdf = 2; /* A response data format value of two indicates that the data shall be in the format specified in SCSI-2 */
2203 inq_data.inqd_len = 31;
1da177e4 2204 /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */
3b2946cc 2205 inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */
1da177e4
LT		 2206 /*
2207 * Set the Vendor, Product, and Revision Level
2208 * see: <vendor>.c i.e. aac.c
2209 */
1a655040 2210 if (cid == host->this_id) {
6391a113 2211 setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types));
3b2946cc 2212 inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */
d4345028
FT		 2213 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2214 sizeof(inq_data));
1da177e4
LT		 2215 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2216 scsicmd->scsi_done(scsicmd);
2217 return 0;
2218 }
8c867b25
MH		 2219 if (dev->in_reset)
2220 return -1;
794d0601 2221 setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type);
3b2946cc 2222 inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */
d4345028 2223 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data));
9e7c349c 2224 return aac_get_container_name(scsicmd);
1da177e4 2225 }
7a8cf29d
MH		 2226 case SERVICE_ACTION_IN:
2227 if (!(dev->raw_io_interface) ||
2228 !(dev->raw_io_64) ||
2229 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
2230 break;
2231 {
2232 u64 capacity;
07ce5eba 2233 char cp[13];
b271f1c8 2234 unsigned int alloc_len;
7a8cf29d
MH		 2235
2236 dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n"));
2237 capacity = fsa_dev_ptr[cid].size - 1;
7a8cf29d
MH		 2238 cp[0] = (capacity >> 56) & 0xff;
2239 cp[1] = (capacity >> 48) & 0xff;
2240 cp[2] = (capacity >> 40) & 0xff;
2241 cp[3] = (capacity >> 32) & 0xff;
2242 cp[4] = (capacity >> 24) & 0xff;
2243 cp[5] = (capacity >> 16) & 0xff;
2244 cp[6] = (capacity >> 8) & 0xff;
2245 cp[7] = (capacity >> 0) & 0xff;
2246 cp[8] = 0;
2247 cp[9] = 0;
2248 cp[10] = 2;
2249 cp[11] = 0;
07ce5eba 2250 cp[12] = 0;
07ce5eba 2251
b271f1c8
FT		 2252 alloc_len = ((scsicmd->cmnd[10] << 24)
2253 + (scsicmd->cmnd[11] << 16)
2254 + (scsicmd->cmnd[12] << 8) + scsicmd->cmnd[13]);
2255
2256 alloc_len = min_t(size_t, alloc_len, sizeof(cp));
d4345028 2257 scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len);
b271f1c8
FT		 2258 if (alloc_len < scsi_bufflen(scsicmd))
2259 scsi_set_resid(scsicmd,
2260 scsi_bufflen(scsicmd) - alloc_len);
7a8cf29d
MH		 2261
2262 /* Do not cache partition table for arrays */
2263 scsicmd->device->removable = 1;
2264
2265 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2266 scsicmd->scsi_done(scsicmd);
2267
2268 return 0;
2269 }
2270
1da177e4
LT		 2271 case READ_CAPACITY:
2272 {
2273 u32 capacity;
3b2946cc 2274 char cp[8];
1da177e4
LT		 2275
2276 dprintk((KERN_DEBUG "READ CAPACITY command.\n"));
7a8cf29d 2277 if (fsa_dev_ptr[cid].size <= 0x100000000ULL)
1da177e4
LT		 2278 capacity = fsa_dev_ptr[cid].size - 1;
2279 else
2280 capacity = (u32)-1;
3b2946cc 2281
1da177e4
LT		 2282 cp[0] = (capacity >> 24) & 0xff;
2283 cp[1] = (capacity >> 16) & 0xff;
2284 cp[2] = (capacity >> 8) & 0xff;
2285 cp[3] = (capacity >> 0) & 0xff;
2286 cp[4] = 0;
2287 cp[5] = 0;
2288 cp[6] = 2;
2289 cp[7] = 0;
d4345028 2290 scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp));
7a8cf29d
MH		 2291 /* Do not cache partition table for arrays */
2292 scsicmd->device->removable = 1;
655d722c
MS		 2293 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
2294 SAM_STAT_GOOD;
1da177e4
LT		 2295 scsicmd->scsi_done(scsicmd);
2296
2297 return 0;
2298 }
2299
2300 case MODE_SENSE:
2301 {
9d399cc7
SM		 2302 char mode_buf[7];
2303 int mode_buf_length = 4;
1da177e4
LT		 2304
2305 dprintk((KERN_DEBUG "MODE SENSE command.\n"));
1da177e4
LT		 2306 mode_buf[0] = 3; /* Mode data length */
2307 mode_buf[1] = 0; /* Medium type - default */
9d399cc7
SM		 2308 mode_buf[2] = 0; /* Device-specific param,
2309 bit 8: 0/1 = write enabled/protected
2310 bit 4: 0/1 = FUA enabled */
95e852e1 2311 if (dev->raw_io_interface && ((aac_cache & 5) != 1))
9d399cc7 2312 mode_buf[2] = 0x10;
1da177e4 2313 mode_buf[3] = 0; /* Block descriptor length */
9d399cc7
SM		 2314 if (((scsicmd->cmnd[2] & 0x3f) == 8) ||
2315 ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) {
2316 mode_buf[0] = 6;
2317 mode_buf[4] = 8;
2318 mode_buf[5] = 1;
95e852e1
SM		 2319 mode_buf[6] = ((aac_cache & 6) == 2)
2320 ? 0 : 0x04; /* WCE */
9d399cc7
SM		 2321 mode_buf_length = 7;
2322 if (mode_buf_length > scsicmd->cmnd[4])
2323 mode_buf_length = scsicmd->cmnd[4];
2324 }
d4345028 2325 scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length);
1da177e4
LT		 2326 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2327 scsicmd->scsi_done(scsicmd);
2328
2329 return 0;
2330 }
2331 case MODE_SENSE_10:
2332 {
9d399cc7
SM		 2333 char mode_buf[11];
2334 int mode_buf_length = 8;
1da177e4
LT		 2335
2336 dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n"));
1da177e4
LT		 2337 mode_buf[0] = 0; /* Mode data length (MSB) */
2338 mode_buf[1] = 6; /* Mode data length (LSB) */
2339 mode_buf[2] = 0; /* Medium type - default */
9d399cc7
SM		 2340 mode_buf[3] = 0; /* Device-specific param,
2341 bit 8: 0/1 = write enabled/protected
2342 bit 4: 0/1 = FUA enabled */
95e852e1 2343 if (dev->raw_io_interface && ((aac_cache & 5) != 1))
9d399cc7 2344 mode_buf[3] = 0x10;
1da177e4
LT		 2345 mode_buf[4] = 0; /* reserved */
2346 mode_buf[5] = 0; /* reserved */
2347 mode_buf[6] = 0; /* Block descriptor length (MSB) */
2348 mode_buf[7] = 0; /* Block descriptor length (LSB) */
9d399cc7
SM		 2349 if (((scsicmd->cmnd[2] & 0x3f) == 8) ||
2350 ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) {
2351 mode_buf[1] = 9;
2352 mode_buf[8] = 8;
2353 mode_buf[9] = 1;
95e852e1
SM		 2354 mode_buf[10] = ((aac_cache & 6) == 2)
2355 ? 0 : 0x04; /* WCE */
9d399cc7
SM		 2356 mode_buf_length = 11;
2357 if (mode_buf_length > scsicmd->cmnd[8])
2358 mode_buf_length = scsicmd->cmnd[8];
2359 }
d4345028 2360 scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length);
1da177e4
LT		 2361
2362 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2363 scsicmd->scsi_done(scsicmd);
2364
2365 return 0;
2366 }
2367 case REQUEST_SENSE:
2368 dprintk((KERN_DEBUG "REQUEST SENSE command.\n"));
2369 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data));
2370 memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data));
2371 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2372 scsicmd->scsi_done(scsicmd);
2373 return 0;
2374
2375 case ALLOW_MEDIUM_REMOVAL:
2376 dprintk((KERN_DEBUG "LOCK command.\n"));
2377 if (scsicmd->cmnd[4])
2378 fsa_dev_ptr[cid].locked = 1;
2379 else
2380 fsa_dev_ptr[cid].locked = 0;
2381
2382 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2383 scsicmd->scsi_done(scsicmd);
2384 return 0;
2385 /*
2386 * These commands are all No-Ops
2387 */
2388 case TEST_UNIT_READY:
655d722c
MS		 2389 if (fsa_dev_ptr[cid].sense_data.sense_key == NOT_READY) {
2390 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
2391 SAM_STAT_CHECK_CONDITION;
2392 set_sense(&dev->fsa_dev[cid].sense_data,
2393 NOT_READY, SENCODE_BECOMING_READY,
2394 ASENCODE_BECOMING_READY, 0, 0);
2395 memcpy(scsicmd->sense_buffer,
2396 &dev->fsa_dev[cid].sense_data,
2397 min_t(size_t,
2398 sizeof(dev->fsa_dev[cid].sense_data),
2399 SCSI_SENSE_BUFFERSIZE));
2400 scsicmd->scsi_done(scsicmd);
2401 return 0;
2402 }
2403 /* FALLTHRU */
1da177e4
LT		 2404 case RESERVE:
2405 case RELEASE:
2406 case REZERO_UNIT:
2407 case REASSIGN_BLOCKS:
2408 case SEEK_10:
1da177e4
LT		 2409 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2410 scsicmd->scsi_done(scsicmd);
2411 return 0;
655d722c
MS		 2412
2413 case START_STOP:
2414 return aac_start_stop(scsicmd);
1da177e4
LT		 2415 }
2416
8ce3eca4 2417 switch (scsicmd->cmnd[0])
1da177e4
LT		 2418 {
2419 case READ_6:
2420 case READ_10:
7a8cf29d
MH		 2421 case READ_12:
2422 case READ_16:
8c867b25
MH		 2423 if (dev->in_reset)
2424 return -1;
1da177e4
LT		 2425 /*
2426 * Hack to keep track of ordinal number of the device that
2427 * corresponds to a container. Needed to convert
2428 * containers to /dev/sd device names
2429 */
8ce3eca4 2430
7a8cf29d
MH		 2431 if (scsicmd->request->rq_disk)
2432 strlcpy(fsa_dev_ptr[cid].devname,
2433 scsicmd->request->rq_disk->disk_name,
8ce3eca4 2434 min(sizeof(fsa_dev_ptr[cid].devname),
7a8cf29d 2435 sizeof(scsicmd->request->rq_disk->disk_name) + 1));
77d644d4 2436
9e7c349c 2437 return aac_read(scsicmd);
1da177e4
LT		 2438
2439 case WRITE_6:
2440 case WRITE_10:
7a8cf29d
MH		 2441 case WRITE_12:
2442 case WRITE_16:
8c867b25
MH		 2443 if (dev->in_reset)
2444 return -1;
9e7c349c 2445 return aac_write(scsicmd);
1da177e4
LT		 2446
2447 case SYNCHRONIZE_CACHE:
95e852e1
SM		 2448 if (((aac_cache & 6) == 6) && dev->cache_protected) {
2449 scsicmd->result = DID_OK << 16 |
2450 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2451 scsicmd->scsi_done(scsicmd);
2452 return 0;
2453 }
1da177e4 2454 /* Issue FIB to tell Firmware to flush it's cache */
95e852e1
SM		 2455 if ((aac_cache & 6) != 2)
2456 return aac_synchronize(scsicmd);
2457 /* FALLTHRU */
1da177e4
LT		 2458 default:
2459 /*
2460 * Unhandled commands
2461 */
7c00ffa3 2462 dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0]));
1da177e4 2463 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
8e31e607
SM		 2464 set_sense(&dev->fsa_dev[cid].sense_data,
2465 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND,
2466 ASENCODE_INVALID_COMMAND, 0, 0);
1da177e4 2467 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
3ace426f
SM		 2468 min_t(size_t,
2469 sizeof(dev->fsa_dev[cid].sense_data),
2470 SCSI_SENSE_BUFFERSIZE));
1da177e4
LT		 2471 scsicmd->scsi_done(scsicmd);
2472 return 0;
2473 }
2474}
2475
2476static int query_disk(struct aac_dev *dev, void __user *arg)
2477{
2478 struct aac_query_disk qd;
2479 struct fsa_dev_info *fsa_dev_ptr;
2480
2481 fsa_dev_ptr = dev->fsa_dev;
90ee3466 2482 if (!fsa_dev_ptr)
65101355 2483 return -EBUSY;
1da177e4
LT		 2484 if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk)))
2485 return -EFAULT;
2486 if (qd.cnum == -1)
e5718774 2487 qd.cnum = qd.id;
8ce3eca4 2488 else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1))
1da177e4
LT		 2489 {
2490 if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers)
2491 return -EINVAL;
2492 qd.instance = dev->scsi_host_ptr->host_no;
2493 qd.bus = 0;
2494 qd.id = CONTAINER_TO_ID(qd.cnum);
2495 qd.lun = CONTAINER_TO_LUN(qd.cnum);
2496 }
2497 else return -EINVAL;
2498
fd622b1b 2499 qd.valid = fsa_dev_ptr[qd.cnum].valid != 0;
1da177e4
LT		 2500 qd.locked = fsa_dev_ptr[qd.cnum].locked;
2501 qd.deleted = fsa_dev_ptr[qd.cnum].deleted;
2502
2503 if (fsa_dev_ptr[qd.cnum].devname[0] == '\0')
2504 qd.unmapped = 1;
2505 else
2506 qd.unmapped = 0;
2507
2508 strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname,
2509 min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1));
2510
2511 if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk)))
2512 return -EFAULT;
2513 return 0;
2514}
2515
2516static int force_delete_disk(struct aac_dev *dev, void __user *arg)
2517{
2518 struct aac_delete_disk dd;
2519 struct fsa_dev_info *fsa_dev_ptr;
2520
2521 fsa_dev_ptr = dev->fsa_dev;
65101355
MH		 2522 if (!fsa_dev_ptr)
2523 return -EBUSY;
1da177e4
LT		 2524
2525 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
2526 return -EFAULT;
2527
2528 if (dd.cnum >= dev->maximum_num_containers)
2529 return -EINVAL;
2530 /*
2531 * Mark this container as being deleted.
2532 */
2533 fsa_dev_ptr[dd.cnum].deleted = 1;
2534 /*
2535 * Mark the container as no longer valid
2536 */
2537 fsa_dev_ptr[dd.cnum].valid = 0;
2538 return 0;
2539}
2540
2541static int delete_disk(struct aac_dev *dev, void __user *arg)
2542{
2543 struct aac_delete_disk dd;
2544 struct fsa_dev_info *fsa_dev_ptr;
2545
2546 fsa_dev_ptr = dev->fsa_dev;
90ee3466 2547 if (!fsa_dev_ptr)
65101355 2548 return -EBUSY;
1da177e4
LT		 2549
2550 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
2551 return -EFAULT;
2552
2553 if (dd.cnum >= dev->maximum_num_containers)
2554 return -EINVAL;
2555 /*
2556 * If the container is locked, it can not be deleted by the API.
2557 */
2558 if (fsa_dev_ptr[dd.cnum].locked)
2559 return -EBUSY;
2560 else {
2561 /*
2562 * Mark the container as no longer being valid.
2563 */
2564 fsa_dev_ptr[dd.cnum].valid = 0;
2565 fsa_dev_ptr[dd.cnum].devname[0] = '\0';
2566 return 0;
2567 }
2568}
2569
2570int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg)
2571{
2572 switch (cmd) {
2573 case FSACTL_QUERY_DISK:
2574 return query_disk(dev, arg);
2575 case FSACTL_DELETE_DISK:
2576 return delete_disk(dev, arg);
2577 case FSACTL_FORCE_DELETE_DISK:
2578 return force_delete_disk(dev, arg);
2579 case FSACTL_GET_CONTAINERS:
2580 return aac_get_containers(dev);
2581 default:
2582 return -ENOTTY;
2583 }
2584}
2585
2586/**
2587 *
2588 * aac_srb_callback
2589 * @context: the context set in the fib - here it is scsi cmd
2590 * @fibptr: pointer to the fib
2591 *
2592 * Handles the completion of a scsi command to a non dasd device
2593 *
2594 */
2595
2596static void aac_srb_callback(void *context, struct fib * fibptr)
2597{
2598 struct aac_dev *dev;
2599 struct aac_srb_reply *srbreply;
2600 struct scsi_cmnd *scsicmd;
2601
2602 scsicmd = (struct scsi_cmnd *) context;
03d44337
MH		 2603
2604 if (!aac_valid_context(scsicmd, fibptr))
2605 return;
2606
125e1874 2607 BUG_ON(fibptr == NULL);
1da177e4 2608
1a655040
SM		 2609 dev = fibptr->dev;
2610
1da177e4
LT		 2611 srbreply = (struct aac_srb_reply *) fib_data(fibptr);
2612
2613 scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */
2614 /*
8ce3eca4 2615 * Calculate resid for sg
1da177e4 2616 */
727eead6
FT		 2617
2618 scsi_set_resid(scsicmd, scsi_bufflen(scsicmd)
2619 - le32_to_cpu(srbreply->data_xfer_length));
2620
2621 scsi_dma_unmap(scsicmd);
1da177e4 2622
e3cc268f
RM		 2623 /* expose physical device if expose_physicald flag is on */
2624 if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01)
2625 && expose_physicals > 0)
2626 aac_expose_phy_device(scsicmd);
2627
1da177e4
LT		 2628 /*
2629 * First check the fib status
2630 */
2631
2632 if (le32_to_cpu(srbreply->status) != ST_OK){
2633 int len;
2634 printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status));
3ace426f
SM		 2635 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
2636 SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 2637 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
2638 memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
2639 }
2640
2641 /*
2642 * Next check the srb status
2643 */
2644 switch( (le32_to_cpu(srbreply->srb_status))&0x3f){
2645 case SRB_STATUS_ERROR_RECOVERY:
2646 case SRB_STATUS_PENDING:
2647 case SRB_STATUS_SUCCESS:
bb08f92e 2648 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
1da177e4
LT		 2649 break;
2650 case SRB_STATUS_DATA_OVERRUN:
2651 switch(scsicmd->cmnd[0]){
2652 case READ_6:
2653 case WRITE_6:
2654 case READ_10:
2655 case WRITE_10:
2656 case READ_12:
2657 case WRITE_12:
7a8cf29d
MH		 2658 case READ_16:
2659 case WRITE_16:
8ce3eca4 2660 if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) {
1da177e4
LT		 2661 printk(KERN_WARNING"aacraid: SCSI CMD underflow\n");
2662 } else {
2663 printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n");
2664 }
2665 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
2666 break;
2667 case INQUIRY: {
bb08f92e 2668 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
1da177e4
LT		 2669 break;
2670 }
2671 default:
2672 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
2673 break;
2674 }
2675 break;
2676 case SRB_STATUS_ABORTED:
2677 scsicmd->result = DID_ABORT << 16 | ABORT << 8;
2678 break;
2679 case SRB_STATUS_ABORT_FAILED:
2680 // Not sure about this one - but assuming the hba was trying to abort for some reason
2681 scsicmd->result = DID_ERROR << 16 | ABORT << 8;
2682 break;
2683 case SRB_STATUS_PARITY_ERROR:
2684 scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8;
2685 break;
2686 case SRB_STATUS_NO_DEVICE:
2687 case SRB_STATUS_INVALID_PATH_ID:
2688 case SRB_STATUS_INVALID_TARGET_ID:
2689 case SRB_STATUS_INVALID_LUN:
2690 case SRB_STATUS_SELECTION_TIMEOUT:
2691 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
2692 break;
2693
2694 case SRB_STATUS_COMMAND_TIMEOUT:
2695 case SRB_STATUS_TIMEOUT:
2696 scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8;
2697 break;
2698
2699 case SRB_STATUS_BUSY:
760af100 2700 scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8;
1da177e4
LT		 2701 break;
2702
2703 case SRB_STATUS_BUS_RESET:
2704 scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8;
2705 break;
2706
2707 case SRB_STATUS_MESSAGE_REJECTED:
2708 scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8;
2709 break;
2710 case SRB_STATUS_REQUEST_FLUSHED:
2711 case SRB_STATUS_ERROR:
2712 case SRB_STATUS_INVALID_REQUEST:
2713 case SRB_STATUS_REQUEST_SENSE_FAILED:
2714 case SRB_STATUS_NO_HBA:
2715 case SRB_STATUS_UNEXPECTED_BUS_FREE:
2716 case SRB_STATUS_PHASE_SEQUENCE_FAILURE:
2717 case SRB_STATUS_BAD_SRB_BLOCK_LENGTH:
2718 case SRB_STATUS_DELAYED_RETRY:
2719 case SRB_STATUS_BAD_FUNCTION:
2720 case SRB_STATUS_NOT_STARTED:
2721 case SRB_STATUS_NOT_IN_USE:
2722 case SRB_STATUS_FORCE_ABORT:
2723 case SRB_STATUS_DOMAIN_VALIDATION_FAIL:
2724 default:
2725#ifdef AAC_DETAILED_STATUS_INFO
2726 printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n",
2727 le32_to_cpu(srbreply->srb_status) & 0x3F,
2728 aac_get_status_string(
8ce3eca4
SM		 2729 le32_to_cpu(srbreply->srb_status) & 0x3F),
2730 scsicmd->cmnd[0],
1da177e4
LT		 2731 le32_to_cpu(srbreply->scsi_status));
2732#endif
1fc8010a
RM		 2733 if ((scsicmd->cmnd[0] == ATA_12)
2734 || (scsicmd->cmnd[0] == ATA_16)) {
2735 if (scsicmd->cmnd[2] & (0x01 << 5)) {
2736 scsicmd->result = DID_OK << 16
2737 | COMMAND_COMPLETE << 8;
2738 break;
2739 } else {
2740 scsicmd->result = DID_ERROR << 16
2741 | COMMAND_COMPLETE << 8;
2742 break;
2743 }
2744 } else {
2745 scsicmd->result = DID_ERROR << 16
2746 | COMMAND_COMPLETE << 8;
2747 break;
2748 }
1da177e4 2749 }
8ce3eca4 2750 if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) {
1da177e4
LT		 2751 int len;
2752 scsicmd->result |= SAM_STAT_CHECK_CONDITION;
3ace426f
SM		 2753 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
2754 SCSI_SENSE_BUFFERSIZE);
1da177e4 2755#ifdef AAC_DETAILED_STATUS_INFO
7a8cf29d
MH		 2756 printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n",
2757 le32_to_cpu(srbreply->status), len);
1da177e4
LT		 2758#endif
2759 memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
1da177e4
LT		 2760 }
2761 /*
2762 * OR in the scsi status (already shifted up a bit)
2763 */
2764 scsicmd->result |= le32_to_cpu(srbreply->scsi_status);
2765
bfb35aa8
MH		 2766 aac_fib_complete(fibptr);
2767 aac_fib_free(fibptr);
8e0c5ebd 2768 scsicmd->scsi_done(scsicmd);
1da177e4
LT		 2769}
2770
2771/**
2772 *
2773 * aac_send_scb_fib
2774 * @scsicmd: the scsi command block
2775 *
8ce3eca4 2776 * This routine will form a FIB and fill in the aac_srb from the
1da177e4
LT		 2777 * scsicmd passed in.
2778 */
2779
2780static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
2781{
2782 struct fib* cmd_fibcontext;
2783 struct aac_dev* dev;
2784 int status;
1da177e4 2785
84971738 2786 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
e5718774 2787 if (scmd_id(scsicmd) >= dev->maximum_num_physicals ||
84971738 2788 scsicmd->device->lun > 7) {
1da177e4
LT		 2789 scsicmd->result = DID_NO_CONNECT << 16;
2790 scsicmd->scsi_done(scsicmd);
2791 return 0;
2792 }
2793
1da177e4
LT		 2794 /*
2795 * Allocate and initialize a Fib then setup a BlockWrite command
2796 */
bfb35aa8 2797 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
1da177e4
LT		 2798 return -1;
2799 }
e8f32de5 2800 status = aac_adapter_scsi(cmd_fibcontext, scsicmd);
1da177e4 2801
1da177e4
LT		 2802 /*
2803 * Check that the command queued to the controller
2804 */
77d644d4
MH		 2805 if (status == -EINPROGRESS) {
2806 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1da177e4
LT		 2807 return 0;
2808 }
2809
bfb35aa8
MH		 2810 printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status);
2811 aac_fib_complete(cmd_fibcontext);
2812 aac_fib_free(cmd_fibcontext);
1da177e4
LT		 2813
2814 return -1;
2815}
2816
2817static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg)
2818{
2819 struct aac_dev *dev;
2820 unsigned long byte_count = 0;
727eead6 2821 int nseg;
1da177e4
LT		 2822
2823 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
2824 // Get rid of old data
2825 psg->count = 0;
2826 psg->sg[0].addr = 0;
727eead6
FT		 2827 psg->sg[0].count = 0;
2828
2829 nseg = scsi_dma_map(scsicmd);
2830 BUG_ON(nseg < 0);
2831 if (nseg) {
1da177e4
LT		 2832 struct scatterlist *sg;
2833 int i;
1da177e4 2834
727eead6 2835 psg->count = cpu_to_le32(nseg);
1da177e4 2836
727eead6 2837 scsi_for_each_sg(scsicmd, sg, nseg, i) {
1da177e4
LT		 2838 psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg));
2839 psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));
2840 byte_count += sg_dma_len(sg);
1da177e4
LT		 2841 }
2842 /* hba wants the size to be exact */
727eead6
FT		 2843 if (byte_count > scsi_bufflen(scsicmd)) {
2844 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2845 (byte_count - scsi_bufflen(scsicmd));
56b58712 2846 psg->sg[i-1].count = cpu_to_le32(temp);
727eead6 2847 byte_count = scsi_bufflen(scsicmd);
1da177e4
LT		 2848 }
2849 /* Check for command underflow */
2850 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
2851 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n",
2852 byte_count, scsicmd->underflow);
2853 }
2854 }
1da177e4
LT		 2855 return byte_count;
2856}
2857
2858
2859static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg)
2860{
2861 struct aac_dev *dev;
2862 unsigned long byte_count = 0;
56b58712 2863 u64 addr;
727eead6 2864 int nseg;
1da177e4
LT		 2865
2866 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
2867 // Get rid of old data
2868 psg->count = 0;
2869 psg->sg[0].addr[0] = 0;
2870 psg->sg[0].addr[1] = 0;
2871 psg->sg[0].count = 0;
727eead6
FT		 2872
2873 nseg = scsi_dma_map(scsicmd);
2874 BUG_ON(nseg < 0);
2875 if (nseg) {
1da177e4
LT		 2876 struct scatterlist *sg;
2877 int i;
1da177e4 2878
727eead6 2879 scsi_for_each_sg(scsicmd, sg, nseg, i) {
1241f359 2880 int count = sg_dma_len(sg);
56b58712
MH		 2881 addr = sg_dma_address(sg);
2882 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
2883 psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
1241f359
MH		 2884 psg->sg[i].count = cpu_to_le32(count);
2885 byte_count += count;
1da177e4 2886 }
727eead6 2887 psg->count = cpu_to_le32(nseg);
1da177e4 2888 /* hba wants the size to be exact */
727eead6
FT		 2889 if (byte_count > scsi_bufflen(scsicmd)) {
2890 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2891 (byte_count - scsi_bufflen(scsicmd));
56b58712 2892 psg->sg[i-1].count = cpu_to_le32(temp);
727eead6 2893 byte_count = scsi_bufflen(scsicmd);
1da177e4
LT		 2894 }
2895 /* Check for command underflow */
2896 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
2897 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n",
2898 byte_count, scsicmd->underflow);
2899 }
2900 }
1da177e4
LT		 2901 return byte_count;
2902}
2903
0e68c003
MH		 2904static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg)
2905{
0e68c003 2906 unsigned long byte_count = 0;
727eead6 2907 int nseg;
0e68c003
MH		 2908
2909 // Get rid of old data
2910 psg->count = 0;
2911 psg->sg[0].next = 0;
2912 psg->sg[0].prev = 0;
2913 psg->sg[0].addr[0] = 0;
2914 psg->sg[0].addr[1] = 0;
2915 psg->sg[0].count = 0;
2916 psg->sg[0].flags = 0;
727eead6
FT		 2917
2918 nseg = scsi_dma_map(scsicmd);
2919 BUG_ON(nseg < 0);
2920 if (nseg) {
0e68c003
MH		 2921 struct scatterlist *sg;
2922 int i;
0e68c003 2923
727eead6 2924 scsi_for_each_sg(scsicmd, sg, nseg, i) {
0e68c003
MH		 2925 int count = sg_dma_len(sg);
2926 u64 addr = sg_dma_address(sg);
2927 psg->sg[i].next = 0;
2928 psg->sg[i].prev = 0;
2929 psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32));
2930 psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
2931 psg->sg[i].count = cpu_to_le32(count);
2932 psg->sg[i].flags = 0;
2933 byte_count += count;
0e68c003 2934 }
727eead6 2935 psg->count = cpu_to_le32(nseg);
0e68c003 2936 /* hba wants the size to be exact */
727eead6
FT		 2937 if (byte_count > scsi_bufflen(scsicmd)) {
2938 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2939 (byte_count - scsi_bufflen(scsicmd));
0e68c003 2940 psg->sg[i-1].count = cpu_to_le32(temp);
727eead6 2941 byte_count = scsi_bufflen(scsicmd);
0e68c003
MH		 2942 }
2943 /* Check for command underflow */
2944 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
2945 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n",
2946 byte_count, scsicmd->underflow);
2947 }
2948 }
0e68c003
MH		 2949 return byte_count;
2950}
2951
1da177e4
LT		 2952#ifdef AAC_DETAILED_STATUS_INFO
2953
2954struct aac_srb_status_info {
2955 u32 status;
2956 char *str;
2957};
2958
2959
2960static struct aac_srb_status_info srb_status_info[] = {
2961 { SRB_STATUS_PENDING, "Pending Status"},
2962 { SRB_STATUS_SUCCESS, "Success"},
2963 { SRB_STATUS_ABORTED, "Aborted Command"},
2964 { SRB_STATUS_ABORT_FAILED, "Abort Failed"},
6391a113 2965 { SRB_STATUS_ERROR, "Error Event"},
1da177e4
LT		 2966 { SRB_STATUS_BUSY, "Device Busy"},
2967 { SRB_STATUS_INVALID_REQUEST, "Invalid Request"},
2968 { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"},
2969 { SRB_STATUS_NO_DEVICE, "No Device"},
2970 { SRB_STATUS_TIMEOUT, "Timeout"},
2971 { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"},
2972 { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"},
2973 { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"},
2974 { SRB_STATUS_BUS_RESET, "Bus Reset"},
2975 { SRB_STATUS_PARITY_ERROR, "Parity Error"},
2976 { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"},
2977 { SRB_STATUS_NO_HBA, "No HBA"},
2978 { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"},
2979 { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"},
2980 { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"},
2981 { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"},
2982 { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"},
2983 { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"},
6391a113 2984 { SRB_STATUS_INVALID_LUN, "Invalid LUN"},
1da177e4
LT		 2985 { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"},
2986 { SRB_STATUS_BAD_FUNCTION, "Bad Function"},
2987 { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"},
2988 { SRB_STATUS_NOT_STARTED, "Not Started"},
2989 { SRB_STATUS_NOT_IN_USE, "Not In Use"},
8ce3eca4 2990 { SRB_STATUS_FORCE_ABORT, "Force Abort"},
1da177e4
LT		 2991 { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"},
2992 { 0xff, "Unknown Error"}
2993};
2994
2995char *aac_get_status_string(u32 status)
2996{
2997 int i;
2998
6391a113
TK		 2999 for (i = 0; i < ARRAY_SIZE(srb_status_info); i++)
3000 if (srb_status_info[i].status == status)
1da177e4 3001 return srb_status_info[i].str;
1da177e4
LT		 3002
3003 return "Bad Status Code";
3004}
3005
3006#endif
Ubuntu Jammy Linux kernel mirror