?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: HDA: Cirrus - fix "Surround Speaker" volume control name
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / aacraid / aachba.c
blob061995741444b379b007886f7fe0bd2acb7b8ac1
1 /*
2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc.
4 *
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
7 *
8 * Copyright (c) 2000-2010 Adaptec, Inc.
9 * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
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>
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>
35 #include <asm/uaccess.h>
36 #include <linux/highmem.h> /* For flush_kernel_dcache_page */
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
56 /*
57 * Sense codes
58 */
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
81
82 /*
83 * Additional sense codes
84 */
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
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 */
117 struct inquiry_data {
118 u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */
119 u8 inqd_dtq; /* RMB | Device Type Qualifier */
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 */
133
134 static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap);
135 static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg);
136 static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg);
137 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd);
138 #ifdef AAC_DETAILED_STATUS_INFO
139 static char *aac_get_status_string(u32 status);
140 #endif
141
142 /*
143 * Non dasd selection is handled entirely in aachba now
144 */
145
146 static int nondasd = -1;
147 static int aac_cache = 2; /* WCE=0 to avoid performance problems */
148 static int dacmode = -1;
149 int aac_msi;
150 int aac_commit = -1;
151 int startup_timeout = 180;
152 int aif_timeout = 120;
153
154 module_param(nondasd, int, S_IRUGO|S_IWUSR);
155 MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices."
156 " 0=off, 1=on");
157 module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR);
158 MODULE_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"
161 "\tbit 2 - Disable only if Battery is protecting Cache");
162 module_param(dacmode, int, S_IRUGO|S_IWUSR);
163 MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC."
164 " 0=off, 1=on");
165 module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR);
166 MODULE_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");
170 module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR);
171 MODULE_PARM_DESC(msi, "IRQ handling."
172 " 0=PIC(default), 1=MSI, 2=MSI-X(unsupported, uses MSI)");
173 module_param(startup_timeout, int, S_IRUGO|S_IWUSR);
174 MODULE_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.");
178 module_param(aif_timeout, int, S_IRUGO|S_IWUSR);
179 MODULE_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.");
183
184 int numacb = -1;
185 module_param(numacb, int, S_IRUGO|S_IWUSR);
186 MODULE_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.");
189
190 int acbsize = -1;
191 module_param(acbsize, int, S_IRUGO|S_IWUSR);
192 MODULE_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.");
195
196 int update_interval = 30 * 60;
197 module_param(update_interval, int, S_IRUGO|S_IWUSR);
198 MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync"
199 " updates issued to adapter.");
200
201 int check_interval = 24 * 60 * 60;
202 module_param(check_interval, int, S_IRUGO|S_IWUSR);
203 MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health"
204 " checks.");
205
206 int aac_check_reset = 1;
207 module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR);
208 MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the"
209 " adapter. a value of -1 forces the reset to adapters programmed to"
210 " ignore it.");
211
212 int expose_physicals = -1;
213 module_param(expose_physicals, int, S_IRUGO|S_IWUSR);
214 MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays."
215 " -1=protect 0=off, 1=on");
216
217 int aac_reset_devices;
218 module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR);
219 MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization.");
220
221 int aac_wwn = 1;
222 module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR);
223 MODULE_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
229 static inline int aac_valid_context(struct scsi_cmnd *scsicmd,
230 struct fib *fibptr) {
231 struct scsi_device *device;
232
233 if (unlikely(!scsicmd || !scsicmd->scsi_done)) {
234 dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n"));
235 aac_fib_complete(fibptr);
236 aac_fib_free(fibptr);
237 return 0;
238 }
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
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 */
256 int aac_get_config_status(struct aac_dev *dev, int commit_flag)
257 {
258 int status = 0;
259 struct fib * fibptr;
260
261 if (!(fibptr = aac_fib_alloc(dev)))
262 return -ENOMEM;
263
264 aac_fib_init(fibptr);
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
274 status = aac_fib_send(ContainerCommand,
275 fibptr,
276 sizeof (struct aac_get_config_status),
277 FsaNormal,
278 1, 1,
279 NULL, NULL);
280 if (status < 0) {
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 }
297 /* Do not set XferState to zero unless receives a response from F/W */
298 if (status >= 0)
299 aac_fib_complete(fibptr);
300
301 /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
302 if (status >= 0) {
303 if ((aac_commit == 1) || commit_flag) {
304 struct aac_commit_config * dinfo;
305 aac_fib_init(fibptr);
306 dinfo = (struct aac_commit_config *) fib_data(fibptr);
307
308 dinfo->command = cpu_to_le32(VM_ContainerConfig);
309 dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG);
310
311 status = aac_fib_send(ContainerCommand,
312 fibptr,
313 sizeof (struct aac_commit_config),
314 FsaNormal,
315 1, 1,
316 NULL, NULL);
317 /* Do not set XferState to zero unless
318 * receives a response from F/W */
319 if (status >= 0)
320 aac_fib_complete(fibptr);
321 } else if (aac_commit == 0) {
322 printk(KERN_WARNING
323 "aac_get_config_status: Foreign device configurations are being ignored\n");
324 }
325 }
326 /* FIB should be freed only after getting the response from the F/W */
327 if (status != -ERESTARTSYS)
328 aac_fib_free(fibptr);
329 return status;
330 }
331
332 static 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
342 /**
343 * aac_get_containers - list containers
344 * @common: adapter to probe
345 *
346 * Make a list of all containers on this controller
347 */
348 int aac_get_containers(struct aac_dev *dev)
349 {
350 struct fsa_dev_info *fsa_dev_ptr;
351 u32 index;
352 int status = 0;
353 struct fib * fibptr;
354 struct aac_get_container_count *dinfo;
355 struct aac_get_container_count_resp *dresp;
356 int maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
357
358 if (!(fibptr = aac_fib_alloc(dev)))
359 return -ENOMEM;
360
361 aac_fib_init(fibptr);
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
366 status = aac_fib_send(ContainerCommand,
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);
375 aac_fib_complete(fibptr);
376 }
377 /* FIB should be freed only after getting the response from the F/W */
378 if (status != -ERESTARTSYS)
379 aac_fib_free(fibptr);
380
381 if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
382 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
383 fsa_dev_ptr = kzalloc(sizeof(*fsa_dev_ptr) * maximum_num_containers,
384 GFP_KERNEL);
385 if (!fsa_dev_ptr)
386 return -ENOMEM;
387
388 dev->fsa_dev = fsa_dev_ptr;
389 dev->maximum_num_containers = maximum_num_containers;
390
391 for (index = 0; index < dev->maximum_num_containers; ) {
392 fsa_dev_ptr[index].devname[0] = '\0';
393
394 status = aac_probe_container(dev, index);
395
396 if (status < 0) {
397 printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n");
398 break;
399 }
400
401 /*
402 * If there are no more containers, then stop asking.
403 */
404 if (++index >= status)
405 break;
406 }
407 return status;
408 }
409
410 static 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
417 if (!aac_valid_context(scsicmd, fibptr))
418 return;
419
420 dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies));
421 BUG_ON(fibptr == NULL);
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')) {
427 char *sp = get_name_reply->data;
428 sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0';
429 while (*sp == ' ')
430 ++sp;
431 if (*sp) {
432 struct inquiry_data inq;
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);
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));
443 }
444 }
445
446 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
447
448 aac_fib_complete(fibptr);
449 aac_fib_free(fibptr);
450 scsicmd->scsi_done(scsicmd);
451 }
452
453 /**
454 * aac_get_container_name - get container name, none blocking.
455 */
456 static int aac_get_container_name(struct scsi_cmnd * scsicmd)
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
465 if (!(cmd_fibcontext = aac_fib_alloc(dev)))
466 return -ENOMEM;
467
468 aac_fib_init(cmd_fibcontext);
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);
473 dinfo->cid = cpu_to_le32(scmd_id(scsicmd));
474 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
475
476 status = aac_fib_send(ContainerCommand,
477 cmd_fibcontext,
478 sizeof (struct aac_get_name),
479 FsaNormal,
480 0, 1,
481 (fib_callback)get_container_name_callback,
482 (void *) scsicmd);
483
484 /*
485 * Check that the command queued to the controller
486 */
487 if (status == -EINPROGRESS) {
488 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
489 return 0;
490 }
491
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);
495 return -1;
496 }
497
498 static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd)
499 {
500 struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev;
501
502 if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1))
503 return aac_scsi_cmd(scsicmd);
504
505 scsicmd->result = DID_NO_CONNECT << 16;
506 scsicmd->scsi_done(scsicmd);
507 return 0;
508 }
509
510 static void _aac_probe_container2(void * context, struct fib * fibptr)
511 {
512 struct fsa_dev_info *fsa_dev_ptr;
513 int (*callback)(struct scsi_cmnd *);
514 struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context;
515
516
517 if (!aac_valid_context(scsicmd, fibptr))
518 return;
519
520 scsicmd->SCp.Status = 0;
521 fsa_dev_ptr = fibptr->dev->fsa_dev;
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;
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;
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;
549 (*callback)(scsicmd);
550 return;
551 }
552
553 static void _aac_probe_container1(void * context, struct fib * fibptr)
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) ||
563 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) {
564 _aac_probe_container2(context, fibptr);
565 return;
566 }
567 scsicmd = (struct scsi_cmnd *) context;
568
569 if (!aac_valid_context(scsicmd, fibptr))
570 return;
571
572 aac_fib_init(fibptr);
573
574 dinfo = (struct aac_query_mount *)fib_data(fibptr);
575
576 dinfo->command = cpu_to_le32(VM_NameServe64);
577 dinfo->count = cpu_to_le32(scmd_id(scsicmd));
578 dinfo->type = cpu_to_le32(FT_FILESYS);
579
580 status = aac_fib_send(ContainerCommand,
581 fibptr,
582 sizeof(struct aac_query_mount),
583 FsaNormal,
584 0, 1,
585 _aac_probe_container2,
586 (void *) scsicmd);
587 /*
588 * Check that the command queued to the controller
589 */
590 if (status == -EINPROGRESS)
591 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
592 else if (status < 0) {
593 /* Inherit results from VM_NameServe, if any */
594 dresp->status = cpu_to_le32(ST_OK);
595 _aac_probe_container2(context, fibptr);
596 }
597 }
598
599 static 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);
610
611 dinfo->command = cpu_to_le32(VM_NameServe);
612 dinfo->count = cpu_to_le32(scmd_id(scsicmd));
613 dinfo->type = cpu_to_le32(FT_FILESYS);
614 scsicmd->SCp.ptr = (char *)callback;
615
616 status = aac_fib_send(ContainerCommand,
617 fibptr,
618 sizeof(struct aac_query_mount),
619 FsaNormal,
620 0, 1,
621 _aac_probe_container1,
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 }
645 }
646 return status;
647 }
648
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 */
657 static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd)
658 {
659 scsicmd->device = NULL;
660 return 0;
661 }
662
663 int 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;
675 scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1;
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();
685 kfree(scsidev);
686 status = scsicmd->SCp.Status;
687 kfree(scsicmd);
688 return status;
689 }
690
691 /* Local Structure to set SCSI inquiry data strings */
692 struct 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 *
703 * Copy a String from one location to another
704 * without copying \0
705 */
706
707 static void inqstrcpy(char *a, char *b)
708 {
709
710 while (*a != (char)0)
711 *b++ = *a++;
712 }
713
714 static char *container_types[] = {
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",
729 "RAID50",
730 "RAID5D",
731 "RAID5D0",
732 "RAID1E",
733 "RAID6",
734 "RAID60",
735 "Unknown"
736 };
737
738 char * 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 }
744
745 /* Function: setinqstr
746 *
747 * Arguments: [1] pointer to void [1] int
748 *
749 * Purpose: Sets SCSI inquiry data strings for vendor, product
750 * and revision level. Allows strings to be set in platform dependent
751 * files instead of in OS dependent driver source.
752 */
753
754 static void setinqstr(struct aac_dev *dev, void *data, int tindex)
755 {
756 struct scsi_inq *str;
757
758 str = (struct scsi_inq *)(data); /* cast data to scsi inq block */
759 memset(str, ' ', sizeof(*str));
760
761 if (dev->supplement_adapter_info.AdapterTypeText[0]) {
762 char * cp = dev->supplement_adapter_info.AdapterTypeText;
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 }
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);
791
792 inqstrcpy (mp->vname, str->vid);
793 /* last six chars reserved for vol type */
794 inqstrcpy (mp->model, str->pid);
795 }
796
797 if (tindex < ARRAY_SIZE(container_types)){
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) = ' ';
804 if (((findit - str->pid) + strlen(container_types[tindex]))
805 < (sizeof(str->pid) + sizeof(str->prl)))
806 inqstrcpy (container_types[tindex], findit + 1);
807 }
808 inqstrcpy ("V1.0", str->prl);
809 }
810
811 static 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));
832 scsi_sg_copy_from_buffer(scsicmd, sp, sizeof(sp));
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 */
845 static 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
897 static 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
906 static 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)
908 {
909 u8 *sense_buf = (u8 *)sense_data;
910 /* Sense data valid, err code 70h */
911 sense_buf[0] = 0x70; /* No info field */
912 sense_buf[1] = 0; /* Segment number, always zero */
913
914 sense_buf[2] = sense_key; /* Sense key */
915
916 sense_buf[12] = sense_code; /* Additional sense code */
917 sense_buf[13] = a_sense_code; /* Additional sense code qualifier */
918
919 if (sense_key == ILLEGAL_REQUEST) {
920 sense_buf[7] = 10; /* Additional sense length */
921
922 sense_buf[15] = bit_pointer;
923 /* Illegal parameter is in the parameter block */
924 if (sense_code == SENCODE_INVALID_CDB_FIELD)
925 sense_buf[15] |= 0xc0;/* Std sense key specific field */
926 /* Illegal parameter is in the CDB block */
927 sense_buf[16] = field_pointer >> 8; /* MSB */
928 sense_buf[17] = field_pointer; /* LSB */
929 } else
930 sense_buf[7] = 6; /* Additional sense length */
931 }
932
933 static 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;
940 set_sense(&dev->fsa_dev[cid].sense_data,
941 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
942 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
943 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
944 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
945 SCSI_SENSE_BUFFERSIZE));
946 cmd->scsi_done(cmd);
947 return 1;
948 }
949 return 0;
950 }
951
952 static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba)
953 {
954 return 0;
955 }
956
957 static void io_callback(void *context, struct fib * fibptr);
958
959 static 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));
969 readcmd->flags = cpu_to_le16(IO_TYPE_READ);
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
988 static 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
1019 static 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);
1026 readcmd->cid = cpu_to_le32(scmd_id(cmd));
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
1048 static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
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));
1058 writecmd->flags = (fua && ((aac_cache & 5) != 1) &&
1059 (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ?
1060 cpu_to_le16(IO_TYPE_WRITE|IO_SUREWRITE) :
1061 cpu_to_le16(IO_TYPE_WRITE);
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
1080 static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
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
1111 static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua)
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);
1118 writecmd->cid = cpu_to_le32(scmd_id(cmd));
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
1142 static 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);
1171 timeout = cmd->request->timeout/HZ;
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
1180 static void aac_srb_callback(void *context, struct fib * fibptr);
1181
1182 static 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);
1188 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd));
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
1210 static 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);
1216 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd));
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
1236 static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd)
1237 {
1238 if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac &&
1239 (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64))
1240 return FAILED;
1241 return aac_scsi_32(fib, cmd);
1242 }
1243
1244 int aac_get_adapter_info(struct aac_dev* dev)
1245 {
1246 struct fib* fibptr;
1247 int rcode;
1248 u32 tmp;
1249 struct aac_adapter_info *info;
1250 struct aac_bus_info *command;
1251 struct aac_bus_info_response *bus_info;
1252
1253 if (!(fibptr = aac_fib_alloc(dev)))
1254 return -ENOMEM;
1255
1256 aac_fib_init(fibptr);
1257 info = (struct aac_adapter_info *) fib_data(fibptr);
1258 memset(info,0,sizeof(*info));
1259
1260 rcode = aac_fib_send(RequestAdapterInfo,
1261 fibptr,
1262 sizeof(*info),
1263 FsaNormal,
1264 -1, 1, /* First `interrupt' command uses special wait */
1265 NULL,
1266 NULL);
1267
1268 if (rcode < 0) {
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 }
1275 return rcode;
1276 }
1277 memcpy(&dev->adapter_info, info, sizeof(*info));
1278
1279 if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) {
1280 struct aac_supplement_adapter_info * sinfo;
1281
1282 aac_fib_init(fibptr);
1283
1284 sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr);
1285
1286 memset(sinfo,0,sizeof(*sinfo));
1287
1288 rcode = aac_fib_send(RequestSupplementAdapterInfo,
1289 fibptr,
1290 sizeof(*sinfo),
1291 FsaNormal,
1292 1, 1,
1293 NULL,
1294 NULL);
1295
1296 if (rcode >= 0)
1297 memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
1298 if (rcode == -ERESTARTSYS) {
1299 fibptr = aac_fib_alloc(dev);
1300 if (!fibptr)
1301 return -ENOMEM;
1302 }
1303
1304 }
1305
1306
1307 /*
1308 * GetBusInfo
1309 */
1310
1311 aac_fib_init(fibptr);
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
1324 rcode = aac_fib_send(ContainerCommand,
1325 fibptr,
1326 sizeof (*bus_info),
1327 FsaNormal,
1328 1, 1,
1329 NULL, NULL);
1330
1331 /* reasoned default */
1332 dev->maximum_num_physicals = 16;
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
1338 if (!dev->in_reset) {
1339 char buffer[16];
1340 tmp = le32_to_cpu(dev->adapter_info.kernelrev);
1341 printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n",
1342 dev->name,
1343 dev->id,
1344 tmp>>24,
1345 (tmp>>16)&0xff,
1346 tmp&0xff,
1347 le32_to_cpu(dev->adapter_info.kernelbuild),
1348 (int)sizeof(dev->supplement_adapter_info.BuildDate),
1349 dev->supplement_adapter_info.BuildDate);
1350 tmp = le32_to_cpu(dev->adapter_info.monitorrev);
1351 printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n",
1352 dev->name, dev->id,
1353 tmp>>24,(tmp>>16)&0xff,tmp&0xff,
1354 le32_to_cpu(dev->adapter_info.monitorbuild));
1355 tmp = le32_to_cpu(dev->adapter_info.biosrev);
1356 printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n",
1357 dev->name, dev->id,
1358 tmp>>24,(tmp>>16)&0xff,tmp&0xff,
1359 le32_to_cpu(dev->adapter_info.biosbuild));
1360 buffer[0] = '\0';
1361 if (aac_get_serial_number(
1362 shost_to_class(dev->scsi_host_ptr), buffer))
1363 printk(KERN_INFO "%s%d: serial %s",
1364 dev->name, dev->id, buffer);
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 }
1371 if (!aac_check_reset || ((aac_check_reset == 1) &&
1372 (dev->supplement_adapter_info.SupportedOptions2 &
1373 AAC_OPTION_IGNORE_RESET))) {
1374 printk(KERN_INFO "%s%d: Reset Adapter Ignored\n",
1375 dev->name, dev->id);
1376 }
1377 }
1378
1379 dev->cache_protected = 0;
1380 dev->jbod = ((dev->supplement_adapter_info.FeatureBits &
1381 AAC_FEATURE_JBOD) != 0);
1382 dev->nondasd_support = 0;
1383 dev->raid_scsi_mode = 0;
1384 if(dev->adapter_info.options & AAC_OPT_NONDASD)
1385 dev->nondasd_support = 1;
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);
1406
1407 if (nondasd != -1)
1408 dev->nondasd_support = (nondasd!=0);
1409 if (dev->nondasd_support && !dev->in_reset)
1410 printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id);
1411
1412 if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32))
1413 dev->needs_dac = 1;
1414 dev->dac_support = 0;
1415 if ((sizeof(dma_addr_t) > 4) && dev->needs_dac &&
1416 (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) {
1417 if (!dev->in_reset)
1418 printk(KERN_INFO "%s%d: 64bit support enabled.\n",
1419 dev->name, dev->id);
1420 dev->dac_support = 1;
1421 }
1422
1423 if(dacmode != -1) {
1424 dev->dac_support = (dacmode!=0);
1425 }
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
1435 if(dev->dac_support != 0) {
1436 if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) &&
1437 !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) {
1438 if (!dev->in_reset)
1439 printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n",
1440 dev->name, dev->id);
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))) {
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 }
1452 /*
1453 * Deal with configuring for the individualized limits of each packet
1454 * interface.
1455 */
1456 dev->a_ops.adapter_scsi = (dev->dac_support)
1457 ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32)
1458 ? aac_scsi_32_64
1459 : aac_scsi_64)
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;
1469 dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size -
1470 sizeof(struct aac_fibhdr) -
1471 sizeof(struct aac_write) + sizeof(struct sgentry)) /
1472 sizeof(struct sgentry);
1473 if (dev->dac_support) {
1474 dev->a_ops.adapter_read = aac_read_block64;
1475 dev->a_ops.adapter_write = aac_write_block64;
1476 /*
1477 * 38 scatter gather elements
1478 */
1479 dev->scsi_host_ptr->sg_tablesize =
1480 (dev->max_fib_size -
1481 sizeof(struct aac_fibhdr) -
1482 sizeof(struct aac_write64) +
1483 sizeof(struct sgentry64)) /
1484 sizeof(struct sgentry64);
1485 } else {
1486 dev->a_ops.adapter_read = aac_read_block;
1487 dev->a_ops.adapter_write = aac_write_block;
1488 }
1489 dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT;
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)) {
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 }
1505 }
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 }
1511
1512 return rcode;
1513 }
1514
1515
1516 static void io_callback(void *context, struct fib * fibptr)
1517 {
1518 struct aac_dev *dev;
1519 struct aac_read_reply *readreply;
1520 struct scsi_cmnd *scsicmd;
1521 u32 cid;
1522
1523 scsicmd = (struct scsi_cmnd *) context;
1524
1525 if (!aac_valid_context(scsicmd, fibptr))
1526 return;
1527
1528 dev = fibptr->dev;
1529 cid = scmd_id(scsicmd);
1530
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 }
1565
1566 BUG_ON(fibptr == NULL);
1567
1568 scsi_dma_unmap(scsicmd);
1569
1570 readreply = (struct aac_read_reply *)fib_data(fibptr);
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:
1587 #ifdef AAC_DETAILED_STATUS_INFO
1588 printk(KERN_WARNING "io_callback: io failed, status = %d\n",
1589 le32_to_cpu(readreply->status));
1590 #endif
1591 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
1592 SAM_STAT_CHECK_CONDITION;
1593 set_sense(&dev->fsa_dev[cid].sense_data,
1594 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1595 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1596 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
1597 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1598 SCSI_SENSE_BUFFERSIZE));
1599 break;
1600 }
1601 aac_fib_complete(fibptr);
1602 aac_fib_free(fibptr);
1603
1604 scsicmd->scsi_done(scsicmd);
1605 }
1606
1607 static int aac_read(struct scsi_cmnd * scsicmd)
1608 {
1609 u64 lba;
1610 u32 count;
1611 int status;
1612 struct aac_dev *dev;
1613 struct fib * cmd_fibcontext;
1614 int cid;
1615
1616 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
1617 /*
1618 * Get block address and transfer length
1619 */
1620 switch (scsicmd->cmnd[0]) {
1621 case READ_6:
1622 dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd)));
1623
1624 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) |
1625 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
1626 count = scsicmd->cmnd[4];
1627
1628 if (count == 0)
1629 count = 256;
1630 break;
1631 case READ_16:
1632 dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd)));
1633
1634 lba = ((u64)scsicmd->cmnd[2] << 56) |
1635 ((u64)scsicmd->cmnd[3] << 48) |
1636 ((u64)scsicmd->cmnd[4] << 40) |
1637 ((u64)scsicmd->cmnd[5] << 32) |
1638 ((u64)scsicmd->cmnd[6] << 24) |
1639 (scsicmd->cmnd[7] << 16) |
1640 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
1641 count = (scsicmd->cmnd[10] << 24) |
1642 (scsicmd->cmnd[11] << 16) |
1643 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
1644 break;
1645 case READ_12:
1646 dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd)));
1647
1648 lba = ((u64)scsicmd->cmnd[2] << 24) |
1649 (scsicmd->cmnd[3] << 16) |
1650 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1651 count = (scsicmd->cmnd[6] << 24) |
1652 (scsicmd->cmnd[7] << 16) |
1653 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
1654 break;
1655 default:
1656 dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd)));
1657
1658 lba = ((u64)scsicmd->cmnd[2] << 24) |
1659 (scsicmd->cmnd[3] << 16) |
1660 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1661 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
1662 break;
1663 }
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
1680 dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n",
1681 smp_processor_id(), (unsigned long long)lba, jiffies));
1682 if (aac_adapter_bounds(dev,scsicmd,lba))
1683 return 0;
1684 /*
1685 * Alocate and initialize a Fib
1686 */
1687 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
1688 printk(KERN_WARNING "aac_read: fib allocation failed\n");
1689 return -1;
1690 }
1691
1692 status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count);
1693
1694 /*
1695 * Check that the command queued to the controller
1696 */
1697 if (status == -EINPROGRESS) {
1698 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1699 return 0;
1700 }
1701
1702 printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status);
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;
1707 scsicmd->scsi_done(scsicmd);
1708 aac_fib_complete(cmd_fibcontext);
1709 aac_fib_free(cmd_fibcontext);
1710 return 0;
1711 }
1712
1713 static int aac_write(struct scsi_cmnd * scsicmd)
1714 {
1715 u64 lba;
1716 u32 count;
1717 int fua;
1718 int status;
1719 struct aac_dev *dev;
1720 struct fib * cmd_fibcontext;
1721 int cid;
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;
1733 fua = 0;
1734 } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */
1735 dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd)));
1736
1737 lba = ((u64)scsicmd->cmnd[2] << 56) |
1738 ((u64)scsicmd->cmnd[3] << 48) |
1739 ((u64)scsicmd->cmnd[4] << 40) |
1740 ((u64)scsicmd->cmnd[5] << 32) |
1741 ((u64)scsicmd->cmnd[6] << 24) |
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];
1746 fua = scsicmd->cmnd[1] & 0x8;
1747 } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */
1748 dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd)));
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];
1754 fua = scsicmd->cmnd[1] & 0x8;
1755 } else {
1756 dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd)));
1757 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
1758 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
1759 fua = scsicmd->cmnd[1] & 0x8;
1760 }
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
1777 dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n",
1778 smp_processor_id(), (unsigned long long)lba, jiffies));
1779 if (aac_adapter_bounds(dev,scsicmd,lba))
1780 return 0;
1781 /*
1782 * Allocate and initialize a Fib then setup a BlockWrite command
1783 */
1784 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
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;
1793 }
1794
1795 status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
1796
1797 /*
1798 * Check that the command queued to the controller
1799 */
1800 if (status == -EINPROGRESS) {
1801 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1802 return 0;
1803 }
1804
1805 printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status);
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;
1810 scsicmd->scsi_done(scsicmd);
1811
1812 aac_fib_complete(cmd_fibcontext);
1813 aac_fib_free(cmd_fibcontext);
1814 return 0;
1815 }
1816
1817 static 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
1824 if (!aac_valid_context(cmd, fibptr))
1825 return;
1826
1827 dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n",
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)
1834 cmd->result = DID_OK << 16 |
1835 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
1836 else {
1837 struct scsi_device *sdev = cmd->device;
1838 struct aac_dev *dev = fibptr->dev;
1839 u32 cid = sdev_id(sdev);
1840 printk(KERN_WARNING
1841 "synchronize_callback: synchronize failed, status = %d\n",
1842 le32_to_cpu(synchronizereply->status));
1843 cmd->result = DID_OK << 16 |
1844 COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
1845 set_sense(&dev->fsa_dev[cid].sense_data,
1846 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE,
1847 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0);
1848 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
1849 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
1850 SCSI_SENSE_BUFFERSIZE));
1851 }
1852
1853 aac_fib_complete(fibptr);
1854 aac_fib_free(fibptr);
1855 cmd->scsi_done(cmd);
1856 }
1857
1858 static int aac_synchronize(struct scsi_cmnd *scsicmd)
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;
1866 struct aac_dev *aac;
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];
1870 unsigned long flags;
1871
1872 /*
1873 * Wait for all outstanding queued commands to complete to this
1874 * specific target (block).
1875 */
1876 spin_lock_irqsave(&sdev->list_lock, flags);
1877 list_for_each_entry(cmd, &sdev->cmd_list, list)
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;
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
1935 aac = (struct aac_dev *)sdev->host->hostdata;
1936 if (aac->in_reset)
1937 return SCSI_MLQUEUE_HOST_BUSY;
1938
1939 /*
1940 * Allocate and initialize a Fib
1941 */
1942 if (!(cmd_fibcontext = aac_fib_alloc(aac)))
1943 return SCSI_MLQUEUE_HOST_BUSY;
1944
1945 aac_fib_init(cmd_fibcontext);
1946
1947 synchronizecmd = fib_data(cmd_fibcontext);
1948 synchronizecmd->command = cpu_to_le32(VM_ContainerConfig);
1949 synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE);
1950 synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd));
1951 synchronizecmd->count =
1952 cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
1953
1954 /*
1955 * Now send the Fib to the adapter
1956 */
1957 status = aac_fib_send(ContainerCommand,
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 */
1968 if (status == -EINPROGRESS) {
1969 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
1970 return 0;
1971 }
1972
1973 printk(KERN_WARNING
1974 "aac_synchronize: aac_fib_send failed with status: %d.\n", status);
1975 aac_fib_complete(cmd_fibcontext);
1976 aac_fib_free(cmd_fibcontext);
1977 return SCSI_MLQUEUE_HOST_BUSY;
1978 }
1979
1980 static 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
1996 static 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
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 */
2065
2066 int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
2067 {
2068 u32 cid;
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;
2072
2073 if (fsa_dev_ptr == NULL)
2074 return -1;
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 */
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) ||
2084 (scsicmd->device->lun != 0)) {
2085 scsicmd->result = DID_NO_CONNECT << 16;
2086 scsicmd->scsi_done(scsicmd);
2087 return 0;
2088 }
2089
2090 /*
2091 * If the target container doesn't exist, it may have
2092 * been newly created
2093 */
2094 if (((fsa_dev_ptr[cid].valid & 1) == 0) ||
2095 (fsa_dev_ptr[cid].sense_data.sense_key ==
2096 NOT_READY)) {
2097 switch (scsicmd->cmnd[0]) {
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;
2103 case INQUIRY:
2104 case READ_CAPACITY:
2105 case TEST_UNIT_READY:
2106 if (dev->in_reset)
2107 return -1;
2108 return _aac_probe_container(scsicmd,
2109 aac_probe_container_callback2);
2110 default:
2111 break;
2112 }
2113 }
2114 } else { /* check for physical non-dasd devices */
2115 if (dev->nondasd_support || expose_physicals ||
2116 dev->jbod) {
2117 if (dev->in_reset)
2118 return -1;
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 */
2131 (scsicmd->cmnd[0] != TEST_UNIT_READY))
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;
2135 set_sense(&dev->fsa_dev[cid].sense_data,
2136 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND,
2137 ASENCODE_INVALID_COMMAND, 0, 0);
2138 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
2139 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data),
2140 SCSI_SENSE_BUFFERSIZE));
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 {
2150 struct inquiry_data inq_data;
2151
2152 dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid));
2153 memset(&inq_data, 0, sizeof (struct inquiry_data));
2154
2155 if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) {
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];
2167 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2168 sizeof(inq_data));
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];
2176 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2177 sizeof(inq_data));
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;
2184 } else {
2185 /* vpd page not implemented */
2186 scsicmd->result = DID_OK << 16 |
2187 COMMAND_COMPLETE << 8 |
2188 SAM_STAT_CHECK_CONDITION;
2189 set_sense(&dev->fsa_dev[cid].sense_data,
2190 ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD,
2191 ASENCODE_NO_SENSE, 7, 2);
2192 memcpy(scsicmd->sense_buffer,
2193 &dev->fsa_dev[cid].sense_data,
2194 min_t(size_t,
2195 sizeof(dev->fsa_dev[cid].sense_data),
2196 SCSI_SENSE_BUFFERSIZE));
2197 }
2198 scsicmd->scsi_done(scsicmd);
2199 return 0;
2200 }
2201 inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */
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;
2204 /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */
2205 inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */
2206 /*
2207 * Set the Vendor, Product, and Revision Level
2208 * see: <vendor>.c i.e. aac.c
2209 */
2210 if (cid == host->this_id) {
2211 setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types));
2212 inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */
2213 scsi_sg_copy_from_buffer(scsicmd, &inq_data,
2214 sizeof(inq_data));
2215 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2216 scsicmd->scsi_done(scsicmd);
2217 return 0;
2218 }
2219 if (dev->in_reset)
2220 return -1;
2221 setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type);
2222 inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */
2223 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data));
2224 return aac_get_container_name(scsicmd);
2225 }
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;
2233 char cp[13];
2234 unsigned int alloc_len;
2235
2236 dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n"));
2237 capacity = fsa_dev_ptr[cid].size - 1;
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;
2250 cp[12] = 0;
2251
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));
2257 scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len);
2258 if (alloc_len < scsi_bufflen(scsicmd))
2259 scsi_set_resid(scsicmd,
2260 scsi_bufflen(scsicmd) - alloc_len);
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
2271 case READ_CAPACITY:
2272 {
2273 u32 capacity;
2274 char cp[8];
2275
2276 dprintk((KERN_DEBUG "READ CAPACITY command.\n"));
2277 if (fsa_dev_ptr[cid].size <= 0x100000000ULL)
2278 capacity = fsa_dev_ptr[cid].size - 1;
2279 else
2280 capacity = (u32)-1;
2281
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;
2290 scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp));
2291 /* Do not cache partition table for arrays */
2292 scsicmd->device->removable = 1;
2293 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 |
2294 SAM_STAT_GOOD;
2295 scsicmd->scsi_done(scsicmd);
2296
2297 return 0;
2298 }
2299
2300 case MODE_SENSE:
2301 {
2302 char mode_buf[7];
2303 int mode_buf_length = 4;
2304
2305 dprintk((KERN_DEBUG "MODE SENSE command.\n"));
2306 mode_buf[0] = 3; /* Mode data length */
2307 mode_buf[1] = 0; /* Medium type - default */
2308 mode_buf[2] = 0; /* Device-specific param,
2309 bit 8: 0/1 = write enabled/protected
2310 bit 4: 0/1 = FUA enabled */
2311 if (dev->raw_io_interface && ((aac_cache & 5) != 1))
2312 mode_buf[2] = 0x10;
2313 mode_buf[3] = 0; /* Block descriptor length */
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;
2319 mode_buf[6] = ((aac_cache & 6) == 2)
2320 ? 0 : 0x04; /* WCE */
2321 mode_buf_length = 7;
2322 if (mode_buf_length > scsicmd->cmnd[4])
2323 mode_buf_length = scsicmd->cmnd[4];
2324 }
2325 scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length);
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 {
2333 char mode_buf[11];
2334 int mode_buf_length = 8;
2335
2336 dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n"));
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 */
2340 mode_buf[3] = 0; /* Device-specific param,
2341 bit 8: 0/1 = write enabled/protected
2342 bit 4: 0/1 = FUA enabled */
2343 if (dev->raw_io_interface && ((aac_cache & 5) != 1))
2344 mode_buf[3] = 0x10;
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) */
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;
2354 mode_buf[10] = ((aac_cache & 6) == 2)
2355 ? 0 : 0x04; /* WCE */
2356 mode_buf_length = 11;
2357 if (mode_buf_length > scsicmd->cmnd[8])
2358 mode_buf_length = scsicmd->cmnd[8];
2359 }
2360 scsi_sg_copy_from_buffer(scsicmd, mode_buf, mode_buf_length);
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:
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 */
2404 case RESERVE:
2405 case RELEASE:
2406 case REZERO_UNIT:
2407 case REASSIGN_BLOCKS:
2408 case SEEK_10:
2409 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
2410 scsicmd->scsi_done(scsicmd);
2411 return 0;
2412
2413 case START_STOP:
2414 return aac_start_stop(scsicmd);
2415 }
2416
2417 switch (scsicmd->cmnd[0])
2418 {
2419 case READ_6:
2420 case READ_10:
2421 case READ_12:
2422 case READ_16:
2423 if (dev->in_reset)
2424 return -1;
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 */
2430
2431 if (scsicmd->request->rq_disk)
2432 strlcpy(fsa_dev_ptr[cid].devname,
2433 scsicmd->request->rq_disk->disk_name,
2434 min(sizeof(fsa_dev_ptr[cid].devname),
2435 sizeof(scsicmd->request->rq_disk->disk_name) + 1));
2436
2437 return aac_read(scsicmd);
2438
2439 case WRITE_6:
2440 case WRITE_10:
2441 case WRITE_12:
2442 case WRITE_16:
2443 if (dev->in_reset)
2444 return -1;
2445 return aac_write(scsicmd);
2446
2447 case SYNCHRONIZE_CACHE:
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 }
2454 /* Issue FIB to tell Firmware to flush it's cache */
2455 if ((aac_cache & 6) != 2)
2456 return aac_synchronize(scsicmd);
2457 /* FALLTHRU */
2458 default:
2459 /*
2460 * Unhandled commands
2461 */
2462 dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0]));
2463 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
2464 set_sense(&dev->fsa_dev[cid].sense_data,
2465 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND,
2466 ASENCODE_INVALID_COMMAND, 0, 0);
2467 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
2468 min_t(size_t,
2469 sizeof(dev->fsa_dev[cid].sense_data),
2470 SCSI_SENSE_BUFFERSIZE));
2471 scsicmd->scsi_done(scsicmd);
2472 return 0;
2473 }
2474 }
2475
2476 static 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;
2482 if (!fsa_dev_ptr)
2483 return -EBUSY;
2484 if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk)))
2485 return -EFAULT;
2486 if (qd.cnum == -1)
2487 qd.cnum = qd.id;
2488 else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1))
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
2499 qd.valid = fsa_dev_ptr[qd.cnum].valid != 0;
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
2516 static 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;
2522 if (!fsa_dev_ptr)
2523 return -EBUSY;
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
2541 static 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;
2547 if (!fsa_dev_ptr)
2548 return -EBUSY;
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
2570 int 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
2596 static 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;
2603
2604 if (!aac_valid_context(scsicmd, fibptr))
2605 return;
2606
2607 BUG_ON(fibptr == NULL);
2608
2609 dev = fibptr->dev;
2610
2611 srbreply = (struct aac_srb_reply *) fib_data(fibptr);
2612
2613 scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */
2614 /*
2615 * Calculate resid for sg
2616 */
2617
2618 scsi_set_resid(scsicmd, scsi_bufflen(scsicmd)
2619 - le32_to_cpu(srbreply->data_xfer_length));
2620
2621 scsi_dma_unmap(scsicmd);
2622
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
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));
2635 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
2636 SCSI_SENSE_BUFFERSIZE);
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:
2648 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
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:
2658 case READ_16:
2659 case WRITE_16:
2660 if (le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow) {
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: {
2668 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
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:
2700 scsicmd->result = DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8;
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(
2729 le32_to_cpu(srbreply->srb_status) & 0x3F),
2730 scsicmd->cmnd[0],
2731 le32_to_cpu(srbreply->scsi_status));
2732 #endif
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 }
2749 }
2750 if (le32_to_cpu(srbreply->scsi_status) == SAM_STAT_CHECK_CONDITION) {
2751 int len;
2752 scsicmd->result |= SAM_STAT_CHECK_CONDITION;
2753 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size),
2754 SCSI_SENSE_BUFFERSIZE);
2755 #ifdef AAC_DETAILED_STATUS_INFO
2756 printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n",
2757 le32_to_cpu(srbreply->status), len);
2758 #endif
2759 memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
2760 }
2761 /*
2762 * OR in the scsi status (already shifted up a bit)
2763 */
2764 scsicmd->result |= le32_to_cpu(srbreply->scsi_status);
2765
2766 aac_fib_complete(fibptr);
2767 aac_fib_free(fibptr);
2768 scsicmd->scsi_done(scsicmd);
2769 }
2770
2771 /**
2772 *
2773 * aac_send_scb_fib
2774 * @scsicmd: the scsi command block
2775 *
2776 * This routine will form a FIB and fill in the aac_srb from the
2777 * scsicmd passed in.
2778 */
2779
2780 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd)
2781 {
2782 struct fib* cmd_fibcontext;
2783 struct aac_dev* dev;
2784 int status;
2785
2786 dev = (struct aac_dev *)scsicmd->device->host->hostdata;
2787 if (scmd_id(scsicmd) >= dev->maximum_num_physicals ||
2788 scsicmd->device->lun > 7) {
2789 scsicmd->result = DID_NO_CONNECT << 16;
2790 scsicmd->scsi_done(scsicmd);
2791 return 0;
2792 }
2793
2794 /*
2795 * Allocate and initialize a Fib then setup a BlockWrite command
2796 */
2797 if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
2798 return -1;
2799 }
2800 status = aac_adapter_scsi(cmd_fibcontext, scsicmd);
2801
2802 /*
2803 * Check that the command queued to the controller
2804 */
2805 if (status == -EINPROGRESS) {
2806 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE;
2807 return 0;
2808 }
2809
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);
2813
2814 return -1;
2815 }
2816
2817 static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg)
2818 {
2819 struct aac_dev *dev;
2820 unsigned long byte_count = 0;
2821 int nseg;
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;
2827 psg->sg[0].count = 0;
2828
2829 nseg = scsi_dma_map(scsicmd);
2830 BUG_ON(nseg < 0);
2831 if (nseg) {
2832 struct scatterlist *sg;
2833 int i;
2834
2835 psg->count = cpu_to_le32(nseg);
2836
2837 scsi_for_each_sg(scsicmd, sg, nseg, i) {
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);
2841 }
2842 /* hba wants the size to be exact */
2843 if (byte_count > scsi_bufflen(scsicmd)) {
2844 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2845 (byte_count - scsi_bufflen(scsicmd));
2846 psg->sg[i-1].count = cpu_to_le32(temp);
2847 byte_count = scsi_bufflen(scsicmd);
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 }
2855 return byte_count;
2856 }
2857
2858
2859 static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg)
2860 {
2861 struct aac_dev *dev;
2862 unsigned long byte_count = 0;
2863 u64 addr;
2864 int nseg;
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;
2872
2873 nseg = scsi_dma_map(scsicmd);
2874 BUG_ON(nseg < 0);
2875 if (nseg) {
2876 struct scatterlist *sg;
2877 int i;
2878
2879 scsi_for_each_sg(scsicmd, sg, nseg, i) {
2880 int count = sg_dma_len(sg);
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);
2884 psg->sg[i].count = cpu_to_le32(count);
2885 byte_count += count;
2886 }
2887 psg->count = cpu_to_le32(nseg);
2888 /* hba wants the size to be exact */
2889 if (byte_count > scsi_bufflen(scsicmd)) {
2890 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2891 (byte_count - scsi_bufflen(scsicmd));
2892 psg->sg[i-1].count = cpu_to_le32(temp);
2893 byte_count = scsi_bufflen(scsicmd);
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 }
2901 return byte_count;
2902 }
2903
2904 static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg)
2905 {
2906 unsigned long byte_count = 0;
2907 int nseg;
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;
2917
2918 nseg = scsi_dma_map(scsicmd);
2919 BUG_ON(nseg < 0);
2920 if (nseg) {
2921 struct scatterlist *sg;
2922 int i;
2923
2924 scsi_for_each_sg(scsicmd, sg, nseg, i) {
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;
2934 }
2935 psg->count = cpu_to_le32(nseg);
2936 /* hba wants the size to be exact */
2937 if (byte_count > scsi_bufflen(scsicmd)) {
2938 u32 temp = le32_to_cpu(psg->sg[i-1].count) -
2939 (byte_count - scsi_bufflen(scsicmd));
2940 psg->sg[i-1].count = cpu_to_le32(temp);
2941 byte_count = scsi_bufflen(scsicmd);
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 }
2949 return byte_count;
2950 }
2951
2952 #ifdef AAC_DETAILED_STATUS_INFO
2953
2954 struct aac_srb_status_info {
2955 u32 status;
2956 char *str;
2957 };
2958
2959
2960 static 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"},
2965 { SRB_STATUS_ERROR, "Error Event"},
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"},
2984 { SRB_STATUS_INVALID_LUN, "Invalid LUN"},
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"},
2990 { SRB_STATUS_FORCE_ABORT, "Force Abort"},
2991 { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"},
2992 { 0xff, "Unknown Error"}
2993 };
2994
2995 char *aac_get_status_string(u32 status)
2996 {
2997 int i;
2998
2999 for (i = 0; i < ARRAY_SIZE(srb_status_info); i++)
3000 if (srb_status_info[i].status == status)
3001 return srb_status_info[i].str;
3002
3003 return "Bad Status Code";
3004 }
3005
3006 #endif
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree