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