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-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) 10 * 2016-2017 Microsemi Corp. (aacraid@microsemi.com) 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2, or (at your option) 15 * any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; see the file COPYING. If not, write to 24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 25 * 26 * Module Name: 27 * aachba.c 28 * 29 * Abstract: Contains Interfaces to manage IOs. 30 * 31 */ 32 33 #include <linux/kernel.h> 34 #include <linux/init.h> 35 #include <linux/types.h> 36 #include <linux/pci.h> 37 #include <linux/spinlock.h> 38 #include <linux/slab.h> 39 #include <linux/completion.h> 40 #include <linux/blkdev.h> 41 #include <linux/uaccess.h> 42 #include <linux/highmem.h> /* For flush_kernel_dcache_page */ 43 #include <linux/module.h> 44 45 #include <scsi/scsi.h> 46 #include <scsi/scsi_cmnd.h> 47 #include <scsi/scsi_device.h> 48 #include <scsi/scsi_host.h> 49 50 #include "aacraid.h" 51 52 /* values for inqd_pdt: Peripheral device type in plain English */ 53 #define INQD_PDT_DA 0x00 /* Direct-access (DISK) device */ 54 #define INQD_PDT_PROC 0x03 /* Processor device */ 55 #define INQD_PDT_CHNGR 0x08 /* Changer (jukebox, scsi2) */ 56 #define INQD_PDT_COMM 0x09 /* Communication device (scsi2) */ 57 #define INQD_PDT_NOLUN2 0x1f /* Unknown Device (scsi2) */ 58 #define INQD_PDT_NOLUN 0x7f /* Logical Unit Not Present */ 59 60 #define INQD_PDT_DMASK 0x1F /* Peripheral Device Type Mask */ 61 #define INQD_PDT_QMASK 0xE0 /* Peripheral Device Qualifer Mask */ 62 63 /* 64 * Sense codes 65 */ 66 67 #define SENCODE_NO_SENSE 0x00 68 #define SENCODE_END_OF_DATA 0x00 69 #define SENCODE_BECOMING_READY 0x04 70 #define SENCODE_INIT_CMD_REQUIRED 0x04 71 #define SENCODE_UNRECOVERED_READ_ERROR 0x11 72 #define SENCODE_PARAM_LIST_LENGTH_ERROR 0x1A 73 #define SENCODE_INVALID_COMMAND 0x20 74 #define SENCODE_LBA_OUT_OF_RANGE 0x21 75 #define SENCODE_INVALID_CDB_FIELD 0x24 76 #define SENCODE_LUN_NOT_SUPPORTED 0x25 77 #define SENCODE_INVALID_PARAM_FIELD 0x26 78 #define SENCODE_PARAM_NOT_SUPPORTED 0x26 79 #define SENCODE_PARAM_VALUE_INVALID 0x26 80 #define SENCODE_RESET_OCCURRED 0x29 81 #define SENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x3E 82 #define SENCODE_INQUIRY_DATA_CHANGED 0x3F 83 #define SENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x39 84 #define SENCODE_DIAGNOSTIC_FAILURE 0x40 85 #define SENCODE_INTERNAL_TARGET_FAILURE 0x44 86 #define SENCODE_INVALID_MESSAGE_ERROR 0x49 87 #define SENCODE_LUN_FAILED_SELF_CONFIG 0x4c 88 #define SENCODE_OVERLAPPED_COMMAND 0x4E 89 90 /* 91 * Additional sense codes 92 */ 93 94 #define ASENCODE_NO_SENSE 0x00 95 #define ASENCODE_END_OF_DATA 0x05 96 #define ASENCODE_BECOMING_READY 0x01 97 #define ASENCODE_INIT_CMD_REQUIRED 0x02 98 #define ASENCODE_PARAM_LIST_LENGTH_ERROR 0x00 99 #define ASENCODE_INVALID_COMMAND 0x00 100 #define ASENCODE_LBA_OUT_OF_RANGE 0x00 101 #define ASENCODE_INVALID_CDB_FIELD 0x00 102 #define ASENCODE_LUN_NOT_SUPPORTED 0x00 103 #define ASENCODE_INVALID_PARAM_FIELD 0x00 104 #define ASENCODE_PARAM_NOT_SUPPORTED 0x01 105 #define ASENCODE_PARAM_VALUE_INVALID 0x02 106 #define ASENCODE_RESET_OCCURRED 0x00 107 #define ASENCODE_LUN_NOT_SELF_CONFIGURED_YET 0x00 108 #define ASENCODE_INQUIRY_DATA_CHANGED 0x03 109 #define ASENCODE_SAVING_PARAMS_NOT_SUPPORTED 0x00 110 #define ASENCODE_DIAGNOSTIC_FAILURE 0x80 111 #define ASENCODE_INTERNAL_TARGET_FAILURE 0x00 112 #define ASENCODE_INVALID_MESSAGE_ERROR 0x00 113 #define ASENCODE_LUN_FAILED_SELF_CONFIG 0x00 114 #define ASENCODE_OVERLAPPED_COMMAND 0x00 115 116 #define AAC_STAT_GOOD (DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD) 117 118 #define BYTE0(x) (unsigned char)(x) 119 #define BYTE1(x) (unsigned char)((x) >> 8) 120 #define BYTE2(x) (unsigned char)((x) >> 16) 121 #define BYTE3(x) (unsigned char)((x) >> 24) 122 123 /* MODE_SENSE data format */ 124 typedef struct { 125 struct { 126 u8 data_length; 127 u8 med_type; 128 u8 dev_par; 129 u8 bd_length; 130 } __attribute__((packed)) hd; 131 struct { 132 u8 dens_code; 133 u8 block_count[3]; 134 u8 reserved; 135 u8 block_length[3]; 136 } __attribute__((packed)) bd; 137 u8 mpc_buf[3]; 138 } __attribute__((packed)) aac_modep_data; 139 140 /* MODE_SENSE_10 data format */ 141 typedef struct { 142 struct { 143 u8 data_length[2]; 144 u8 med_type; 145 u8 dev_par; 146 u8 rsrvd[2]; 147 u8 bd_length[2]; 148 } __attribute__((packed)) hd; 149 struct { 150 u8 dens_code; 151 u8 block_count[3]; 152 u8 reserved; 153 u8 block_length[3]; 154 } __attribute__((packed)) bd; 155 u8 mpc_buf[3]; 156 } __attribute__((packed)) aac_modep10_data; 157 158 /*------------------------------------------------------------------------------ 159 * S T R U C T S / T Y P E D E F S 160 *----------------------------------------------------------------------------*/ 161 /* SCSI inquiry data */ 162 struct inquiry_data { 163 u8 inqd_pdt; /* Peripheral qualifier | Peripheral Device Type */ 164 u8 inqd_dtq; /* RMB | Device Type Qualifier */ 165 u8 inqd_ver; /* ISO version | ECMA version | ANSI-approved version */ 166 u8 inqd_rdf; /* AENC | TrmIOP | Response data format */ 167 u8 inqd_len; /* Additional length (n-4) */ 168 u8 inqd_pad1[2];/* Reserved - must be zero */ 169 u8 inqd_pad2; /* RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 170 u8 inqd_vid[8]; /* Vendor ID */ 171 u8 inqd_pid[16];/* Product ID */ 172 u8 inqd_prl[4]; /* Product Revision Level */ 173 }; 174 175 /* Added for VPD 0x83 */ 176 struct tvpd_id_descriptor_type_1 { 177 u8 codeset:4; /* VPD_CODE_SET */ 178 u8 reserved:4; 179 u8 identifiertype:4; /* VPD_IDENTIFIER_TYPE */ 180 u8 reserved2:4; 181 u8 reserved3; 182 u8 identifierlength; 183 u8 venid[8]; 184 u8 productid[16]; 185 u8 serialnumber[8]; /* SN in ASCII */ 186 187 }; 188 189 struct tvpd_id_descriptor_type_2 { 190 u8 codeset:4; /* VPD_CODE_SET */ 191 u8 reserved:4; 192 u8 identifiertype:4; /* VPD_IDENTIFIER_TYPE */ 193 u8 reserved2:4; 194 u8 reserved3; 195 u8 identifierlength; 196 struct teu64id { 197 u32 Serial; 198 /* The serial number supposed to be 40 bits, 199 * bit we only support 32, so make the last byte zero. */ 200 u8 reserved; 201 u8 venid[3]; 202 } eu64id; 203 204 }; 205 206 struct tvpd_id_descriptor_type_3 { 207 u8 codeset : 4; /* VPD_CODE_SET */ 208 u8 reserved : 4; 209 u8 identifiertype : 4; /* VPD_IDENTIFIER_TYPE */ 210 u8 reserved2 : 4; 211 u8 reserved3; 212 u8 identifierlength; 213 u8 Identifier[16]; 214 }; 215 216 struct tvpd_page83 { 217 u8 DeviceType:5; 218 u8 DeviceTypeQualifier:3; 219 u8 PageCode; 220 u8 reserved; 221 u8 PageLength; 222 struct tvpd_id_descriptor_type_1 type1; 223 struct tvpd_id_descriptor_type_2 type2; 224 struct tvpd_id_descriptor_type_3 type3; 225 }; 226 227 /* 228 * M O D U L E G L O B A L S 229 */ 230 231 static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *sgmap); 232 static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg); 233 static long aac_build_sgraw(struct scsi_cmnd *scsicmd, struct sgmapraw *psg); 234 static long aac_build_sgraw2(struct scsi_cmnd *scsicmd, 235 struct aac_raw_io2 *rio2, int sg_max); 236 static long aac_build_sghba(struct scsi_cmnd *scsicmd, 237 struct aac_hba_cmd_req *hbacmd, 238 int sg_max, u64 sg_address); 239 static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, 240 int pages, int nseg, int nseg_new); 241 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd); 242 static int aac_send_hba_fib(struct scsi_cmnd *scsicmd); 243 #ifdef AAC_DETAILED_STATUS_INFO 244 static char *aac_get_status_string(u32 status); 245 #endif 246 247 /* 248 * Non dasd selection is handled entirely in aachba now 249 */ 250 251 static int nondasd = -1; 252 static int aac_cache = 2; /* WCE=0 to avoid performance problems */ 253 static int dacmode = -1; 254 int aac_msi; 255 int aac_commit = -1; 256 int startup_timeout = 180; 257 int aif_timeout = 120; 258 int aac_sync_mode; /* Only Sync. transfer - disabled */ 259 int aac_convert_sgl = 1; /* convert non-conformable s/g list - enabled */ 260 261 module_param(aac_sync_mode, int, S_IRUGO|S_IWUSR); 262 MODULE_PARM_DESC(aac_sync_mode, "Force sync. transfer mode" 263 " 0=off, 1=on"); 264 module_param(aac_convert_sgl, int, S_IRUGO|S_IWUSR); 265 MODULE_PARM_DESC(aac_convert_sgl, "Convert non-conformable s/g list" 266 " 0=off, 1=on"); 267 module_param(nondasd, int, S_IRUGO|S_IWUSR); 268 MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices." 269 " 0=off, 1=on"); 270 module_param_named(cache, aac_cache, int, S_IRUGO|S_IWUSR); 271 MODULE_PARM_DESC(cache, "Disable Queue Flush commands:\n" 272 "\tbit 0 - Disable FUA in WRITE SCSI commands\n" 273 "\tbit 1 - Disable SYNCHRONIZE_CACHE SCSI command\n" 274 "\tbit 2 - Disable only if Battery is protecting Cache"); 275 module_param(dacmode, int, S_IRUGO|S_IWUSR); 276 MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC." 277 " 0=off, 1=on"); 278 module_param_named(commit, aac_commit, int, S_IRUGO|S_IWUSR); 279 MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the" 280 " adapter for foreign arrays.\n" 281 "This is typically needed in systems that do not have a BIOS." 282 " 0=off, 1=on"); 283 module_param_named(msi, aac_msi, int, S_IRUGO|S_IWUSR); 284 MODULE_PARM_DESC(msi, "IRQ handling." 285 " 0=PIC(default), 1=MSI, 2=MSI-X)"); 286 module_param(startup_timeout, int, S_IRUGO|S_IWUSR); 287 MODULE_PARM_DESC(startup_timeout, "The duration of time in seconds to wait for" 288 " adapter to have it's kernel up and\n" 289 "running. This is typically adjusted for large systems that do not" 290 " have a BIOS."); 291 module_param(aif_timeout, int, S_IRUGO|S_IWUSR); 292 MODULE_PARM_DESC(aif_timeout, "The duration of time in seconds to wait for" 293 " applications to pick up AIFs before\n" 294 "deregistering them. This is typically adjusted for heavily burdened" 295 " systems."); 296 297 int aac_fib_dump; 298 module_param(aac_fib_dump, int, 0644); 299 MODULE_PARM_DESC(aac_fib_dump, "Dump controller fibs prior to IOP_RESET 0=off, 1=on"); 300 301 int numacb = -1; 302 module_param(numacb, int, S_IRUGO|S_IWUSR); 303 MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control" 304 " blocks (FIB) allocated. Valid values are 512 and down. Default is" 305 " to use suggestion from Firmware."); 306 307 int acbsize = -1; 308 module_param(acbsize, int, S_IRUGO|S_IWUSR); 309 MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB)" 310 " size. Valid values are 512, 2048, 4096 and 8192. Default is to use" 311 " suggestion from Firmware."); 312 313 int update_interval = 30 * 60; 314 module_param(update_interval, int, S_IRUGO|S_IWUSR); 315 MODULE_PARM_DESC(update_interval, "Interval in seconds between time sync" 316 " updates issued to adapter."); 317 318 int check_interval = 60; 319 module_param(check_interval, int, S_IRUGO|S_IWUSR); 320 MODULE_PARM_DESC(check_interval, "Interval in seconds between adapter health" 321 " checks."); 322 323 int aac_check_reset = 1; 324 module_param_named(check_reset, aac_check_reset, int, S_IRUGO|S_IWUSR); 325 MODULE_PARM_DESC(check_reset, "If adapter fails health check, reset the" 326 " adapter. a value of -1 forces the reset to adapters programmed to" 327 " ignore it."); 328 329 int expose_physicals = -1; 330 module_param(expose_physicals, int, S_IRUGO|S_IWUSR); 331 MODULE_PARM_DESC(expose_physicals, "Expose physical components of the arrays." 332 " -1=protect 0=off, 1=on"); 333 334 int aac_reset_devices; 335 module_param_named(reset_devices, aac_reset_devices, int, S_IRUGO|S_IWUSR); 336 MODULE_PARM_DESC(reset_devices, "Force an adapter reset at initialization."); 337 338 int aac_wwn = 1; 339 module_param_named(wwn, aac_wwn, int, S_IRUGO|S_IWUSR); 340 MODULE_PARM_DESC(wwn, "Select a WWN type for the arrays:\n" 341 "\t0 - Disable\n" 342 "\t1 - Array Meta Data Signature (default)\n" 343 "\t2 - Adapter Serial Number"); 344 345 346 static inline int aac_valid_context(struct scsi_cmnd *scsicmd, 347 struct fib *fibptr) { 348 struct scsi_device *device; 349 350 if (unlikely(!scsicmd || !scsicmd->scsi_done)) { 351 dprintk((KERN_WARNING "aac_valid_context: scsi command corrupt\n")); 352 aac_fib_complete(fibptr); 353 return 0; 354 } 355 scsicmd->SCp.phase = AAC_OWNER_MIDLEVEL; 356 device = scsicmd->device; 357 if (unlikely(!device)) { 358 dprintk((KERN_WARNING "aac_valid_context: scsi device corrupt\n")); 359 aac_fib_complete(fibptr); 360 return 0; 361 } 362 return 1; 363 } 364 365 /** 366 * aac_get_config_status - check the adapter configuration 367 * @common: adapter to query 368 * 369 * Query config status, and commit the configuration if needed. 370 */ 371 int aac_get_config_status(struct aac_dev *dev, int commit_flag) 372 { 373 int status = 0; 374 struct fib * fibptr; 375 376 if (!(fibptr = aac_fib_alloc(dev))) 377 return -ENOMEM; 378 379 aac_fib_init(fibptr); 380 { 381 struct aac_get_config_status *dinfo; 382 dinfo = (struct aac_get_config_status *) fib_data(fibptr); 383 384 dinfo->command = cpu_to_le32(VM_ContainerConfig); 385 dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 386 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 387 } 388 389 status = aac_fib_send(ContainerCommand, 390 fibptr, 391 sizeof (struct aac_get_config_status), 392 FsaNormal, 393 1, 1, 394 NULL, NULL); 395 if (status < 0) { 396 printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 397 } else { 398 struct aac_get_config_status_resp *reply 399 = (struct aac_get_config_status_resp *) fib_data(fibptr); 400 dprintk((KERN_WARNING 401 "aac_get_config_status: response=%d status=%d action=%d\n", 402 le32_to_cpu(reply->response), 403 le32_to_cpu(reply->status), 404 le32_to_cpu(reply->data.action))); 405 if ((le32_to_cpu(reply->response) != ST_OK) || 406 (le32_to_cpu(reply->status) != CT_OK) || 407 (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 408 printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 409 status = -EINVAL; 410 } 411 } 412 /* Do not set XferState to zero unless receives a response from F/W */ 413 if (status >= 0) 414 aac_fib_complete(fibptr); 415 416 /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 417 if (status >= 0) { 418 if ((aac_commit == 1) || commit_flag) { 419 struct aac_commit_config * dinfo; 420 aac_fib_init(fibptr); 421 dinfo = (struct aac_commit_config *) fib_data(fibptr); 422 423 dinfo->command = cpu_to_le32(VM_ContainerConfig); 424 dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 425 426 status = aac_fib_send(ContainerCommand, 427 fibptr, 428 sizeof (struct aac_commit_config), 429 FsaNormal, 430 1, 1, 431 NULL, NULL); 432 /* Do not set XferState to zero unless 433 * receives a response from F/W */ 434 if (status >= 0) 435 aac_fib_complete(fibptr); 436 } else if (aac_commit == 0) { 437 printk(KERN_WARNING 438 "aac_get_config_status: Foreign device configurations are being ignored\n"); 439 } 440 } 441 /* FIB should be freed only after getting the response from the F/W */ 442 if (status != -ERESTARTSYS) 443 aac_fib_free(fibptr); 444 return status; 445 } 446 447 static void aac_expose_phy_device(struct scsi_cmnd *scsicmd) 448 { 449 char inq_data; 450 scsi_sg_copy_to_buffer(scsicmd, &inq_data, sizeof(inq_data)); 451 if ((inq_data & 0x20) && (inq_data & 0x1f) == TYPE_DISK) { 452 inq_data &= 0xdf; 453 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 454 } 455 } 456 457 /** 458 * aac_get_containers - list containers 459 * @common: adapter to probe 460 * 461 * Make a list of all containers on this controller 462 */ 463 int aac_get_containers(struct aac_dev *dev) 464 { 465 struct fsa_dev_info *fsa_dev_ptr; 466 u32 index; 467 int status = 0; 468 struct fib * fibptr; 469 struct aac_get_container_count *dinfo; 470 struct aac_get_container_count_resp *dresp; 471 int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 472 473 if (!(fibptr = aac_fib_alloc(dev))) 474 return -ENOMEM; 475 476 aac_fib_init(fibptr); 477 dinfo = (struct aac_get_container_count *) fib_data(fibptr); 478 dinfo->command = cpu_to_le32(VM_ContainerConfig); 479 dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 480 481 status = aac_fib_send(ContainerCommand, 482 fibptr, 483 sizeof (struct aac_get_container_count), 484 FsaNormal, 485 1, 1, 486 NULL, NULL); 487 if (status >= 0) { 488 dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 489 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 490 if (fibptr->dev->supplement_adapter_info.supported_options2 & 491 AAC_OPTION_SUPPORTED_240_VOLUMES) { 492 maximum_num_containers = 493 le32_to_cpu(dresp->MaxSimpleVolumes); 494 } 495 aac_fib_complete(fibptr); 496 } 497 /* FIB should be freed only after getting the response from the F/W */ 498 if (status != -ERESTARTSYS) 499 aac_fib_free(fibptr); 500 501 if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 502 maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 503 if (dev->fsa_dev == NULL || 504 dev->maximum_num_containers != maximum_num_containers) { 505 506 fsa_dev_ptr = dev->fsa_dev; 507 508 dev->fsa_dev = kcalloc(maximum_num_containers, 509 sizeof(*fsa_dev_ptr), GFP_KERNEL); 510 511 kfree(fsa_dev_ptr); 512 fsa_dev_ptr = NULL; 513 514 515 if (!dev->fsa_dev) 516 return -ENOMEM; 517 518 dev->maximum_num_containers = maximum_num_containers; 519 } 520 for (index = 0; index < dev->maximum_num_containers; index++) { 521 dev->fsa_dev[index].devname[0] = '\0'; 522 dev->fsa_dev[index].valid = 0; 523 524 status = aac_probe_container(dev, index); 525 526 if (status < 0) { 527 printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 528 break; 529 } 530 } 531 return status; 532 } 533 534 static void get_container_name_callback(void *context, struct fib * fibptr) 535 { 536 struct aac_get_name_resp * get_name_reply; 537 struct scsi_cmnd * scsicmd; 538 539 scsicmd = (struct scsi_cmnd *) context; 540 541 if (!aac_valid_context(scsicmd, fibptr)) 542 return; 543 544 dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 545 BUG_ON(fibptr == NULL); 546 547 get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 548 /* Failure is irrelevant, using default value instead */ 549 if ((le32_to_cpu(get_name_reply->status) == CT_OK) 550 && (get_name_reply->data[0] != '\0')) { 551 char *sp = get_name_reply->data; 552 sp[sizeof(((struct aac_get_name_resp *)NULL)->data)] = '\0'; 553 while (*sp == ' ') 554 ++sp; 555 if (*sp) { 556 struct inquiry_data inq; 557 char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 558 int count = sizeof(d); 559 char *dp = d; 560 do { 561 *dp++ = (*sp) ? *sp++ : ' '; 562 } while (--count > 0); 563 564 scsi_sg_copy_to_buffer(scsicmd, &inq, sizeof(inq)); 565 memcpy(inq.inqd_pid, d, sizeof(d)); 566 scsi_sg_copy_from_buffer(scsicmd, &inq, sizeof(inq)); 567 } 568 } 569 570 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 571 572 aac_fib_complete(fibptr); 573 scsicmd->scsi_done(scsicmd); 574 } 575 576 /** 577 * aac_get_container_name - get container name, none blocking. 578 */ 579 static int aac_get_container_name(struct scsi_cmnd * scsicmd) 580 { 581 int status; 582 struct aac_get_name *dinfo; 583 struct fib * cmd_fibcontext; 584 struct aac_dev * dev; 585 586 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 587 588 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 589 590 aac_fib_init(cmd_fibcontext); 591 dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 592 593 dinfo->command = cpu_to_le32(VM_ContainerConfig); 594 dinfo->type = cpu_to_le32(CT_READ_NAME); 595 dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 596 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 597 598 status = aac_fib_send(ContainerCommand, 599 cmd_fibcontext, 600 sizeof(struct aac_get_name_resp), 601 FsaNormal, 602 0, 1, 603 (fib_callback)get_container_name_callback, 604 (void *) scsicmd); 605 606 /* 607 * Check that the command queued to the controller 608 */ 609 if (status == -EINPROGRESS) { 610 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 611 return 0; 612 } 613 614 printk(KERN_WARNING "aac_get_container_name: aac_fib_send failed with status: %d.\n", status); 615 aac_fib_complete(cmd_fibcontext); 616 return -1; 617 } 618 619 static int aac_probe_container_callback2(struct scsi_cmnd * scsicmd) 620 { 621 struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 622 623 if ((fsa_dev_ptr[scmd_id(scsicmd)].valid & 1)) 624 return aac_scsi_cmd(scsicmd); 625 626 scsicmd->result = DID_NO_CONNECT << 16; 627 scsicmd->scsi_done(scsicmd); 628 return 0; 629 } 630 631 static void _aac_probe_container2(void * context, struct fib * fibptr) 632 { 633 struct fsa_dev_info *fsa_dev_ptr; 634 int (*callback)(struct scsi_cmnd *); 635 struct scsi_cmnd * scsicmd = (struct scsi_cmnd *)context; 636 int i; 637 638 639 if (!aac_valid_context(scsicmd, fibptr)) 640 return; 641 642 scsicmd->SCp.Status = 0; 643 fsa_dev_ptr = fibptr->dev->fsa_dev; 644 if (fsa_dev_ptr) { 645 struct aac_mount * dresp = (struct aac_mount *) fib_data(fibptr); 646 __le32 sup_options2; 647 648 fsa_dev_ptr += scmd_id(scsicmd); 649 sup_options2 = 650 fibptr->dev->supplement_adapter_info.supported_options2; 651 652 if ((le32_to_cpu(dresp->status) == ST_OK) && 653 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 654 (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 655 if (!(sup_options2 & AAC_OPTION_VARIABLE_BLOCK_SIZE)) { 656 dresp->mnt[0].fileinfo.bdevinfo.block_size = 0x200; 657 fsa_dev_ptr->block_size = 0x200; 658 } else { 659 fsa_dev_ptr->block_size = 660 le32_to_cpu(dresp->mnt[0].fileinfo.bdevinfo.block_size); 661 } 662 for (i = 0; i < 16; i++) 663 fsa_dev_ptr->identifier[i] = 664 dresp->mnt[0].fileinfo.bdevinfo 665 .identifier[i]; 666 fsa_dev_ptr->valid = 1; 667 /* sense_key holds the current state of the spin-up */ 668 if (dresp->mnt[0].state & cpu_to_le32(FSCS_NOT_READY)) 669 fsa_dev_ptr->sense_data.sense_key = NOT_READY; 670 else if (fsa_dev_ptr->sense_data.sense_key == NOT_READY) 671 fsa_dev_ptr->sense_data.sense_key = NO_SENSE; 672 fsa_dev_ptr->type = le32_to_cpu(dresp->mnt[0].vol); 673 fsa_dev_ptr->size 674 = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 675 (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 676 fsa_dev_ptr->ro = ((le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) != 0); 677 } 678 if ((fsa_dev_ptr->valid & 1) == 0) 679 fsa_dev_ptr->valid = 0; 680 scsicmd->SCp.Status = le32_to_cpu(dresp->count); 681 } 682 aac_fib_complete(fibptr); 683 aac_fib_free(fibptr); 684 callback = (int (*)(struct scsi_cmnd *))(scsicmd->SCp.ptr); 685 scsicmd->SCp.ptr = NULL; 686 (*callback)(scsicmd); 687 return; 688 } 689 690 static void _aac_probe_container1(void * context, struct fib * fibptr) 691 { 692 struct scsi_cmnd * scsicmd; 693 struct aac_mount * dresp; 694 struct aac_query_mount *dinfo; 695 int status; 696 697 dresp = (struct aac_mount *) fib_data(fibptr); 698 if (!(fibptr->dev->supplement_adapter_info.supported_options2 & 699 AAC_OPTION_VARIABLE_BLOCK_SIZE)) 700 dresp->mnt[0].capacityhigh = 0; 701 if ((le32_to_cpu(dresp->status) != ST_OK) || 702 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE)) { 703 _aac_probe_container2(context, fibptr); 704 return; 705 } 706 scsicmd = (struct scsi_cmnd *) context; 707 708 if (!aac_valid_context(scsicmd, fibptr)) 709 return; 710 711 aac_fib_init(fibptr); 712 713 dinfo = (struct aac_query_mount *)fib_data(fibptr); 714 715 if (fibptr->dev->supplement_adapter_info.supported_options2 & 716 AAC_OPTION_VARIABLE_BLOCK_SIZE) 717 dinfo->command = cpu_to_le32(VM_NameServeAllBlk); 718 else 719 dinfo->command = cpu_to_le32(VM_NameServe64); 720 721 dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 722 dinfo->type = cpu_to_le32(FT_FILESYS); 723 724 status = aac_fib_send(ContainerCommand, 725 fibptr, 726 sizeof(struct aac_query_mount), 727 FsaNormal, 728 0, 1, 729 _aac_probe_container2, 730 (void *) scsicmd); 731 /* 732 * Check that the command queued to the controller 733 */ 734 if (status == -EINPROGRESS) 735 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 736 else if (status < 0) { 737 /* Inherit results from VM_NameServe, if any */ 738 dresp->status = cpu_to_le32(ST_OK); 739 _aac_probe_container2(context, fibptr); 740 } 741 } 742 743 static int _aac_probe_container(struct scsi_cmnd * scsicmd, int (*callback)(struct scsi_cmnd *)) 744 { 745 struct fib * fibptr; 746 int status = -ENOMEM; 747 748 if ((fibptr = aac_fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) { 749 struct aac_query_mount *dinfo; 750 751 aac_fib_init(fibptr); 752 753 dinfo = (struct aac_query_mount *)fib_data(fibptr); 754 755 if (fibptr->dev->supplement_adapter_info.supported_options2 & 756 AAC_OPTION_VARIABLE_BLOCK_SIZE) 757 dinfo->command = cpu_to_le32(VM_NameServeAllBlk); 758 else 759 dinfo->command = cpu_to_le32(VM_NameServe); 760 761 dinfo->count = cpu_to_le32(scmd_id(scsicmd)); 762 dinfo->type = cpu_to_le32(FT_FILESYS); 763 scsicmd->SCp.ptr = (char *)callback; 764 765 status = aac_fib_send(ContainerCommand, 766 fibptr, 767 sizeof(struct aac_query_mount), 768 FsaNormal, 769 0, 1, 770 _aac_probe_container1, 771 (void *) scsicmd); 772 /* 773 * Check that the command queued to the controller 774 */ 775 if (status == -EINPROGRESS) { 776 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 777 return 0; 778 } 779 if (status < 0) { 780 scsicmd->SCp.ptr = NULL; 781 aac_fib_complete(fibptr); 782 aac_fib_free(fibptr); 783 } 784 } 785 if (status < 0) { 786 struct fsa_dev_info *fsa_dev_ptr = ((struct aac_dev *)(scsicmd->device->host->hostdata))->fsa_dev; 787 if (fsa_dev_ptr) { 788 fsa_dev_ptr += scmd_id(scsicmd); 789 if ((fsa_dev_ptr->valid & 1) == 0) { 790 fsa_dev_ptr->valid = 0; 791 return (*callback)(scsicmd); 792 } 793 } 794 } 795 return status; 796 } 797 798 /** 799 * aac_probe_container - query a logical volume 800 * @dev: device to query 801 * @cid: container identifier 802 * 803 * Queries the controller about the given volume. The volume information 804 * is updated in the struct fsa_dev_info structure rather than returned. 805 */ 806 static int aac_probe_container_callback1(struct scsi_cmnd * scsicmd) 807 { 808 scsicmd->device = NULL; 809 return 0; 810 } 811 812 int aac_probe_container(struct aac_dev *dev, int cid) 813 { 814 struct scsi_cmnd *scsicmd = kmalloc(sizeof(*scsicmd), GFP_KERNEL); 815 struct scsi_device *scsidev = kmalloc(sizeof(*scsidev), GFP_KERNEL); 816 int status; 817 818 if (!scsicmd || !scsidev) { 819 kfree(scsicmd); 820 kfree(scsidev); 821 return -ENOMEM; 822 } 823 scsicmd->list.next = NULL; 824 scsicmd->scsi_done = (void (*)(struct scsi_cmnd*))aac_probe_container_callback1; 825 826 scsicmd->device = scsidev; 827 scsidev->sdev_state = 0; 828 scsidev->id = cid; 829 scsidev->host = dev->scsi_host_ptr; 830 831 if (_aac_probe_container(scsicmd, aac_probe_container_callback1) == 0) 832 while (scsicmd->device == scsidev) 833 schedule(); 834 kfree(scsidev); 835 status = scsicmd->SCp.Status; 836 kfree(scsicmd); 837 return status; 838 } 839 840 /* Local Structure to set SCSI inquiry data strings */ 841 struct scsi_inq { 842 char vid[8]; /* Vendor ID */ 843 char pid[16]; /* Product ID */ 844 char prl[4]; /* Product Revision Level */ 845 }; 846 847 /** 848 * InqStrCopy - string merge 849 * @a: string to copy from 850 * @b: string to copy to 851 * 852 * Copy a String from one location to another 853 * without copying \0 854 */ 855 856 static void inqstrcpy(char *a, char *b) 857 { 858 859 while (*a != (char)0) 860 *b++ = *a++; 861 } 862 863 static char *container_types[] = { 864 "None", 865 "Volume", 866 "Mirror", 867 "Stripe", 868 "RAID5", 869 "SSRW", 870 "SSRO", 871 "Morph", 872 "Legacy", 873 "RAID4", 874 "RAID10", 875 "RAID00", 876 "V-MIRRORS", 877 "PSEUDO R4", 878 "RAID50", 879 "RAID5D", 880 "RAID5D0", 881 "RAID1E", 882 "RAID6", 883 "RAID60", 884 "Unknown" 885 }; 886 887 char * get_container_type(unsigned tindex) 888 { 889 if (tindex >= ARRAY_SIZE(container_types)) 890 tindex = ARRAY_SIZE(container_types) - 1; 891 return container_types[tindex]; 892 } 893 894 /* Function: setinqstr 895 * 896 * Arguments: [1] pointer to void [1] int 897 * 898 * Purpose: Sets SCSI inquiry data strings for vendor, product 899 * and revision level. Allows strings to be set in platform dependent 900 * files instead of in OS dependent driver source. 901 */ 902 903 static void setinqstr(struct aac_dev *dev, void *data, int tindex) 904 { 905 struct scsi_inq *str; 906 struct aac_supplement_adapter_info *sup_adap_info; 907 908 sup_adap_info = &dev->supplement_adapter_info; 909 str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 910 memset(str, ' ', sizeof(*str)); 911 912 if (sup_adap_info->adapter_type_text[0]) { 913 char *cp = sup_adap_info->adapter_type_text; 914 int c; 915 if ((cp[0] == 'A') && (cp[1] == 'O') && (cp[2] == 'C')) 916 inqstrcpy("SMC", str->vid); 917 else { 918 c = sizeof(str->vid); 919 while (*cp && *cp != ' ' && --c) 920 ++cp; 921 c = *cp; 922 *cp = '\0'; 923 inqstrcpy(sup_adap_info->adapter_type_text, str->vid); 924 *cp = c; 925 while (*cp && *cp != ' ') 926 ++cp; 927 } 928 while (*cp == ' ') 929 ++cp; 930 /* last six chars reserved for vol type */ 931 c = 0; 932 if (strlen(cp) > sizeof(str->pid)) { 933 c = cp[sizeof(str->pid)]; 934 cp[sizeof(str->pid)] = '\0'; 935 } 936 inqstrcpy (cp, str->pid); 937 if (c) 938 cp[sizeof(str->pid)] = c; 939 } else { 940 struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 941 942 inqstrcpy (mp->vname, str->vid); 943 /* last six chars reserved for vol type */ 944 inqstrcpy (mp->model, str->pid); 945 } 946 947 if (tindex < ARRAY_SIZE(container_types)){ 948 char *findit = str->pid; 949 950 for ( ; *findit != ' '; findit++); /* walk till we find a space */ 951 /* RAID is superfluous in the context of a RAID device */ 952 if (memcmp(findit-4, "RAID", 4) == 0) 953 *(findit -= 4) = ' '; 954 if (((findit - str->pid) + strlen(container_types[tindex])) 955 < (sizeof(str->pid) + sizeof(str->prl))) 956 inqstrcpy (container_types[tindex], findit + 1); 957 } 958 inqstrcpy ("V1.0", str->prl); 959 } 960 961 static void build_vpd83_type3(struct tvpd_page83 *vpdpage83data, 962 struct aac_dev *dev, struct scsi_cmnd *scsicmd) 963 { 964 int container; 965 966 vpdpage83data->type3.codeset = 1; 967 vpdpage83data->type3.identifiertype = 3; 968 vpdpage83data->type3.identifierlength = sizeof(vpdpage83data->type3) 969 - 4; 970 971 for (container = 0; container < dev->maximum_num_containers; 972 container++) { 973 974 if (scmd_id(scsicmd) == container) { 975 memcpy(vpdpage83data->type3.Identifier, 976 dev->fsa_dev[container].identifier, 977 16); 978 break; 979 } 980 } 981 } 982 983 static void get_container_serial_callback(void *context, struct fib * fibptr) 984 { 985 struct aac_get_serial_resp * get_serial_reply; 986 struct scsi_cmnd * scsicmd; 987 988 BUG_ON(fibptr == NULL); 989 990 scsicmd = (struct scsi_cmnd *) context; 991 if (!aac_valid_context(scsicmd, fibptr)) 992 return; 993 994 get_serial_reply = (struct aac_get_serial_resp *) fib_data(fibptr); 995 /* Failure is irrelevant, using default value instead */ 996 if (le32_to_cpu(get_serial_reply->status) == CT_OK) { 997 /*Check to see if it's for VPD 0x83 or 0x80 */ 998 if (scsicmd->cmnd[2] == 0x83) { 999 /* vpd page 0x83 - Device Identification Page */ 1000 struct aac_dev *dev; 1001 int i; 1002 struct tvpd_page83 vpdpage83data; 1003 1004 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1005 1006 memset(((u8 *)&vpdpage83data), 0, 1007 sizeof(vpdpage83data)); 1008 1009 /* DIRECT_ACCESS_DEVIC */ 1010 vpdpage83data.DeviceType = 0; 1011 /* DEVICE_CONNECTED */ 1012 vpdpage83data.DeviceTypeQualifier = 0; 1013 /* VPD_DEVICE_IDENTIFIERS */ 1014 vpdpage83data.PageCode = 0x83; 1015 vpdpage83data.reserved = 0; 1016 vpdpage83data.PageLength = 1017 sizeof(vpdpage83data.type1) + 1018 sizeof(vpdpage83data.type2); 1019 1020 /* VPD 83 Type 3 is not supported for ARC */ 1021 if (dev->sa_firmware) 1022 vpdpage83data.PageLength += 1023 sizeof(vpdpage83data.type3); 1024 1025 /* T10 Vendor Identifier Field Format */ 1026 /* VpdcodesetAscii */ 1027 vpdpage83data.type1.codeset = 2; 1028 /* VpdIdentifierTypeVendorId */ 1029 vpdpage83data.type1.identifiertype = 1; 1030 vpdpage83data.type1.identifierlength = 1031 sizeof(vpdpage83data.type1) - 4; 1032 1033 /* "ADAPTEC " for adaptec */ 1034 memcpy(vpdpage83data.type1.venid, 1035 "ADAPTEC ", 1036 sizeof(vpdpage83data.type1.venid)); 1037 memcpy(vpdpage83data.type1.productid, 1038 "ARRAY ", 1039 sizeof( 1040 vpdpage83data.type1.productid)); 1041 1042 /* Convert to ascii based serial number. 1043 * The LSB is the the end. 1044 */ 1045 for (i = 0; i < 8; i++) { 1046 u8 temp = 1047 (u8)((get_serial_reply->uid >> ((7 - i) * 4)) & 0xF); 1048 if (temp > 0x9) { 1049 vpdpage83data.type1.serialnumber[i] = 1050 'A' + (temp - 0xA); 1051 } else { 1052 vpdpage83data.type1.serialnumber[i] = 1053 '0' + temp; 1054 } 1055 } 1056 1057 /* VpdCodeSetBinary */ 1058 vpdpage83data.type2.codeset = 1; 1059 /* VpdidentifiertypeEUI64 */ 1060 vpdpage83data.type2.identifiertype = 2; 1061 vpdpage83data.type2.identifierlength = 1062 sizeof(vpdpage83data.type2) - 4; 1063 1064 vpdpage83data.type2.eu64id.venid[0] = 0xD0; 1065 vpdpage83data.type2.eu64id.venid[1] = 0; 1066 vpdpage83data.type2.eu64id.venid[2] = 0; 1067 1068 vpdpage83data.type2.eu64id.Serial = 1069 get_serial_reply->uid; 1070 vpdpage83data.type2.eu64id.reserved = 0; 1071 1072 /* 1073 * VpdIdentifierTypeFCPHName 1074 * VPD 0x83 Type 3 not supported for ARC 1075 */ 1076 if (dev->sa_firmware) { 1077 build_vpd83_type3(&vpdpage83data, 1078 dev, scsicmd); 1079 } 1080 1081 /* Move the inquiry data to the response buffer. */ 1082 scsi_sg_copy_from_buffer(scsicmd, &vpdpage83data, 1083 sizeof(vpdpage83data)); 1084 } else { 1085 /* It must be for VPD 0x80 */ 1086 char sp[13]; 1087 /* EVPD bit set */ 1088 sp[0] = INQD_PDT_DA; 1089 sp[1] = scsicmd->cmnd[2]; 1090 sp[2] = 0; 1091 sp[3] = snprintf(sp+4, sizeof(sp)-4, "%08X", 1092 le32_to_cpu(get_serial_reply->uid)); 1093 scsi_sg_copy_from_buffer(scsicmd, sp, 1094 sizeof(sp)); 1095 } 1096 } 1097 1098 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1099 1100 aac_fib_complete(fibptr); 1101 scsicmd->scsi_done(scsicmd); 1102 } 1103 1104 /** 1105 * aac_get_container_serial - get container serial, none blocking. 1106 */ 1107 static int aac_get_container_serial(struct scsi_cmnd * scsicmd) 1108 { 1109 int status; 1110 struct aac_get_serial *dinfo; 1111 struct fib * cmd_fibcontext; 1112 struct aac_dev * dev; 1113 1114 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1115 1116 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 1117 1118 aac_fib_init(cmd_fibcontext); 1119 dinfo = (struct aac_get_serial *) fib_data(cmd_fibcontext); 1120 1121 dinfo->command = cpu_to_le32(VM_ContainerConfig); 1122 dinfo->type = cpu_to_le32(CT_CID_TO_32BITS_UID); 1123 dinfo->cid = cpu_to_le32(scmd_id(scsicmd)); 1124 1125 status = aac_fib_send(ContainerCommand, 1126 cmd_fibcontext, 1127 sizeof(struct aac_get_serial_resp), 1128 FsaNormal, 1129 0, 1, 1130 (fib_callback) get_container_serial_callback, 1131 (void *) scsicmd); 1132 1133 /* 1134 * Check that the command queued to the controller 1135 */ 1136 if (status == -EINPROGRESS) { 1137 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 1138 return 0; 1139 } 1140 1141 printk(KERN_WARNING "aac_get_container_serial: aac_fib_send failed with status: %d.\n", status); 1142 aac_fib_complete(cmd_fibcontext); 1143 return -1; 1144 } 1145 1146 /* Function: setinqserial 1147 * 1148 * Arguments: [1] pointer to void [1] int 1149 * 1150 * Purpose: Sets SCSI Unit Serial number. 1151 * This is a fake. We should read a proper 1152 * serial number from the container. <SuSE>But 1153 * without docs it's quite hard to do it :-) 1154 * So this will have to do in the meantime.</SuSE> 1155 */ 1156 1157 static int setinqserial(struct aac_dev *dev, void *data, int cid) 1158 { 1159 /* 1160 * This breaks array migration. 1161 */ 1162 return snprintf((char *)(data), sizeof(struct scsi_inq) - 4, "%08X%02X", 1163 le32_to_cpu(dev->adapter_info.serial[0]), cid); 1164 } 1165 1166 static inline void set_sense(struct sense_data *sense_data, u8 sense_key, 1167 u8 sense_code, u8 a_sense_code, u8 bit_pointer, u16 field_pointer) 1168 { 1169 u8 *sense_buf = (u8 *)sense_data; 1170 /* Sense data valid, err code 70h */ 1171 sense_buf[0] = 0x70; /* No info field */ 1172 sense_buf[1] = 0; /* Segment number, always zero */ 1173 1174 sense_buf[2] = sense_key; /* Sense key */ 1175 1176 sense_buf[12] = sense_code; /* Additional sense code */ 1177 sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 1178 1179 if (sense_key == ILLEGAL_REQUEST) { 1180 sense_buf[7] = 10; /* Additional sense length */ 1181 1182 sense_buf[15] = bit_pointer; 1183 /* Illegal parameter is in the parameter block */ 1184 if (sense_code == SENCODE_INVALID_CDB_FIELD) 1185 sense_buf[15] |= 0xc0;/* Std sense key specific field */ 1186 /* Illegal parameter is in the CDB block */ 1187 sense_buf[16] = field_pointer >> 8; /* MSB */ 1188 sense_buf[17] = field_pointer; /* LSB */ 1189 } else 1190 sense_buf[7] = 6; /* Additional sense length */ 1191 } 1192 1193 static int aac_bounds_32(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 1194 { 1195 if (lba & 0xffffffff00000000LL) { 1196 int cid = scmd_id(cmd); 1197 dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 1198 cmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1199 SAM_STAT_CHECK_CONDITION; 1200 set_sense(&dev->fsa_dev[cid].sense_data, 1201 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 1202 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 1203 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1204 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 1205 SCSI_SENSE_BUFFERSIZE)); 1206 cmd->scsi_done(cmd); 1207 return 1; 1208 } 1209 return 0; 1210 } 1211 1212 static int aac_bounds_64(struct aac_dev * dev, struct scsi_cmnd * cmd, u64 lba) 1213 { 1214 return 0; 1215 } 1216 1217 static void io_callback(void *context, struct fib * fibptr); 1218 1219 static int aac_read_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1220 { 1221 struct aac_dev *dev = fib->dev; 1222 u16 fibsize, command; 1223 long ret; 1224 1225 aac_fib_init(fib); 1226 if ((dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 || 1227 dev->comm_interface == AAC_COMM_MESSAGE_TYPE3) && 1228 !dev->sync_mode) { 1229 struct aac_raw_io2 *readcmd2; 1230 readcmd2 = (struct aac_raw_io2 *) fib_data(fib); 1231 memset(readcmd2, 0, sizeof(struct aac_raw_io2)); 1232 readcmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 1233 readcmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1234 readcmd2->byteCount = cpu_to_le32(count * 1235 dev->fsa_dev[scmd_id(cmd)].block_size); 1236 readcmd2->cid = cpu_to_le16(scmd_id(cmd)); 1237 readcmd2->flags = cpu_to_le16(RIO2_IO_TYPE_READ); 1238 ret = aac_build_sgraw2(cmd, readcmd2, 1239 dev->scsi_host_ptr->sg_tablesize); 1240 if (ret < 0) 1241 return ret; 1242 command = ContainerRawIo2; 1243 fibsize = sizeof(struct aac_raw_io2) + 1244 ((le32_to_cpu(readcmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 1245 } else { 1246 struct aac_raw_io *readcmd; 1247 readcmd = (struct aac_raw_io *) fib_data(fib); 1248 readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1249 readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1250 readcmd->count = cpu_to_le32(count * 1251 dev->fsa_dev[scmd_id(cmd)].block_size); 1252 readcmd->cid = cpu_to_le16(scmd_id(cmd)); 1253 readcmd->flags = cpu_to_le16(RIO_TYPE_READ); 1254 readcmd->bpTotal = 0; 1255 readcmd->bpComplete = 0; 1256 ret = aac_build_sgraw(cmd, &readcmd->sg); 1257 if (ret < 0) 1258 return ret; 1259 command = ContainerRawIo; 1260 fibsize = sizeof(struct aac_raw_io) + 1261 ((le32_to_cpu(readcmd->sg.count)-1) * sizeof(struct sgentryraw)); 1262 } 1263 1264 BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1265 /* 1266 * Now send the Fib to the adapter 1267 */ 1268 return aac_fib_send(command, 1269 fib, 1270 fibsize, 1271 FsaNormal, 1272 0, 1, 1273 (fib_callback) io_callback, 1274 (void *) cmd); 1275 } 1276 1277 static int aac_read_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1278 { 1279 u16 fibsize; 1280 struct aac_read64 *readcmd; 1281 long ret; 1282 1283 aac_fib_init(fib); 1284 readcmd = (struct aac_read64 *) fib_data(fib); 1285 readcmd->command = cpu_to_le32(VM_CtHostRead64); 1286 readcmd->cid = cpu_to_le16(scmd_id(cmd)); 1287 readcmd->sector_count = cpu_to_le16(count); 1288 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1289 readcmd->pad = 0; 1290 readcmd->flags = 0; 1291 1292 ret = aac_build_sg64(cmd, &readcmd->sg); 1293 if (ret < 0) 1294 return ret; 1295 fibsize = sizeof(struct aac_read64) + 1296 ((le32_to_cpu(readcmd->sg.count) - 1) * 1297 sizeof (struct sgentry64)); 1298 BUG_ON (fibsize > (fib->dev->max_fib_size - 1299 sizeof(struct aac_fibhdr))); 1300 /* 1301 * Now send the Fib to the adapter 1302 */ 1303 return aac_fib_send(ContainerCommand64, 1304 fib, 1305 fibsize, 1306 FsaNormal, 1307 0, 1, 1308 (fib_callback) io_callback, 1309 (void *) cmd); 1310 } 1311 1312 static int aac_read_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count) 1313 { 1314 u16 fibsize; 1315 struct aac_read *readcmd; 1316 struct aac_dev *dev = fib->dev; 1317 long ret; 1318 1319 aac_fib_init(fib); 1320 readcmd = (struct aac_read *) fib_data(fib); 1321 readcmd->command = cpu_to_le32(VM_CtBlockRead); 1322 readcmd->cid = cpu_to_le32(scmd_id(cmd)); 1323 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1324 readcmd->count = cpu_to_le32(count * 1325 dev->fsa_dev[scmd_id(cmd)].block_size); 1326 1327 ret = aac_build_sg(cmd, &readcmd->sg); 1328 if (ret < 0) 1329 return ret; 1330 fibsize = sizeof(struct aac_read) + 1331 ((le32_to_cpu(readcmd->sg.count) - 1) * 1332 sizeof (struct sgentry)); 1333 BUG_ON (fibsize > (fib->dev->max_fib_size - 1334 sizeof(struct aac_fibhdr))); 1335 /* 1336 * Now send the Fib to the adapter 1337 */ 1338 return aac_fib_send(ContainerCommand, 1339 fib, 1340 fibsize, 1341 FsaNormal, 1342 0, 1, 1343 (fib_callback) io_callback, 1344 (void *) cmd); 1345 } 1346 1347 static int aac_write_raw_io(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1348 { 1349 struct aac_dev *dev = fib->dev; 1350 u16 fibsize, command; 1351 long ret; 1352 1353 aac_fib_init(fib); 1354 if ((dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 || 1355 dev->comm_interface == AAC_COMM_MESSAGE_TYPE3) && 1356 !dev->sync_mode) { 1357 struct aac_raw_io2 *writecmd2; 1358 writecmd2 = (struct aac_raw_io2 *) fib_data(fib); 1359 memset(writecmd2, 0, sizeof(struct aac_raw_io2)); 1360 writecmd2->blockLow = cpu_to_le32((u32)(lba&0xffffffff)); 1361 writecmd2->blockHigh = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1362 writecmd2->byteCount = cpu_to_le32(count * 1363 dev->fsa_dev[scmd_id(cmd)].block_size); 1364 writecmd2->cid = cpu_to_le16(scmd_id(cmd)); 1365 writecmd2->flags = (fua && ((aac_cache & 5) != 1) && 1366 (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 1367 cpu_to_le16(RIO2_IO_TYPE_WRITE|RIO2_IO_SUREWRITE) : 1368 cpu_to_le16(RIO2_IO_TYPE_WRITE); 1369 ret = aac_build_sgraw2(cmd, writecmd2, 1370 dev->scsi_host_ptr->sg_tablesize); 1371 if (ret < 0) 1372 return ret; 1373 command = ContainerRawIo2; 1374 fibsize = sizeof(struct aac_raw_io2) + 1375 ((le32_to_cpu(writecmd2->sgeCnt)-1) * sizeof(struct sge_ieee1212)); 1376 } else { 1377 struct aac_raw_io *writecmd; 1378 writecmd = (struct aac_raw_io *) fib_data(fib); 1379 writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1380 writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1381 writecmd->count = cpu_to_le32(count * 1382 dev->fsa_dev[scmd_id(cmd)].block_size); 1383 writecmd->cid = cpu_to_le16(scmd_id(cmd)); 1384 writecmd->flags = (fua && ((aac_cache & 5) != 1) && 1385 (((aac_cache & 5) != 5) || !fib->dev->cache_protected)) ? 1386 cpu_to_le16(RIO_TYPE_WRITE|RIO_SUREWRITE) : 1387 cpu_to_le16(RIO_TYPE_WRITE); 1388 writecmd->bpTotal = 0; 1389 writecmd->bpComplete = 0; 1390 ret = aac_build_sgraw(cmd, &writecmd->sg); 1391 if (ret < 0) 1392 return ret; 1393 command = ContainerRawIo; 1394 fibsize = sizeof(struct aac_raw_io) + 1395 ((le32_to_cpu(writecmd->sg.count)-1) * sizeof (struct sgentryraw)); 1396 } 1397 1398 BUG_ON(fibsize > (fib->dev->max_fib_size - sizeof(struct aac_fibhdr))); 1399 /* 1400 * Now send the Fib to the adapter 1401 */ 1402 return aac_fib_send(command, 1403 fib, 1404 fibsize, 1405 FsaNormal, 1406 0, 1, 1407 (fib_callback) io_callback, 1408 (void *) cmd); 1409 } 1410 1411 static int aac_write_block64(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1412 { 1413 u16 fibsize; 1414 struct aac_write64 *writecmd; 1415 long ret; 1416 1417 aac_fib_init(fib); 1418 writecmd = (struct aac_write64 *) fib_data(fib); 1419 writecmd->command = cpu_to_le32(VM_CtHostWrite64); 1420 writecmd->cid = cpu_to_le16(scmd_id(cmd)); 1421 writecmd->sector_count = cpu_to_le16(count); 1422 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1423 writecmd->pad = 0; 1424 writecmd->flags = 0; 1425 1426 ret = aac_build_sg64(cmd, &writecmd->sg); 1427 if (ret < 0) 1428 return ret; 1429 fibsize = sizeof(struct aac_write64) + 1430 ((le32_to_cpu(writecmd->sg.count) - 1) * 1431 sizeof (struct sgentry64)); 1432 BUG_ON (fibsize > (fib->dev->max_fib_size - 1433 sizeof(struct aac_fibhdr))); 1434 /* 1435 * Now send the Fib to the adapter 1436 */ 1437 return aac_fib_send(ContainerCommand64, 1438 fib, 1439 fibsize, 1440 FsaNormal, 1441 0, 1, 1442 (fib_callback) io_callback, 1443 (void *) cmd); 1444 } 1445 1446 static int aac_write_block(struct fib * fib, struct scsi_cmnd * cmd, u64 lba, u32 count, int fua) 1447 { 1448 u16 fibsize; 1449 struct aac_write *writecmd; 1450 struct aac_dev *dev = fib->dev; 1451 long ret; 1452 1453 aac_fib_init(fib); 1454 writecmd = (struct aac_write *) fib_data(fib); 1455 writecmd->command = cpu_to_le32(VM_CtBlockWrite); 1456 writecmd->cid = cpu_to_le32(scmd_id(cmd)); 1457 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1458 writecmd->count = cpu_to_le32(count * 1459 dev->fsa_dev[scmd_id(cmd)].block_size); 1460 writecmd->sg.count = cpu_to_le32(1); 1461 /* ->stable is not used - it did mean which type of write */ 1462 1463 ret = aac_build_sg(cmd, &writecmd->sg); 1464 if (ret < 0) 1465 return ret; 1466 fibsize = sizeof(struct aac_write) + 1467 ((le32_to_cpu(writecmd->sg.count) - 1) * 1468 sizeof (struct sgentry)); 1469 BUG_ON (fibsize > (fib->dev->max_fib_size - 1470 sizeof(struct aac_fibhdr))); 1471 /* 1472 * Now send the Fib to the adapter 1473 */ 1474 return aac_fib_send(ContainerCommand, 1475 fib, 1476 fibsize, 1477 FsaNormal, 1478 0, 1, 1479 (fib_callback) io_callback, 1480 (void *) cmd); 1481 } 1482 1483 static struct aac_srb * aac_scsi_common(struct fib * fib, struct scsi_cmnd * cmd) 1484 { 1485 struct aac_srb * srbcmd; 1486 u32 flag; 1487 u32 timeout; 1488 1489 aac_fib_init(fib); 1490 switch(cmd->sc_data_direction){ 1491 case DMA_TO_DEVICE: 1492 flag = SRB_DataOut; 1493 break; 1494 case DMA_BIDIRECTIONAL: 1495 flag = SRB_DataIn | SRB_DataOut; 1496 break; 1497 case DMA_FROM_DEVICE: 1498 flag = SRB_DataIn; 1499 break; 1500 case DMA_NONE: 1501 default: /* shuts up some versions of gcc */ 1502 flag = SRB_NoDataXfer; 1503 break; 1504 } 1505 1506 srbcmd = (struct aac_srb*) fib_data(fib); 1507 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1508 srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scmd_channel(cmd))); 1509 srbcmd->id = cpu_to_le32(scmd_id(cmd)); 1510 srbcmd->lun = cpu_to_le32(cmd->device->lun); 1511 srbcmd->flags = cpu_to_le32(flag); 1512 timeout = cmd->request->timeout/HZ; 1513 if (timeout == 0) 1514 timeout = 1; 1515 srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 1516 srbcmd->retry_limit = 0; /* Obsolete parameter */ 1517 srbcmd->cdb_size = cpu_to_le32(cmd->cmd_len); 1518 return srbcmd; 1519 } 1520 1521 static struct aac_hba_cmd_req *aac_construct_hbacmd(struct fib *fib, 1522 struct scsi_cmnd *cmd) 1523 { 1524 struct aac_hba_cmd_req *hbacmd; 1525 struct aac_dev *dev; 1526 int bus, target; 1527 u64 address; 1528 1529 dev = (struct aac_dev *)cmd->device->host->hostdata; 1530 1531 hbacmd = (struct aac_hba_cmd_req *)fib->hw_fib_va; 1532 memset(hbacmd, 0, 96); /* sizeof(*hbacmd) is not necessary */ 1533 /* iu_type is a parameter of aac_hba_send */ 1534 switch (cmd->sc_data_direction) { 1535 case DMA_TO_DEVICE: 1536 hbacmd->byte1 = 2; 1537 break; 1538 case DMA_FROM_DEVICE: 1539 case DMA_BIDIRECTIONAL: 1540 hbacmd->byte1 = 1; 1541 break; 1542 case DMA_NONE: 1543 default: 1544 break; 1545 } 1546 hbacmd->lun[1] = cpu_to_le32(cmd->device->lun); 1547 1548 bus = aac_logical_to_phys(scmd_channel(cmd)); 1549 target = scmd_id(cmd); 1550 hbacmd->it_nexus = dev->hba_map[bus][target].rmw_nexus; 1551 1552 /* we fill in reply_qid later in aac_src_deliver_message */ 1553 /* we fill in iu_type, request_id later in aac_hba_send */ 1554 /* we fill in emb_data_desc_count later in aac_build_sghba */ 1555 1556 memcpy(hbacmd->cdb, cmd->cmnd, cmd->cmd_len); 1557 hbacmd->data_length = cpu_to_le32(scsi_bufflen(cmd)); 1558 1559 address = (u64)fib->hw_error_pa; 1560 hbacmd->error_ptr_hi = cpu_to_le32((u32)(address >> 32)); 1561 hbacmd->error_ptr_lo = cpu_to_le32((u32)(address & 0xffffffff)); 1562 hbacmd->error_length = cpu_to_le32(FW_ERROR_BUFFER_SIZE); 1563 1564 return hbacmd; 1565 } 1566 1567 static void aac_srb_callback(void *context, struct fib * fibptr); 1568 1569 static int aac_scsi_64(struct fib * fib, struct scsi_cmnd * cmd) 1570 { 1571 u16 fibsize; 1572 struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1573 long ret; 1574 1575 ret = aac_build_sg64(cmd, (struct sgmap64 *) &srbcmd->sg); 1576 if (ret < 0) 1577 return ret; 1578 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1579 1580 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1581 memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1582 /* 1583 * Build Scatter/Gather list 1584 */ 1585 fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 1586 ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 1587 sizeof (struct sgentry64)); 1588 BUG_ON (fibsize > (fib->dev->max_fib_size - 1589 sizeof(struct aac_fibhdr))); 1590 1591 /* 1592 * Now send the Fib to the adapter 1593 */ 1594 return aac_fib_send(ScsiPortCommand64, fib, 1595 fibsize, FsaNormal, 0, 1, 1596 (fib_callback) aac_srb_callback, 1597 (void *) cmd); 1598 } 1599 1600 static int aac_scsi_32(struct fib * fib, struct scsi_cmnd * cmd) 1601 { 1602 u16 fibsize; 1603 struct aac_srb * srbcmd = aac_scsi_common(fib, cmd); 1604 long ret; 1605 1606 ret = aac_build_sg(cmd, (struct sgmap *)&srbcmd->sg); 1607 if (ret < 0) 1608 return ret; 1609 srbcmd->count = cpu_to_le32(scsi_bufflen(cmd)); 1610 1611 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1612 memcpy(srbcmd->cdb, cmd->cmnd, cmd->cmd_len); 1613 /* 1614 * Build Scatter/Gather list 1615 */ 1616 fibsize = sizeof (struct aac_srb) + 1617 (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 1618 sizeof (struct sgentry)); 1619 BUG_ON (fibsize > (fib->dev->max_fib_size - 1620 sizeof(struct aac_fibhdr))); 1621 1622 /* 1623 * Now send the Fib to the adapter 1624 */ 1625 return aac_fib_send(ScsiPortCommand, fib, fibsize, FsaNormal, 0, 1, 1626 (fib_callback) aac_srb_callback, (void *) cmd); 1627 } 1628 1629 static int aac_scsi_32_64(struct fib * fib, struct scsi_cmnd * cmd) 1630 { 1631 if ((sizeof(dma_addr_t) > 4) && fib->dev->needs_dac && 1632 (fib->dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) 1633 return FAILED; 1634 return aac_scsi_32(fib, cmd); 1635 } 1636 1637 static int aac_adapter_hba(struct fib *fib, struct scsi_cmnd *cmd) 1638 { 1639 struct aac_hba_cmd_req *hbacmd = aac_construct_hbacmd(fib, cmd); 1640 struct aac_dev *dev; 1641 long ret; 1642 1643 dev = (struct aac_dev *)cmd->device->host->hostdata; 1644 1645 ret = aac_build_sghba(cmd, hbacmd, 1646 dev->scsi_host_ptr->sg_tablesize, (u64)fib->hw_sgl_pa); 1647 if (ret < 0) 1648 return ret; 1649 1650 /* 1651 * Now send the HBA command to the adapter 1652 */ 1653 fib->hbacmd_size = 64 + le32_to_cpu(hbacmd->emb_data_desc_count) * 1654 sizeof(struct aac_hba_sgl); 1655 1656 return aac_hba_send(HBA_IU_TYPE_SCSI_CMD_REQ, fib, 1657 (fib_callback) aac_hba_callback, 1658 (void *) cmd); 1659 } 1660 1661 int aac_issue_bmic_identify(struct aac_dev *dev, u32 bus, u32 target) 1662 { 1663 struct fib *fibptr; 1664 struct aac_srb *srbcmd; 1665 struct sgmap64 *sg64; 1666 struct aac_ciss_identify_pd *identify_resp; 1667 dma_addr_t addr; 1668 u32 vbus, vid; 1669 u16 fibsize, datasize; 1670 int rcode = -ENOMEM; 1671 1672 1673 fibptr = aac_fib_alloc(dev); 1674 if (!fibptr) 1675 goto out; 1676 1677 fibsize = sizeof(struct aac_srb) - 1678 sizeof(struct sgentry) + sizeof(struct sgentry64); 1679 datasize = sizeof(struct aac_ciss_identify_pd); 1680 1681 identify_resp = dma_alloc_coherent(&dev->pdev->dev, datasize, &addr, 1682 GFP_KERNEL); 1683 if (!identify_resp) 1684 goto fib_free_ptr; 1685 1686 vbus = (u32)le16_to_cpu(dev->supplement_adapter_info.virt_device_bus); 1687 vid = (u32)le16_to_cpu(dev->supplement_adapter_info.virt_device_target); 1688 1689 aac_fib_init(fibptr); 1690 1691 srbcmd = (struct aac_srb *) fib_data(fibptr); 1692 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1693 srbcmd->channel = cpu_to_le32(vbus); 1694 srbcmd->id = cpu_to_le32(vid); 1695 srbcmd->lun = 0; 1696 srbcmd->flags = cpu_to_le32(SRB_DataIn); 1697 srbcmd->timeout = cpu_to_le32(10); 1698 srbcmd->retry_limit = 0; 1699 srbcmd->cdb_size = cpu_to_le32(12); 1700 srbcmd->count = cpu_to_le32(datasize); 1701 1702 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1703 srbcmd->cdb[0] = 0x26; 1704 srbcmd->cdb[2] = (u8)((AAC_MAX_LUN + target) & 0x00FF); 1705 srbcmd->cdb[6] = CISS_IDENTIFY_PHYSICAL_DEVICE; 1706 1707 sg64 = (struct sgmap64 *)&srbcmd->sg; 1708 sg64->count = cpu_to_le32(1); 1709 sg64->sg[0].addr[1] = cpu_to_le32((u32)(((addr) >> 16) >> 16)); 1710 sg64->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 1711 sg64->sg[0].count = cpu_to_le32(datasize); 1712 1713 rcode = aac_fib_send(ScsiPortCommand64, 1714 fibptr, fibsize, FsaNormal, 1, 1, NULL, NULL); 1715 1716 if (identify_resp->current_queue_depth_limit <= 0 || 1717 identify_resp->current_queue_depth_limit > 32) 1718 dev->hba_map[bus][target].qd_limit = 32; 1719 else 1720 dev->hba_map[bus][target].qd_limit = 1721 identify_resp->current_queue_depth_limit; 1722 1723 dma_free_coherent(&dev->pdev->dev, datasize, identify_resp, addr); 1724 1725 aac_fib_complete(fibptr); 1726 1727 fib_free_ptr: 1728 aac_fib_free(fibptr); 1729 out: 1730 return rcode; 1731 } 1732 1733 /** 1734 * aac_update hba_map()- update current hba map with data from FW 1735 * @dev: aac_dev structure 1736 * @phys_luns: FW information from report phys luns 1737 * 1738 * Update our hba map with the information gathered from the FW 1739 */ 1740 void aac_update_hba_map(struct aac_dev *dev, 1741 struct aac_ciss_phys_luns_resp *phys_luns, int rescan) 1742 { 1743 /* ok and extended reporting */ 1744 u32 lun_count, nexus; 1745 u32 i, bus, target; 1746 u8 expose_flag, attribs; 1747 u8 devtype; 1748 1749 lun_count = ((phys_luns->list_length[0] << 24) 1750 + (phys_luns->list_length[1] << 16) 1751 + (phys_luns->list_length[2] << 8) 1752 + (phys_luns->list_length[3])) / 24; 1753 1754 for (i = 0; i < lun_count; ++i) { 1755 1756 bus = phys_luns->lun[i].level2[1] & 0x3f; 1757 target = phys_luns->lun[i].level2[0]; 1758 expose_flag = phys_luns->lun[i].bus >> 6; 1759 attribs = phys_luns->lun[i].node_ident[9]; 1760 nexus = *((u32 *) &phys_luns->lun[i].node_ident[12]); 1761 1762 if (bus >= AAC_MAX_BUSES || target >= AAC_MAX_TARGETS) 1763 continue; 1764 1765 dev->hba_map[bus][target].expose = expose_flag; 1766 1767 if (expose_flag != 0) { 1768 devtype = AAC_DEVTYPE_RAID_MEMBER; 1769 goto update_devtype; 1770 } 1771 1772 if (nexus != 0 && (attribs & 8)) { 1773 devtype = AAC_DEVTYPE_NATIVE_RAW; 1774 dev->hba_map[bus][target].rmw_nexus = 1775 nexus; 1776 } else 1777 devtype = AAC_DEVTYPE_ARC_RAW; 1778 1779 if (devtype != AAC_DEVTYPE_NATIVE_RAW) 1780 goto update_devtype; 1781 1782 if (aac_issue_bmic_identify(dev, bus, target) < 0) 1783 dev->hba_map[bus][target].qd_limit = 32; 1784 1785 update_devtype: 1786 if (rescan == AAC_INIT) 1787 dev->hba_map[bus][target].devtype = devtype; 1788 else 1789 dev->hba_map[bus][target].new_devtype = devtype; 1790 } 1791 } 1792 1793 /** 1794 * aac_report_phys_luns() Process topology change 1795 * @dev: aac_dev structure 1796 * @fibptr: fib pointer 1797 * 1798 * Execute a CISS REPORT PHYS LUNS and process the results into 1799 * the current hba_map. 1800 */ 1801 int aac_report_phys_luns(struct aac_dev *dev, struct fib *fibptr, int rescan) 1802 { 1803 int fibsize, datasize; 1804 struct aac_ciss_phys_luns_resp *phys_luns; 1805 struct aac_srb *srbcmd; 1806 struct sgmap64 *sg64; 1807 dma_addr_t addr; 1808 u32 vbus, vid; 1809 int rcode = 0; 1810 1811 /* Thor SA Firmware -> CISS_REPORT_PHYSICAL_LUNS */ 1812 fibsize = sizeof(struct aac_srb) - sizeof(struct sgentry) 1813 + sizeof(struct sgentry64); 1814 datasize = sizeof(struct aac_ciss_phys_luns_resp) 1815 + (AAC_MAX_TARGETS - 1) * sizeof(struct _ciss_lun); 1816 1817 phys_luns = dma_alloc_coherent(&dev->pdev->dev, datasize, &addr, 1818 GFP_KERNEL); 1819 if (phys_luns == NULL) { 1820 rcode = -ENOMEM; 1821 goto err_out; 1822 } 1823 1824 vbus = (u32) le16_to_cpu( 1825 dev->supplement_adapter_info.virt_device_bus); 1826 vid = (u32) le16_to_cpu( 1827 dev->supplement_adapter_info.virt_device_target); 1828 1829 aac_fib_init(fibptr); 1830 1831 srbcmd = (struct aac_srb *) fib_data(fibptr); 1832 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 1833 srbcmd->channel = cpu_to_le32(vbus); 1834 srbcmd->id = cpu_to_le32(vid); 1835 srbcmd->lun = 0; 1836 srbcmd->flags = cpu_to_le32(SRB_DataIn); 1837 srbcmd->timeout = cpu_to_le32(10); 1838 srbcmd->retry_limit = 0; 1839 srbcmd->cdb_size = cpu_to_le32(12); 1840 srbcmd->count = cpu_to_le32(datasize); 1841 1842 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 1843 srbcmd->cdb[0] = CISS_REPORT_PHYSICAL_LUNS; 1844 srbcmd->cdb[1] = 2; /* extended reporting */ 1845 srbcmd->cdb[8] = (u8)(datasize >> 8); 1846 srbcmd->cdb[9] = (u8)(datasize); 1847 1848 sg64 = (struct sgmap64 *) &srbcmd->sg; 1849 sg64->count = cpu_to_le32(1); 1850 sg64->sg[0].addr[1] = cpu_to_le32(upper_32_bits(addr)); 1851 sg64->sg[0].addr[0] = cpu_to_le32(lower_32_bits(addr)); 1852 sg64->sg[0].count = cpu_to_le32(datasize); 1853 1854 rcode = aac_fib_send(ScsiPortCommand64, fibptr, fibsize, 1855 FsaNormal, 1, 1, NULL, NULL); 1856 1857 /* analyse data */ 1858 if (rcode >= 0 && phys_luns->resp_flag == 2) { 1859 /* ok and extended reporting */ 1860 aac_update_hba_map(dev, phys_luns, rescan); 1861 } 1862 1863 dma_free_coherent(&dev->pdev->dev, datasize, phys_luns, addr); 1864 err_out: 1865 return rcode; 1866 } 1867 1868 int aac_get_adapter_info(struct aac_dev* dev) 1869 { 1870 struct fib* fibptr; 1871 int rcode; 1872 u32 tmp, bus, target; 1873 struct aac_adapter_info *info; 1874 struct aac_bus_info *command; 1875 struct aac_bus_info_response *bus_info; 1876 1877 if (!(fibptr = aac_fib_alloc(dev))) 1878 return -ENOMEM; 1879 1880 aac_fib_init(fibptr); 1881 info = (struct aac_adapter_info *) fib_data(fibptr); 1882 memset(info,0,sizeof(*info)); 1883 1884 rcode = aac_fib_send(RequestAdapterInfo, 1885 fibptr, 1886 sizeof(*info), 1887 FsaNormal, 1888 -1, 1, /* First `interrupt' command uses special wait */ 1889 NULL, 1890 NULL); 1891 1892 if (rcode < 0) { 1893 /* FIB should be freed only after 1894 * getting the response from the F/W */ 1895 if (rcode != -ERESTARTSYS) { 1896 aac_fib_complete(fibptr); 1897 aac_fib_free(fibptr); 1898 } 1899 return rcode; 1900 } 1901 memcpy(&dev->adapter_info, info, sizeof(*info)); 1902 1903 dev->supplement_adapter_info.virt_device_bus = 0xffff; 1904 if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 1905 struct aac_supplement_adapter_info * sinfo; 1906 1907 aac_fib_init(fibptr); 1908 1909 sinfo = (struct aac_supplement_adapter_info *) fib_data(fibptr); 1910 1911 memset(sinfo,0,sizeof(*sinfo)); 1912 1913 rcode = aac_fib_send(RequestSupplementAdapterInfo, 1914 fibptr, 1915 sizeof(*sinfo), 1916 FsaNormal, 1917 1, 1, 1918 NULL, 1919 NULL); 1920 1921 if (rcode >= 0) 1922 memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo)); 1923 if (rcode == -ERESTARTSYS) { 1924 fibptr = aac_fib_alloc(dev); 1925 if (!fibptr) 1926 return -ENOMEM; 1927 } 1928 1929 } 1930 1931 /* reset all previous mapped devices (i.e. for init. after IOP_RESET) */ 1932 for (bus = 0; bus < AAC_MAX_BUSES; bus++) { 1933 for (target = 0; target < AAC_MAX_TARGETS; target++) { 1934 dev->hba_map[bus][target].devtype = 0; 1935 dev->hba_map[bus][target].qd_limit = 0; 1936 } 1937 } 1938 1939 /* 1940 * GetBusInfo 1941 */ 1942 1943 aac_fib_init(fibptr); 1944 1945 bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 1946 1947 memset(bus_info, 0, sizeof(*bus_info)); 1948 1949 command = (struct aac_bus_info *)bus_info; 1950 1951 command->Command = cpu_to_le32(VM_Ioctl); 1952 command->ObjType = cpu_to_le32(FT_DRIVE); 1953 command->MethodId = cpu_to_le32(1); 1954 command->CtlCmd = cpu_to_le32(GetBusInfo); 1955 1956 rcode = aac_fib_send(ContainerCommand, 1957 fibptr, 1958 sizeof (*bus_info), 1959 FsaNormal, 1960 1, 1, 1961 NULL, NULL); 1962 1963 /* reasoned default */ 1964 dev->maximum_num_physicals = 16; 1965 if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 1966 dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 1967 dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 1968 } 1969 1970 if (!dev->sync_mode && dev->sa_firmware && 1971 dev->supplement_adapter_info.virt_device_bus != 0xffff) { 1972 /* Thor SA Firmware -> CISS_REPORT_PHYSICAL_LUNS */ 1973 rcode = aac_report_phys_luns(dev, fibptr, AAC_INIT); 1974 } 1975 1976 if (!dev->in_reset) { 1977 char buffer[16]; 1978 tmp = le32_to_cpu(dev->adapter_info.kernelrev); 1979 printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 1980 dev->name, 1981 dev->id, 1982 tmp>>24, 1983 (tmp>>16)&0xff, 1984 tmp&0xff, 1985 le32_to_cpu(dev->adapter_info.kernelbuild), 1986 (int)sizeof(dev->supplement_adapter_info.build_date), 1987 dev->supplement_adapter_info.build_date); 1988 tmp = le32_to_cpu(dev->adapter_info.monitorrev); 1989 printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 1990 dev->name, dev->id, 1991 tmp>>24,(tmp>>16)&0xff,tmp&0xff, 1992 le32_to_cpu(dev->adapter_info.monitorbuild)); 1993 tmp = le32_to_cpu(dev->adapter_info.biosrev); 1994 printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 1995 dev->name, dev->id, 1996 tmp>>24,(tmp>>16)&0xff,tmp&0xff, 1997 le32_to_cpu(dev->adapter_info.biosbuild)); 1998 buffer[0] = '\0'; 1999 if (aac_get_serial_number( 2000 shost_to_class(dev->scsi_host_ptr), buffer)) 2001 printk(KERN_INFO "%s%d: serial %s", 2002 dev->name, dev->id, buffer); 2003 if (dev->supplement_adapter_info.vpd_info.tsid[0]) { 2004 printk(KERN_INFO "%s%d: TSID %.*s\n", 2005 dev->name, dev->id, 2006 (int)sizeof(dev->supplement_adapter_info 2007 .vpd_info.tsid), 2008 dev->supplement_adapter_info.vpd_info.tsid); 2009 } 2010 if (!aac_check_reset || ((aac_check_reset == 1) && 2011 (dev->supplement_adapter_info.supported_options2 & 2012 AAC_OPTION_IGNORE_RESET))) { 2013 printk(KERN_INFO "%s%d: Reset Adapter Ignored\n", 2014 dev->name, dev->id); 2015 } 2016 } 2017 2018 dev->cache_protected = 0; 2019 dev->jbod = ((dev->supplement_adapter_info.feature_bits & 2020 AAC_FEATURE_JBOD) != 0); 2021 dev->nondasd_support = 0; 2022 dev->raid_scsi_mode = 0; 2023 if(dev->adapter_info.options & AAC_OPT_NONDASD) 2024 dev->nondasd_support = 1; 2025 2026 /* 2027 * If the firmware supports ROMB RAID/SCSI mode and we are currently 2028 * in RAID/SCSI mode, set the flag. For now if in this mode we will 2029 * force nondasd support on. If we decide to allow the non-dasd flag 2030 * additional changes changes will have to be made to support 2031 * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 2032 * changed to support the new dev->raid_scsi_mode flag instead of 2033 * leaching off of the dev->nondasd_support flag. Also in linit.c the 2034 * function aac_detect will have to be modified where it sets up the 2035 * max number of channels based on the aac->nondasd_support flag only. 2036 */ 2037 if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 2038 (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 2039 dev->nondasd_support = 1; 2040 dev->raid_scsi_mode = 1; 2041 } 2042 if (dev->raid_scsi_mode != 0) 2043 printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 2044 dev->name, dev->id); 2045 2046 if (nondasd != -1) 2047 dev->nondasd_support = (nondasd!=0); 2048 if (dev->nondasd_support && !dev->in_reset) 2049 printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 2050 2051 if (dma_get_required_mask(&dev->pdev->dev) > DMA_BIT_MASK(32)) 2052 dev->needs_dac = 1; 2053 dev->dac_support = 0; 2054 if ((sizeof(dma_addr_t) > 4) && dev->needs_dac && 2055 (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)) { 2056 if (!dev->in_reset) 2057 printk(KERN_INFO "%s%d: 64bit support enabled.\n", 2058 dev->name, dev->id); 2059 dev->dac_support = 1; 2060 } 2061 2062 if(dacmode != -1) { 2063 dev->dac_support = (dacmode!=0); 2064 } 2065 2066 /* avoid problems with AAC_QUIRK_SCSI_32 controllers */ 2067 if (dev->dac_support && (aac_get_driver_ident(dev->cardtype)->quirks 2068 & AAC_QUIRK_SCSI_32)) { 2069 dev->nondasd_support = 0; 2070 dev->jbod = 0; 2071 expose_physicals = 0; 2072 } 2073 2074 if(dev->dac_support != 0) { 2075 if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(64)) && 2076 !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(64))) { 2077 if (!dev->in_reset) 2078 printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 2079 dev->name, dev->id); 2080 } else if (!pci_set_dma_mask(dev->pdev, DMA_BIT_MASK(32)) && 2081 !pci_set_consistent_dma_mask(dev->pdev, DMA_BIT_MASK(32))) { 2082 printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 2083 dev->name, dev->id); 2084 dev->dac_support = 0; 2085 } else { 2086 printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 2087 dev->name, dev->id); 2088 rcode = -ENOMEM; 2089 } 2090 } 2091 /* 2092 * Deal with configuring for the individualized limits of each packet 2093 * interface. 2094 */ 2095 dev->a_ops.adapter_scsi = (dev->dac_support) 2096 ? ((aac_get_driver_ident(dev->cardtype)->quirks & AAC_QUIRK_SCSI_32) 2097 ? aac_scsi_32_64 2098 : aac_scsi_64) 2099 : aac_scsi_32; 2100 if (dev->raw_io_interface) { 2101 dev->a_ops.adapter_bounds = (dev->raw_io_64) 2102 ? aac_bounds_64 2103 : aac_bounds_32; 2104 dev->a_ops.adapter_read = aac_read_raw_io; 2105 dev->a_ops.adapter_write = aac_write_raw_io; 2106 } else { 2107 dev->a_ops.adapter_bounds = aac_bounds_32; 2108 dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 2109 sizeof(struct aac_fibhdr) - 2110 sizeof(struct aac_write) + sizeof(struct sgentry)) / 2111 sizeof(struct sgentry); 2112 if (dev->dac_support) { 2113 dev->a_ops.adapter_read = aac_read_block64; 2114 dev->a_ops.adapter_write = aac_write_block64; 2115 /* 2116 * 38 scatter gather elements 2117 */ 2118 dev->scsi_host_ptr->sg_tablesize = 2119 (dev->max_fib_size - 2120 sizeof(struct aac_fibhdr) - 2121 sizeof(struct aac_write64) + 2122 sizeof(struct sgentry64)) / 2123 sizeof(struct sgentry64); 2124 } else { 2125 dev->a_ops.adapter_read = aac_read_block; 2126 dev->a_ops.adapter_write = aac_write_block; 2127 } 2128 dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 2129 if (!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 2130 /* 2131 * Worst case size that could cause sg overflow when 2132 * we break up SG elements that are larger than 64KB. 2133 * Would be nice if we could tell the SCSI layer what 2134 * the maximum SG element size can be. Worst case is 2135 * (sg_tablesize-1) 4KB elements with one 64KB 2136 * element. 2137 * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 2138 */ 2139 dev->scsi_host_ptr->max_sectors = 2140 (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 2141 } 2142 } 2143 if (!dev->sync_mode && dev->sa_firmware && 2144 dev->scsi_host_ptr->sg_tablesize > HBA_MAX_SG_SEPARATE) 2145 dev->scsi_host_ptr->sg_tablesize = dev->sg_tablesize = 2146 HBA_MAX_SG_SEPARATE; 2147 2148 /* FIB should be freed only after getting the response from the F/W */ 2149 if (rcode != -ERESTARTSYS) { 2150 aac_fib_complete(fibptr); 2151 aac_fib_free(fibptr); 2152 } 2153 2154 return rcode; 2155 } 2156 2157 2158 static void io_callback(void *context, struct fib * fibptr) 2159 { 2160 struct aac_dev *dev; 2161 struct aac_read_reply *readreply; 2162 struct scsi_cmnd *scsicmd; 2163 u32 cid; 2164 2165 scsicmd = (struct scsi_cmnd *) context; 2166 2167 if (!aac_valid_context(scsicmd, fibptr)) 2168 return; 2169 2170 dev = fibptr->dev; 2171 cid = scmd_id(scsicmd); 2172 2173 if (nblank(dprintk(x))) { 2174 u64 lba; 2175 switch (scsicmd->cmnd[0]) { 2176 case WRITE_6: 2177 case READ_6: 2178 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 2179 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 2180 break; 2181 case WRITE_16: 2182 case READ_16: 2183 lba = ((u64)scsicmd->cmnd[2] << 56) | 2184 ((u64)scsicmd->cmnd[3] << 48) | 2185 ((u64)scsicmd->cmnd[4] << 40) | 2186 ((u64)scsicmd->cmnd[5] << 32) | 2187 ((u64)scsicmd->cmnd[6] << 24) | 2188 (scsicmd->cmnd[7] << 16) | 2189 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 2190 break; 2191 case WRITE_12: 2192 case READ_12: 2193 lba = ((u64)scsicmd->cmnd[2] << 24) | 2194 (scsicmd->cmnd[3] << 16) | 2195 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2196 break; 2197 default: 2198 lba = ((u64)scsicmd->cmnd[2] << 24) | 2199 (scsicmd->cmnd[3] << 16) | 2200 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2201 break; 2202 } 2203 printk(KERN_DEBUG 2204 "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 2205 smp_processor_id(), (unsigned long long)lba, jiffies); 2206 } 2207 2208 BUG_ON(fibptr == NULL); 2209 2210 scsi_dma_unmap(scsicmd); 2211 2212 readreply = (struct aac_read_reply *)fib_data(fibptr); 2213 switch (le32_to_cpu(readreply->status)) { 2214 case ST_OK: 2215 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2216 SAM_STAT_GOOD; 2217 dev->fsa_dev[cid].sense_data.sense_key = NO_SENSE; 2218 break; 2219 case ST_NOT_READY: 2220 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2221 SAM_STAT_CHECK_CONDITION; 2222 set_sense(&dev->fsa_dev[cid].sense_data, NOT_READY, 2223 SENCODE_BECOMING_READY, ASENCODE_BECOMING_READY, 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 break; 2228 case ST_MEDERR: 2229 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2230 SAM_STAT_CHECK_CONDITION; 2231 set_sense(&dev->fsa_dev[cid].sense_data, MEDIUM_ERROR, 2232 SENCODE_UNRECOVERED_READ_ERROR, ASENCODE_NO_SENSE, 0, 0); 2233 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2234 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2235 SCSI_SENSE_BUFFERSIZE)); 2236 break; 2237 default: 2238 #ifdef AAC_DETAILED_STATUS_INFO 2239 printk(KERN_WARNING "io_callback: io failed, status = %d\n", 2240 le32_to_cpu(readreply->status)); 2241 #endif 2242 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2243 SAM_STAT_CHECK_CONDITION; 2244 set_sense(&dev->fsa_dev[cid].sense_data, 2245 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 2246 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 2247 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2248 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2249 SCSI_SENSE_BUFFERSIZE)); 2250 break; 2251 } 2252 aac_fib_complete(fibptr); 2253 2254 scsicmd->scsi_done(scsicmd); 2255 } 2256 2257 static int aac_read(struct scsi_cmnd * scsicmd) 2258 { 2259 u64 lba; 2260 u32 count; 2261 int status; 2262 struct aac_dev *dev; 2263 struct fib * cmd_fibcontext; 2264 int cid; 2265 2266 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2267 /* 2268 * Get block address and transfer length 2269 */ 2270 switch (scsicmd->cmnd[0]) { 2271 case READ_6: 2272 dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", scmd_id(scsicmd))); 2273 2274 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 2275 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 2276 count = scsicmd->cmnd[4]; 2277 2278 if (count == 0) 2279 count = 256; 2280 break; 2281 case READ_16: 2282 dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", scmd_id(scsicmd))); 2283 2284 lba = ((u64)scsicmd->cmnd[2] << 56) | 2285 ((u64)scsicmd->cmnd[3] << 48) | 2286 ((u64)scsicmd->cmnd[4] << 40) | 2287 ((u64)scsicmd->cmnd[5] << 32) | 2288 ((u64)scsicmd->cmnd[6] << 24) | 2289 (scsicmd->cmnd[7] << 16) | 2290 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 2291 count = (scsicmd->cmnd[10] << 24) | 2292 (scsicmd->cmnd[11] << 16) | 2293 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 2294 break; 2295 case READ_12: 2296 dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", scmd_id(scsicmd))); 2297 2298 lba = ((u64)scsicmd->cmnd[2] << 24) | 2299 (scsicmd->cmnd[3] << 16) | 2300 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2301 count = (scsicmd->cmnd[6] << 24) | 2302 (scsicmd->cmnd[7] << 16) | 2303 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 2304 break; 2305 default: 2306 dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", scmd_id(scsicmd))); 2307 2308 lba = ((u64)scsicmd->cmnd[2] << 24) | 2309 (scsicmd->cmnd[3] << 16) | 2310 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2311 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 2312 break; 2313 } 2314 2315 if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 2316 cid = scmd_id(scsicmd); 2317 dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 2318 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2319 SAM_STAT_CHECK_CONDITION; 2320 set_sense(&dev->fsa_dev[cid].sense_data, 2321 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 2322 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 2323 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2324 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2325 SCSI_SENSE_BUFFERSIZE)); 2326 scsicmd->scsi_done(scsicmd); 2327 return 1; 2328 } 2329 2330 dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 2331 smp_processor_id(), (unsigned long long)lba, jiffies)); 2332 if (aac_adapter_bounds(dev,scsicmd,lba)) 2333 return 0; 2334 /* 2335 * Alocate and initialize a Fib 2336 */ 2337 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 2338 2339 status = aac_adapter_read(cmd_fibcontext, scsicmd, lba, count); 2340 2341 /* 2342 * Check that the command queued to the controller 2343 */ 2344 if (status == -EINPROGRESS) { 2345 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2346 return 0; 2347 } 2348 2349 printk(KERN_WARNING "aac_read: aac_fib_send failed with status: %d.\n", status); 2350 /* 2351 * For some reason, the Fib didn't queue, return QUEUE_FULL 2352 */ 2353 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 2354 scsicmd->scsi_done(scsicmd); 2355 aac_fib_complete(cmd_fibcontext); 2356 aac_fib_free(cmd_fibcontext); 2357 return 0; 2358 } 2359 2360 static int aac_write(struct scsi_cmnd * scsicmd) 2361 { 2362 u64 lba; 2363 u32 count; 2364 int fua; 2365 int status; 2366 struct aac_dev *dev; 2367 struct fib * cmd_fibcontext; 2368 int cid; 2369 2370 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2371 /* 2372 * Get block address and transfer length 2373 */ 2374 if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 2375 { 2376 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 2377 count = scsicmd->cmnd[4]; 2378 if (count == 0) 2379 count = 256; 2380 fua = 0; 2381 } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 2382 dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", scmd_id(scsicmd))); 2383 2384 lba = ((u64)scsicmd->cmnd[2] << 56) | 2385 ((u64)scsicmd->cmnd[3] << 48) | 2386 ((u64)scsicmd->cmnd[4] << 40) | 2387 ((u64)scsicmd->cmnd[5] << 32) | 2388 ((u64)scsicmd->cmnd[6] << 24) | 2389 (scsicmd->cmnd[7] << 16) | 2390 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 2391 count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 2392 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 2393 fua = scsicmd->cmnd[1] & 0x8; 2394 } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 2395 dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", scmd_id(scsicmd))); 2396 2397 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 2398 | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2399 count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 2400 | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 2401 fua = scsicmd->cmnd[1] & 0x8; 2402 } else { 2403 dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", scmd_id(scsicmd))); 2404 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2405 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 2406 fua = scsicmd->cmnd[1] & 0x8; 2407 } 2408 2409 if ((lba + count) > (dev->fsa_dev[scmd_id(scsicmd)].size)) { 2410 cid = scmd_id(scsicmd); 2411 dprintk((KERN_DEBUG "aacraid: Illegal lba\n")); 2412 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2413 SAM_STAT_CHECK_CONDITION; 2414 set_sense(&dev->fsa_dev[cid].sense_data, 2415 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 2416 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 2417 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2418 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2419 SCSI_SENSE_BUFFERSIZE)); 2420 scsicmd->scsi_done(scsicmd); 2421 return 1; 2422 } 2423 2424 dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 2425 smp_processor_id(), (unsigned long long)lba, jiffies)); 2426 if (aac_adapter_bounds(dev,scsicmd,lba)) 2427 return 0; 2428 /* 2429 * Allocate and initialize a Fib then setup a BlockWrite command 2430 */ 2431 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 2432 2433 status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua); 2434 2435 /* 2436 * Check that the command queued to the controller 2437 */ 2438 if (status == -EINPROGRESS) { 2439 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2440 return 0; 2441 } 2442 2443 printk(KERN_WARNING "aac_write: aac_fib_send failed with status: %d\n", status); 2444 /* 2445 * For some reason, the Fib didn't queue, return QUEUE_FULL 2446 */ 2447 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 2448 scsicmd->scsi_done(scsicmd); 2449 2450 aac_fib_complete(cmd_fibcontext); 2451 aac_fib_free(cmd_fibcontext); 2452 return 0; 2453 } 2454 2455 static void synchronize_callback(void *context, struct fib *fibptr) 2456 { 2457 struct aac_synchronize_reply *synchronizereply; 2458 struct scsi_cmnd *cmd; 2459 2460 cmd = context; 2461 2462 if (!aac_valid_context(cmd, fibptr)) 2463 return; 2464 2465 dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 2466 smp_processor_id(), jiffies)); 2467 BUG_ON(fibptr == NULL); 2468 2469 2470 synchronizereply = fib_data(fibptr); 2471 if (le32_to_cpu(synchronizereply->status) == CT_OK) 2472 cmd->result = DID_OK << 16 | 2473 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 2474 else { 2475 struct scsi_device *sdev = cmd->device; 2476 struct aac_dev *dev = fibptr->dev; 2477 u32 cid = sdev_id(sdev); 2478 printk(KERN_WARNING 2479 "synchronize_callback: synchronize failed, status = %d\n", 2480 le32_to_cpu(synchronizereply->status)); 2481 cmd->result = DID_OK << 16 | 2482 COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 2483 set_sense(&dev->fsa_dev[cid].sense_data, 2484 HARDWARE_ERROR, SENCODE_INTERNAL_TARGET_FAILURE, 2485 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0); 2486 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2487 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2488 SCSI_SENSE_BUFFERSIZE)); 2489 } 2490 2491 aac_fib_complete(fibptr); 2492 aac_fib_free(fibptr); 2493 cmd->scsi_done(cmd); 2494 } 2495 2496 static int aac_synchronize(struct scsi_cmnd *scsicmd) 2497 { 2498 int status; 2499 struct fib *cmd_fibcontext; 2500 struct aac_synchronize *synchronizecmd; 2501 struct scsi_cmnd *cmd; 2502 struct scsi_device *sdev = scsicmd->device; 2503 int active = 0; 2504 struct aac_dev *aac; 2505 u64 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | 2506 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 2507 u32 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 2508 unsigned long flags; 2509 2510 /* 2511 * Wait for all outstanding queued commands to complete to this 2512 * specific target (block). 2513 */ 2514 spin_lock_irqsave(&sdev->list_lock, flags); 2515 list_for_each_entry(cmd, &sdev->cmd_list, list) 2516 if (cmd->SCp.phase == AAC_OWNER_FIRMWARE) { 2517 u64 cmnd_lba; 2518 u32 cmnd_count; 2519 2520 if (cmd->cmnd[0] == WRITE_6) { 2521 cmnd_lba = ((cmd->cmnd[1] & 0x1F) << 16) | 2522 (cmd->cmnd[2] << 8) | 2523 cmd->cmnd[3]; 2524 cmnd_count = cmd->cmnd[4]; 2525 if (cmnd_count == 0) 2526 cmnd_count = 256; 2527 } else if (cmd->cmnd[0] == WRITE_16) { 2528 cmnd_lba = ((u64)cmd->cmnd[2] << 56) | 2529 ((u64)cmd->cmnd[3] << 48) | 2530 ((u64)cmd->cmnd[4] << 40) | 2531 ((u64)cmd->cmnd[5] << 32) | 2532 ((u64)cmd->cmnd[6] << 24) | 2533 (cmd->cmnd[7] << 16) | 2534 (cmd->cmnd[8] << 8) | 2535 cmd->cmnd[9]; 2536 cmnd_count = (cmd->cmnd[10] << 24) | 2537 (cmd->cmnd[11] << 16) | 2538 (cmd->cmnd[12] << 8) | 2539 cmd->cmnd[13]; 2540 } else if (cmd->cmnd[0] == WRITE_12) { 2541 cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 2542 (cmd->cmnd[3] << 16) | 2543 (cmd->cmnd[4] << 8) | 2544 cmd->cmnd[5]; 2545 cmnd_count = (cmd->cmnd[6] << 24) | 2546 (cmd->cmnd[7] << 16) | 2547 (cmd->cmnd[8] << 8) | 2548 cmd->cmnd[9]; 2549 } else if (cmd->cmnd[0] == WRITE_10) { 2550 cmnd_lba = ((u64)cmd->cmnd[2] << 24) | 2551 (cmd->cmnd[3] << 16) | 2552 (cmd->cmnd[4] << 8) | 2553 cmd->cmnd[5]; 2554 cmnd_count = (cmd->cmnd[7] << 8) | 2555 cmd->cmnd[8]; 2556 } else 2557 continue; 2558 if (((cmnd_lba + cmnd_count) < lba) || 2559 (count && ((lba + count) < cmnd_lba))) 2560 continue; 2561 ++active; 2562 break; 2563 } 2564 2565 spin_unlock_irqrestore(&sdev->list_lock, flags); 2566 2567 /* 2568 * Yield the processor (requeue for later) 2569 */ 2570 if (active) 2571 return SCSI_MLQUEUE_DEVICE_BUSY; 2572 2573 aac = (struct aac_dev *)sdev->host->hostdata; 2574 if (aac->in_reset) 2575 return SCSI_MLQUEUE_HOST_BUSY; 2576 2577 /* 2578 * Allocate and initialize a Fib 2579 */ 2580 if (!(cmd_fibcontext = aac_fib_alloc(aac))) 2581 return SCSI_MLQUEUE_HOST_BUSY; 2582 2583 aac_fib_init(cmd_fibcontext); 2584 2585 synchronizecmd = fib_data(cmd_fibcontext); 2586 synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 2587 synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 2588 synchronizecmd->cid = cpu_to_le32(scmd_id(scsicmd)); 2589 synchronizecmd->count = 2590 cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 2591 2592 /* 2593 * Now send the Fib to the adapter 2594 */ 2595 status = aac_fib_send(ContainerCommand, 2596 cmd_fibcontext, 2597 sizeof(struct aac_synchronize), 2598 FsaNormal, 2599 0, 1, 2600 (fib_callback)synchronize_callback, 2601 (void *)scsicmd); 2602 2603 /* 2604 * Check that the command queued to the controller 2605 */ 2606 if (status == -EINPROGRESS) { 2607 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2608 return 0; 2609 } 2610 2611 printk(KERN_WARNING 2612 "aac_synchronize: aac_fib_send failed with status: %d.\n", status); 2613 aac_fib_complete(cmd_fibcontext); 2614 aac_fib_free(cmd_fibcontext); 2615 return SCSI_MLQUEUE_HOST_BUSY; 2616 } 2617 2618 static void aac_start_stop_callback(void *context, struct fib *fibptr) 2619 { 2620 struct scsi_cmnd *scsicmd = context; 2621 2622 if (!aac_valid_context(scsicmd, fibptr)) 2623 return; 2624 2625 BUG_ON(fibptr == NULL); 2626 2627 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 2628 2629 aac_fib_complete(fibptr); 2630 aac_fib_free(fibptr); 2631 scsicmd->scsi_done(scsicmd); 2632 } 2633 2634 static int aac_start_stop(struct scsi_cmnd *scsicmd) 2635 { 2636 int status; 2637 struct fib *cmd_fibcontext; 2638 struct aac_power_management *pmcmd; 2639 struct scsi_device *sdev = scsicmd->device; 2640 struct aac_dev *aac = (struct aac_dev *)sdev->host->hostdata; 2641 2642 if (!(aac->supplement_adapter_info.supported_options2 & 2643 AAC_OPTION_POWER_MANAGEMENT)) { 2644 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 2645 SAM_STAT_GOOD; 2646 scsicmd->scsi_done(scsicmd); 2647 return 0; 2648 } 2649 2650 if (aac->in_reset) 2651 return SCSI_MLQUEUE_HOST_BUSY; 2652 2653 /* 2654 * Allocate and initialize a Fib 2655 */ 2656 cmd_fibcontext = aac_fib_alloc_tag(aac, scsicmd); 2657 2658 aac_fib_init(cmd_fibcontext); 2659 2660 pmcmd = fib_data(cmd_fibcontext); 2661 pmcmd->command = cpu_to_le32(VM_ContainerConfig); 2662 pmcmd->type = cpu_to_le32(CT_POWER_MANAGEMENT); 2663 /* Eject bit ignored, not relevant */ 2664 pmcmd->sub = (scsicmd->cmnd[4] & 1) ? 2665 cpu_to_le32(CT_PM_START_UNIT) : cpu_to_le32(CT_PM_STOP_UNIT); 2666 pmcmd->cid = cpu_to_le32(sdev_id(sdev)); 2667 pmcmd->parm = (scsicmd->cmnd[1] & 1) ? 2668 cpu_to_le32(CT_PM_UNIT_IMMEDIATE) : 0; 2669 2670 /* 2671 * Now send the Fib to the adapter 2672 */ 2673 status = aac_fib_send(ContainerCommand, 2674 cmd_fibcontext, 2675 sizeof(struct aac_power_management), 2676 FsaNormal, 2677 0, 1, 2678 (fib_callback)aac_start_stop_callback, 2679 (void *)scsicmd); 2680 2681 /* 2682 * Check that the command queued to the controller 2683 */ 2684 if (status == -EINPROGRESS) { 2685 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 2686 return 0; 2687 } 2688 2689 aac_fib_complete(cmd_fibcontext); 2690 aac_fib_free(cmd_fibcontext); 2691 return SCSI_MLQUEUE_HOST_BUSY; 2692 } 2693 2694 /** 2695 * aac_scsi_cmd() - Process SCSI command 2696 * @scsicmd: SCSI command block 2697 * 2698 * Emulate a SCSI command and queue the required request for the 2699 * aacraid firmware. 2700 */ 2701 2702 int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 2703 { 2704 u32 cid, bus; 2705 struct Scsi_Host *host = scsicmd->device->host; 2706 struct aac_dev *dev = (struct aac_dev *)host->hostdata; 2707 struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 2708 2709 if (fsa_dev_ptr == NULL) 2710 return -1; 2711 /* 2712 * If the bus, id or lun is out of range, return fail 2713 * Test does not apply to ID 16, the pseudo id for the controller 2714 * itself. 2715 */ 2716 cid = scmd_id(scsicmd); 2717 if (cid != host->this_id) { 2718 if (scmd_channel(scsicmd) == CONTAINER_CHANNEL) { 2719 if((cid >= dev->maximum_num_containers) || 2720 (scsicmd->device->lun != 0)) { 2721 scsicmd->result = DID_NO_CONNECT << 16; 2722 goto scsi_done_ret; 2723 } 2724 2725 /* 2726 * If the target container doesn't exist, it may have 2727 * been newly created 2728 */ 2729 if (((fsa_dev_ptr[cid].valid & 1) == 0) || 2730 (fsa_dev_ptr[cid].sense_data.sense_key == 2731 NOT_READY)) { 2732 switch (scsicmd->cmnd[0]) { 2733 case SERVICE_ACTION_IN_16: 2734 if (!(dev->raw_io_interface) || 2735 !(dev->raw_io_64) || 2736 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 2737 break; 2738 case INQUIRY: 2739 case READ_CAPACITY: 2740 case TEST_UNIT_READY: 2741 if (dev->in_reset) 2742 return -1; 2743 return _aac_probe_container(scsicmd, 2744 aac_probe_container_callback2); 2745 default: 2746 break; 2747 } 2748 } 2749 } else { /* check for physical non-dasd devices */ 2750 bus = aac_logical_to_phys(scmd_channel(scsicmd)); 2751 if (bus < AAC_MAX_BUSES && cid < AAC_MAX_TARGETS && 2752 (dev->hba_map[bus][cid].expose 2753 == AAC_HIDE_DISK)){ 2754 if (scsicmd->cmnd[0] == INQUIRY) { 2755 scsicmd->result = DID_NO_CONNECT << 16; 2756 goto scsi_done_ret; 2757 } 2758 } 2759 2760 if (bus < AAC_MAX_BUSES && cid < AAC_MAX_TARGETS && 2761 dev->hba_map[bus][cid].devtype 2762 == AAC_DEVTYPE_NATIVE_RAW) { 2763 if (dev->in_reset) 2764 return -1; 2765 return aac_send_hba_fib(scsicmd); 2766 } else if (dev->nondasd_support || expose_physicals || 2767 dev->jbod) { 2768 if (dev->in_reset) 2769 return -1; 2770 return aac_send_srb_fib(scsicmd); 2771 } else { 2772 scsicmd->result = DID_NO_CONNECT << 16; 2773 goto scsi_done_ret; 2774 } 2775 } 2776 } 2777 /* 2778 * else Command for the controller itself 2779 */ 2780 else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 2781 (scsicmd->cmnd[0] != TEST_UNIT_READY)) 2782 { 2783 dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 2784 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 2785 set_sense(&dev->fsa_dev[cid].sense_data, 2786 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 2787 ASENCODE_INVALID_COMMAND, 0, 0); 2788 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 2789 min_t(size_t, sizeof(dev->fsa_dev[cid].sense_data), 2790 SCSI_SENSE_BUFFERSIZE)); 2791 goto scsi_done_ret; 2792 } 2793 2794 switch (scsicmd->cmnd[0]) { 2795 case READ_6: 2796 case READ_10: 2797 case READ_12: 2798 case READ_16: 2799 if (dev->in_reset) 2800 return -1; 2801 return aac_read(scsicmd); 2802 2803 case WRITE_6: 2804 case WRITE_10: 2805 case WRITE_12: 2806 case WRITE_16: 2807 if (dev->in_reset) 2808 return -1; 2809 return aac_write(scsicmd); 2810 2811 case SYNCHRONIZE_CACHE: 2812 if (((aac_cache & 6) == 6) && dev->cache_protected) { 2813 scsicmd->result = AAC_STAT_GOOD; 2814 break; 2815 } 2816 /* Issue FIB to tell Firmware to flush it's cache */ 2817 if ((aac_cache & 6) != 2) 2818 return aac_synchronize(scsicmd); 2819 case INQUIRY: 2820 { 2821 struct inquiry_data inq_data; 2822 2823 dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", cid)); 2824 memset(&inq_data, 0, sizeof (struct inquiry_data)); 2825 2826 if ((scsicmd->cmnd[1] & 0x1) && aac_wwn) { 2827 char *arr = (char *)&inq_data; 2828 2829 /* EVPD bit set */ 2830 arr[0] = (scmd_id(scsicmd) == host->this_id) ? 2831 INQD_PDT_PROC : INQD_PDT_DA; 2832 if (scsicmd->cmnd[2] == 0) { 2833 /* supported vital product data pages */ 2834 arr[3] = 3; 2835 arr[4] = 0x0; 2836 arr[5] = 0x80; 2837 arr[6] = 0x83; 2838 arr[1] = scsicmd->cmnd[2]; 2839 scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2840 sizeof(inq_data)); 2841 scsicmd->result = AAC_STAT_GOOD; 2842 } else if (scsicmd->cmnd[2] == 0x80) { 2843 /* unit serial number page */ 2844 arr[3] = setinqserial(dev, &arr[4], 2845 scmd_id(scsicmd)); 2846 arr[1] = scsicmd->cmnd[2]; 2847 scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2848 sizeof(inq_data)); 2849 if (aac_wwn != 2) 2850 return aac_get_container_serial( 2851 scsicmd); 2852 scsicmd->result = AAC_STAT_GOOD; 2853 } else if (scsicmd->cmnd[2] == 0x83) { 2854 /* vpd page 0x83 - Device Identification Page */ 2855 char *sno = (char *)&inq_data; 2856 sno[3] = setinqserial(dev, &sno[4], 2857 scmd_id(scsicmd)); 2858 if (aac_wwn != 2) 2859 return aac_get_container_serial( 2860 scsicmd); 2861 scsicmd->result = AAC_STAT_GOOD; 2862 } else { 2863 /* vpd page not implemented */ 2864 scsicmd->result = DID_OK << 16 | 2865 COMMAND_COMPLETE << 8 | 2866 SAM_STAT_CHECK_CONDITION; 2867 set_sense(&dev->fsa_dev[cid].sense_data, 2868 ILLEGAL_REQUEST, SENCODE_INVALID_CDB_FIELD, 2869 ASENCODE_NO_SENSE, 7, 2); 2870 memcpy(scsicmd->sense_buffer, 2871 &dev->fsa_dev[cid].sense_data, 2872 min_t(size_t, 2873 sizeof(dev->fsa_dev[cid].sense_data), 2874 SCSI_SENSE_BUFFERSIZE)); 2875 } 2876 break; 2877 } 2878 inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 2879 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 */ 2880 inq_data.inqd_len = 31; 2881 /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 2882 inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 2883 /* 2884 * Set the Vendor, Product, and Revision Level 2885 * see: <vendor>.c i.e. aac.c 2886 */ 2887 if (cid == host->this_id) { 2888 setinqstr(dev, (void *) (inq_data.inqd_vid), ARRAY_SIZE(container_types)); 2889 inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 2890 scsi_sg_copy_from_buffer(scsicmd, &inq_data, 2891 sizeof(inq_data)); 2892 scsicmd->result = AAC_STAT_GOOD; 2893 break; 2894 } 2895 if (dev->in_reset) 2896 return -1; 2897 setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 2898 inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 2899 scsi_sg_copy_from_buffer(scsicmd, &inq_data, sizeof(inq_data)); 2900 return aac_get_container_name(scsicmd); 2901 } 2902 case SERVICE_ACTION_IN_16: 2903 if (!(dev->raw_io_interface) || 2904 !(dev->raw_io_64) || 2905 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 2906 break; 2907 { 2908 u64 capacity; 2909 char cp[13]; 2910 unsigned int alloc_len; 2911 2912 dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 2913 capacity = fsa_dev_ptr[cid].size - 1; 2914 cp[0] = (capacity >> 56) & 0xff; 2915 cp[1] = (capacity >> 48) & 0xff; 2916 cp[2] = (capacity >> 40) & 0xff; 2917 cp[3] = (capacity >> 32) & 0xff; 2918 cp[4] = (capacity >> 24) & 0xff; 2919 cp[5] = (capacity >> 16) & 0xff; 2920 cp[6] = (capacity >> 8) & 0xff; 2921 cp[7] = (capacity >> 0) & 0xff; 2922 cp[8] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; 2923 cp[9] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; 2924 cp[10] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; 2925 cp[11] = (fsa_dev_ptr[cid].block_size) & 0xff; 2926 cp[12] = 0; 2927 2928 alloc_len = ((scsicmd->cmnd[10] << 24) 2929 + (scsicmd->cmnd[11] << 16) 2930 + (scsicmd->cmnd[12] << 8) + scsicmd->cmnd[13]); 2931 2932 alloc_len = min_t(size_t, alloc_len, sizeof(cp)); 2933 scsi_sg_copy_from_buffer(scsicmd, cp, alloc_len); 2934 if (alloc_len < scsi_bufflen(scsicmd)) 2935 scsi_set_resid(scsicmd, 2936 scsi_bufflen(scsicmd) - alloc_len); 2937 2938 /* Do not cache partition table for arrays */ 2939 scsicmd->device->removable = 1; 2940 2941 scsicmd->result = AAC_STAT_GOOD; 2942 break; 2943 } 2944 2945 case READ_CAPACITY: 2946 { 2947 u32 capacity; 2948 char cp[8]; 2949 2950 dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 2951 if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 2952 capacity = fsa_dev_ptr[cid].size - 1; 2953 else 2954 capacity = (u32)-1; 2955 2956 cp[0] = (capacity >> 24) & 0xff; 2957 cp[1] = (capacity >> 16) & 0xff; 2958 cp[2] = (capacity >> 8) & 0xff; 2959 cp[3] = (capacity >> 0) & 0xff; 2960 cp[4] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; 2961 cp[5] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; 2962 cp[6] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; 2963 cp[7] = (fsa_dev_ptr[cid].block_size) & 0xff; 2964 scsi_sg_copy_from_buffer(scsicmd, cp, sizeof(cp)); 2965 /* Do not cache partition table for arrays */ 2966 scsicmd->device->removable = 1; 2967 scsicmd->result = AAC_STAT_GOOD; 2968 break; 2969 } 2970 2971 case MODE_SENSE: 2972 { 2973 int mode_buf_length = 4; 2974 u32 capacity; 2975 aac_modep_data mpd; 2976 2977 if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 2978 capacity = fsa_dev_ptr[cid].size - 1; 2979 else 2980 capacity = (u32)-1; 2981 2982 dprintk((KERN_DEBUG "MODE SENSE command.\n")); 2983 memset((char *)&mpd, 0, sizeof(aac_modep_data)); 2984 2985 /* Mode data length */ 2986 mpd.hd.data_length = sizeof(mpd.hd) - 1; 2987 /* Medium type - default */ 2988 mpd.hd.med_type = 0; 2989 /* Device-specific param, 2990 bit 8: 0/1 = write enabled/protected 2991 bit 4: 0/1 = FUA enabled */ 2992 mpd.hd.dev_par = 0; 2993 2994 if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 2995 mpd.hd.dev_par = 0x10; 2996 if (scsicmd->cmnd[1] & 0x8) 2997 mpd.hd.bd_length = 0; /* Block descriptor length */ 2998 else { 2999 mpd.hd.bd_length = sizeof(mpd.bd); 3000 mpd.hd.data_length += mpd.hd.bd_length; 3001 mpd.bd.block_length[0] = 3002 (fsa_dev_ptr[cid].block_size >> 16) & 0xff; 3003 mpd.bd.block_length[1] = 3004 (fsa_dev_ptr[cid].block_size >> 8) & 0xff; 3005 mpd.bd.block_length[2] = 3006 fsa_dev_ptr[cid].block_size & 0xff; 3007 3008 mpd.mpc_buf[0] = scsicmd->cmnd[2]; 3009 if (scsicmd->cmnd[2] == 0x1C) { 3010 /* page length */ 3011 mpd.mpc_buf[1] = 0xa; 3012 /* Mode data length */ 3013 mpd.hd.data_length = 23; 3014 } else { 3015 /* Mode data length */ 3016 mpd.hd.data_length = 15; 3017 } 3018 3019 if (capacity > 0xffffff) { 3020 mpd.bd.block_count[0] = 0xff; 3021 mpd.bd.block_count[1] = 0xff; 3022 mpd.bd.block_count[2] = 0xff; 3023 } else { 3024 mpd.bd.block_count[0] = (capacity >> 16) & 0xff; 3025 mpd.bd.block_count[1] = (capacity >> 8) & 0xff; 3026 mpd.bd.block_count[2] = capacity & 0xff; 3027 } 3028 } 3029 if (((scsicmd->cmnd[2] & 0x3f) == 8) || 3030 ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 3031 mpd.hd.data_length += 3; 3032 mpd.mpc_buf[0] = 8; 3033 mpd.mpc_buf[1] = 1; 3034 mpd.mpc_buf[2] = ((aac_cache & 6) == 2) 3035 ? 0 : 0x04; /* WCE */ 3036 mode_buf_length = sizeof(mpd); 3037 } 3038 3039 if (mode_buf_length > scsicmd->cmnd[4]) 3040 mode_buf_length = scsicmd->cmnd[4]; 3041 else 3042 mode_buf_length = sizeof(mpd); 3043 scsi_sg_copy_from_buffer(scsicmd, 3044 (char *)&mpd, 3045 mode_buf_length); 3046 scsicmd->result = AAC_STAT_GOOD; 3047 break; 3048 } 3049 case MODE_SENSE_10: 3050 { 3051 u32 capacity; 3052 int mode_buf_length = 8; 3053 aac_modep10_data mpd10; 3054 3055 if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 3056 capacity = fsa_dev_ptr[cid].size - 1; 3057 else 3058 capacity = (u32)-1; 3059 3060 dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 3061 memset((char *)&mpd10, 0, sizeof(aac_modep10_data)); 3062 /* Mode data length (MSB) */ 3063 mpd10.hd.data_length[0] = 0; 3064 /* Mode data length (LSB) */ 3065 mpd10.hd.data_length[1] = sizeof(mpd10.hd) - 1; 3066 /* Medium type - default */ 3067 mpd10.hd.med_type = 0; 3068 /* Device-specific param, 3069 bit 8: 0/1 = write enabled/protected 3070 bit 4: 0/1 = FUA enabled */ 3071 mpd10.hd.dev_par = 0; 3072 3073 if (dev->raw_io_interface && ((aac_cache & 5) != 1)) 3074 mpd10.hd.dev_par = 0x10; 3075 mpd10.hd.rsrvd[0] = 0; /* reserved */ 3076 mpd10.hd.rsrvd[1] = 0; /* reserved */ 3077 if (scsicmd->cmnd[1] & 0x8) { 3078 /* Block descriptor length (MSB) */ 3079 mpd10.hd.bd_length[0] = 0; 3080 /* Block descriptor length (LSB) */ 3081 mpd10.hd.bd_length[1] = 0; 3082 } else { 3083 mpd10.hd.bd_length[0] = 0; 3084 mpd10.hd.bd_length[1] = sizeof(mpd10.bd); 3085 3086 mpd10.hd.data_length[1] += mpd10.hd.bd_length[1]; 3087 3088 mpd10.bd.block_length[0] = 3089 (fsa_dev_ptr[cid].block_size >> 16) & 0xff; 3090 mpd10.bd.block_length[1] = 3091 (fsa_dev_ptr[cid].block_size >> 8) & 0xff; 3092 mpd10.bd.block_length[2] = 3093 fsa_dev_ptr[cid].block_size & 0xff; 3094 3095 if (capacity > 0xffffff) { 3096 mpd10.bd.block_count[0] = 0xff; 3097 mpd10.bd.block_count[1] = 0xff; 3098 mpd10.bd.block_count[2] = 0xff; 3099 } else { 3100 mpd10.bd.block_count[0] = 3101 (capacity >> 16) & 0xff; 3102 mpd10.bd.block_count[1] = 3103 (capacity >> 8) & 0xff; 3104 mpd10.bd.block_count[2] = 3105 capacity & 0xff; 3106 } 3107 } 3108 if (((scsicmd->cmnd[2] & 0x3f) == 8) || 3109 ((scsicmd->cmnd[2] & 0x3f) == 0x3f)) { 3110 mpd10.hd.data_length[1] += 3; 3111 mpd10.mpc_buf[0] = 8; 3112 mpd10.mpc_buf[1] = 1; 3113 mpd10.mpc_buf[2] = ((aac_cache & 6) == 2) 3114 ? 0 : 0x04; /* WCE */ 3115 mode_buf_length = sizeof(mpd10); 3116 if (mode_buf_length > scsicmd->cmnd[8]) 3117 mode_buf_length = scsicmd->cmnd[8]; 3118 } 3119 scsi_sg_copy_from_buffer(scsicmd, 3120 (char *)&mpd10, 3121 mode_buf_length); 3122 3123 scsicmd->result = AAC_STAT_GOOD; 3124 break; 3125 } 3126 case REQUEST_SENSE: 3127 dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 3128 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 3129 sizeof(struct sense_data)); 3130 memset(&dev->fsa_dev[cid].sense_data, 0, 3131 sizeof(struct sense_data)); 3132 scsicmd->result = AAC_STAT_GOOD; 3133 break; 3134 3135 case ALLOW_MEDIUM_REMOVAL: 3136 dprintk((KERN_DEBUG "LOCK command.\n")); 3137 if (scsicmd->cmnd[4]) 3138 fsa_dev_ptr[cid].locked = 1; 3139 else 3140 fsa_dev_ptr[cid].locked = 0; 3141 3142 scsicmd->result = AAC_STAT_GOOD; 3143 break; 3144 /* 3145 * These commands are all No-Ops 3146 */ 3147 case TEST_UNIT_READY: 3148 if (fsa_dev_ptr[cid].sense_data.sense_key == NOT_READY) { 3149 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 3150 SAM_STAT_CHECK_CONDITION; 3151 set_sense(&dev->fsa_dev[cid].sense_data, 3152 NOT_READY, SENCODE_BECOMING_READY, 3153 ASENCODE_BECOMING_READY, 0, 0); 3154 memcpy(scsicmd->sense_buffer, 3155 &dev->fsa_dev[cid].sense_data, 3156 min_t(size_t, 3157 sizeof(dev->fsa_dev[cid].sense_data), 3158 SCSI_SENSE_BUFFERSIZE)); 3159 break; 3160 } 3161 case RESERVE: 3162 case RELEASE: 3163 case REZERO_UNIT: 3164 case REASSIGN_BLOCKS: 3165 case SEEK_10: 3166 scsicmd->result = AAC_STAT_GOOD; 3167 break; 3168 3169 case START_STOP: 3170 return aac_start_stop(scsicmd); 3171 3172 /* FALLTHRU */ 3173 default: 3174 /* 3175 * Unhandled commands 3176 */ 3177 dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", 3178 scsicmd->cmnd[0])); 3179 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 3180 SAM_STAT_CHECK_CONDITION; 3181 set_sense(&dev->fsa_dev[cid].sense_data, 3182 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 3183 ASENCODE_INVALID_COMMAND, 0, 0); 3184 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 3185 min_t(size_t, 3186 sizeof(dev->fsa_dev[cid].sense_data), 3187 SCSI_SENSE_BUFFERSIZE)); 3188 } 3189 3190 scsi_done_ret: 3191 3192 scsicmd->scsi_done(scsicmd); 3193 return 0; 3194 } 3195 3196 static int query_disk(struct aac_dev *dev, void __user *arg) 3197 { 3198 struct aac_query_disk qd; 3199 struct fsa_dev_info *fsa_dev_ptr; 3200 3201 fsa_dev_ptr = dev->fsa_dev; 3202 if (!fsa_dev_ptr) 3203 return -EBUSY; 3204 if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 3205 return -EFAULT; 3206 if (qd.cnum == -1) 3207 qd.cnum = qd.id; 3208 else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 3209 { 3210 if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 3211 return -EINVAL; 3212 qd.instance = dev->scsi_host_ptr->host_no; 3213 qd.bus = 0; 3214 qd.id = CONTAINER_TO_ID(qd.cnum); 3215 qd.lun = CONTAINER_TO_LUN(qd.cnum); 3216 } 3217 else return -EINVAL; 3218 3219 qd.valid = fsa_dev_ptr[qd.cnum].valid != 0; 3220 qd.locked = fsa_dev_ptr[qd.cnum].locked; 3221 qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 3222 3223 if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 3224 qd.unmapped = 1; 3225 else 3226 qd.unmapped = 0; 3227 3228 strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 3229 min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 3230 3231 if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 3232 return -EFAULT; 3233 return 0; 3234 } 3235 3236 static int force_delete_disk(struct aac_dev *dev, void __user *arg) 3237 { 3238 struct aac_delete_disk dd; 3239 struct fsa_dev_info *fsa_dev_ptr; 3240 3241 fsa_dev_ptr = dev->fsa_dev; 3242 if (!fsa_dev_ptr) 3243 return -EBUSY; 3244 3245 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 3246 return -EFAULT; 3247 3248 if (dd.cnum >= dev->maximum_num_containers) 3249 return -EINVAL; 3250 /* 3251 * Mark this container as being deleted. 3252 */ 3253 fsa_dev_ptr[dd.cnum].deleted = 1; 3254 /* 3255 * Mark the container as no longer valid 3256 */ 3257 fsa_dev_ptr[dd.cnum].valid = 0; 3258 return 0; 3259 } 3260 3261 static int delete_disk(struct aac_dev *dev, void __user *arg) 3262 { 3263 struct aac_delete_disk dd; 3264 struct fsa_dev_info *fsa_dev_ptr; 3265 3266 fsa_dev_ptr = dev->fsa_dev; 3267 if (!fsa_dev_ptr) 3268 return -EBUSY; 3269 3270 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 3271 return -EFAULT; 3272 3273 if (dd.cnum >= dev->maximum_num_containers) 3274 return -EINVAL; 3275 /* 3276 * If the container is locked, it can not be deleted by the API. 3277 */ 3278 if (fsa_dev_ptr[dd.cnum].locked) 3279 return -EBUSY; 3280 else { 3281 /* 3282 * Mark the container as no longer being valid. 3283 */ 3284 fsa_dev_ptr[dd.cnum].valid = 0; 3285 fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 3286 return 0; 3287 } 3288 } 3289 3290 int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 3291 { 3292 switch (cmd) { 3293 case FSACTL_QUERY_DISK: 3294 return query_disk(dev, arg); 3295 case FSACTL_DELETE_DISK: 3296 return delete_disk(dev, arg); 3297 case FSACTL_FORCE_DELETE_DISK: 3298 return force_delete_disk(dev, arg); 3299 case FSACTL_GET_CONTAINERS: 3300 return aac_get_containers(dev); 3301 default: 3302 return -ENOTTY; 3303 } 3304 } 3305 3306 /** 3307 * 3308 * aac_srb_callback 3309 * @context: the context set in the fib - here it is scsi cmd 3310 * @fibptr: pointer to the fib 3311 * 3312 * Handles the completion of a scsi command to a non dasd device 3313 * 3314 */ 3315 3316 static void aac_srb_callback(void *context, struct fib * fibptr) 3317 { 3318 struct aac_dev *dev; 3319 struct aac_srb_reply *srbreply; 3320 struct scsi_cmnd *scsicmd; 3321 3322 scsicmd = (struct scsi_cmnd *) context; 3323 3324 if (!aac_valid_context(scsicmd, fibptr)) 3325 return; 3326 3327 BUG_ON(fibptr == NULL); 3328 3329 dev = fibptr->dev; 3330 3331 srbreply = (struct aac_srb_reply *) fib_data(fibptr); 3332 3333 scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 3334 3335 if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { 3336 /* fast response */ 3337 srbreply->srb_status = cpu_to_le32(SRB_STATUS_SUCCESS); 3338 srbreply->scsi_status = cpu_to_le32(SAM_STAT_GOOD); 3339 } else { 3340 /* 3341 * Calculate resid for sg 3342 */ 3343 scsi_set_resid(scsicmd, scsi_bufflen(scsicmd) 3344 - le32_to_cpu(srbreply->data_xfer_length)); 3345 } 3346 3347 3348 scsi_dma_unmap(scsicmd); 3349 3350 /* expose physical device if expose_physicald flag is on */ 3351 if (scsicmd->cmnd[0] == INQUIRY && !(scsicmd->cmnd[1] & 0x01) 3352 && expose_physicals > 0) 3353 aac_expose_phy_device(scsicmd); 3354 3355 /* 3356 * First check the fib status 3357 */ 3358 3359 if (le32_to_cpu(srbreply->status) != ST_OK) { 3360 int len; 3361 3362 pr_warn("aac_srb_callback: srb failed, status = %d\n", 3363 le32_to_cpu(srbreply->status)); 3364 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 3365 SCSI_SENSE_BUFFERSIZE); 3366 scsicmd->result = DID_ERROR << 16 3367 | COMMAND_COMPLETE << 8 3368 | SAM_STAT_CHECK_CONDITION; 3369 memcpy(scsicmd->sense_buffer, 3370 srbreply->sense_data, len); 3371 } 3372 3373 /* 3374 * Next check the srb status 3375 */ 3376 switch ((le32_to_cpu(srbreply->srb_status))&0x3f) { 3377 case SRB_STATUS_ERROR_RECOVERY: 3378 case SRB_STATUS_PENDING: 3379 case SRB_STATUS_SUCCESS: 3380 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 3381 break; 3382 case SRB_STATUS_DATA_OVERRUN: 3383 switch (scsicmd->cmnd[0]) { 3384 case READ_6: 3385 case WRITE_6: 3386 case READ_10: 3387 case WRITE_10: 3388 case READ_12: 3389 case WRITE_12: 3390 case READ_16: 3391 case WRITE_16: 3392 if (le32_to_cpu(srbreply->data_xfer_length) 3393 < scsicmd->underflow) 3394 pr_warn("aacraid: SCSI CMD underflow\n"); 3395 else 3396 pr_warn("aacraid: SCSI CMD Data Overrun\n"); 3397 scsicmd->result = DID_ERROR << 16 3398 | COMMAND_COMPLETE << 8; 3399 break; 3400 case INQUIRY: 3401 scsicmd->result = DID_OK << 16 3402 | COMMAND_COMPLETE << 8; 3403 break; 3404 default: 3405 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 3406 break; 3407 } 3408 break; 3409 case SRB_STATUS_ABORTED: 3410 scsicmd->result = DID_ABORT << 16 | ABORT << 8; 3411 break; 3412 case SRB_STATUS_ABORT_FAILED: 3413 /* 3414 * Not sure about this one - but assuming the 3415 * hba was trying to abort for some reason 3416 */ 3417 scsicmd->result = DID_ERROR << 16 | ABORT << 8; 3418 break; 3419 case SRB_STATUS_PARITY_ERROR: 3420 scsicmd->result = DID_PARITY << 16 3421 | MSG_PARITY_ERROR << 8; 3422 break; 3423 case SRB_STATUS_NO_DEVICE: 3424 case SRB_STATUS_INVALID_PATH_ID: 3425 case SRB_STATUS_INVALID_TARGET_ID: 3426 case SRB_STATUS_INVALID_LUN: 3427 case SRB_STATUS_SELECTION_TIMEOUT: 3428 scsicmd->result = DID_NO_CONNECT << 16 3429 | COMMAND_COMPLETE << 8; 3430 break; 3431 3432 case SRB_STATUS_COMMAND_TIMEOUT: 3433 case SRB_STATUS_TIMEOUT: 3434 scsicmd->result = DID_TIME_OUT << 16 3435 | COMMAND_COMPLETE << 8; 3436 break; 3437 3438 case SRB_STATUS_BUSY: 3439 scsicmd->result = DID_BUS_BUSY << 16 3440 | COMMAND_COMPLETE << 8; 3441 break; 3442 3443 case SRB_STATUS_BUS_RESET: 3444 scsicmd->result = DID_RESET << 16 3445 | COMMAND_COMPLETE << 8; 3446 break; 3447 3448 case SRB_STATUS_MESSAGE_REJECTED: 3449 scsicmd->result = DID_ERROR << 16 3450 | MESSAGE_REJECT << 8; 3451 break; 3452 case SRB_STATUS_REQUEST_FLUSHED: 3453 case SRB_STATUS_ERROR: 3454 case SRB_STATUS_INVALID_REQUEST: 3455 case SRB_STATUS_REQUEST_SENSE_FAILED: 3456 case SRB_STATUS_NO_HBA: 3457 case SRB_STATUS_UNEXPECTED_BUS_FREE: 3458 case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 3459 case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 3460 case SRB_STATUS_DELAYED_RETRY: 3461 case SRB_STATUS_BAD_FUNCTION: 3462 case SRB_STATUS_NOT_STARTED: 3463 case SRB_STATUS_NOT_IN_USE: 3464 case SRB_STATUS_FORCE_ABORT: 3465 case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 3466 default: 3467 #ifdef AAC_DETAILED_STATUS_INFO 3468 pr_info("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x -scsi status 0x%x\n", 3469 le32_to_cpu(srbreply->srb_status) & 0x3F, 3470 aac_get_status_string( 3471 le32_to_cpu(srbreply->srb_status) & 0x3F), 3472 scsicmd->cmnd[0], 3473 le32_to_cpu(srbreply->scsi_status)); 3474 #endif 3475 /* 3476 * When the CC bit is SET by the host in ATA pass thru CDB, 3477 * driver is supposed to return DID_OK 3478 * 3479 * When the CC bit is RESET by the host, driver should 3480 * return DID_ERROR 3481 */ 3482 if ((scsicmd->cmnd[0] == ATA_12) 3483 || (scsicmd->cmnd[0] == ATA_16)) { 3484 3485 if (scsicmd->cmnd[2] & (0x01 << 5)) { 3486 scsicmd->result = DID_OK << 16 3487 | COMMAND_COMPLETE << 8; 3488 break; 3489 } else { 3490 scsicmd->result = DID_ERROR << 16 3491 | COMMAND_COMPLETE << 8; 3492 break; 3493 } 3494 } else { 3495 scsicmd->result = DID_ERROR << 16 3496 | COMMAND_COMPLETE << 8; 3497 break; 3498 } 3499 } 3500 if (le32_to_cpu(srbreply->scsi_status) 3501 == SAM_STAT_CHECK_CONDITION) { 3502 int len; 3503 3504 scsicmd->result |= SAM_STAT_CHECK_CONDITION; 3505 len = min_t(u32, le32_to_cpu(srbreply->sense_data_size), 3506 SCSI_SENSE_BUFFERSIZE); 3507 #ifdef AAC_DETAILED_STATUS_INFO 3508 pr_warn("aac_srb_callback: check condition, status = %d len=%d\n", 3509 le32_to_cpu(srbreply->status), len); 3510 #endif 3511 memcpy(scsicmd->sense_buffer, 3512 srbreply->sense_data, len); 3513 } 3514 3515 /* 3516 * OR in the scsi status (already shifted up a bit) 3517 */ 3518 scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 3519 3520 aac_fib_complete(fibptr); 3521 scsicmd->scsi_done(scsicmd); 3522 } 3523 3524 static void hba_resp_task_complete(struct aac_dev *dev, 3525 struct scsi_cmnd *scsicmd, 3526 struct aac_hba_resp *err) { 3527 3528 scsicmd->result = err->status; 3529 /* set residual count */ 3530 scsi_set_resid(scsicmd, le32_to_cpu(err->residual_count)); 3531 3532 switch (err->status) { 3533 case SAM_STAT_GOOD: 3534 scsicmd->result |= DID_OK << 16 | COMMAND_COMPLETE << 8; 3535 break; 3536 case SAM_STAT_CHECK_CONDITION: 3537 { 3538 int len; 3539 3540 len = min_t(u8, err->sense_response_data_len, 3541 SCSI_SENSE_BUFFERSIZE); 3542 if (len) 3543 memcpy(scsicmd->sense_buffer, 3544 err->sense_response_buf, len); 3545 scsicmd->result |= DID_OK << 16 | COMMAND_COMPLETE << 8; 3546 break; 3547 } 3548 case SAM_STAT_BUSY: 3549 scsicmd->result |= DID_BUS_BUSY << 16 | COMMAND_COMPLETE << 8; 3550 break; 3551 case SAM_STAT_TASK_ABORTED: 3552 scsicmd->result |= DID_ABORT << 16 | ABORT << 8; 3553 break; 3554 case SAM_STAT_RESERVATION_CONFLICT: 3555 case SAM_STAT_TASK_SET_FULL: 3556 default: 3557 scsicmd->result |= DID_ERROR << 16 | COMMAND_COMPLETE << 8; 3558 break; 3559 } 3560 } 3561 3562 static void hba_resp_task_failure(struct aac_dev *dev, 3563 struct scsi_cmnd *scsicmd, 3564 struct aac_hba_resp *err) 3565 { 3566 switch (err->status) { 3567 case HBA_RESP_STAT_HBAMODE_DISABLED: 3568 { 3569 u32 bus, cid; 3570 3571 bus = aac_logical_to_phys(scmd_channel(scsicmd)); 3572 cid = scmd_id(scsicmd); 3573 if (dev->hba_map[bus][cid].devtype == AAC_DEVTYPE_NATIVE_RAW) { 3574 dev->hba_map[bus][cid].devtype = AAC_DEVTYPE_ARC_RAW; 3575 dev->hba_map[bus][cid].rmw_nexus = 0xffffffff; 3576 } 3577 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 3578 break; 3579 } 3580 case HBA_RESP_STAT_IO_ERROR: 3581 case HBA_RESP_STAT_NO_PATH_TO_DEVICE: 3582 scsicmd->result = DID_OK << 16 | 3583 COMMAND_COMPLETE << 8 | SAM_STAT_BUSY; 3584 break; 3585 case HBA_RESP_STAT_IO_ABORTED: 3586 scsicmd->result = DID_ABORT << 16 | ABORT << 8; 3587 break; 3588 case HBA_RESP_STAT_INVALID_DEVICE: 3589 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 3590 break; 3591 case HBA_RESP_STAT_UNDERRUN: 3592 /* UNDERRUN is OK */ 3593 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 3594 break; 3595 case HBA_RESP_STAT_OVERRUN: 3596 default: 3597 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 3598 break; 3599 } 3600 } 3601 3602 /** 3603 * 3604 * aac_hba_callback 3605 * @context: the context set in the fib - here it is scsi cmd 3606 * @fibptr: pointer to the fib 3607 * 3608 * Handles the completion of a native HBA scsi command 3609 * 3610 */ 3611 void aac_hba_callback(void *context, struct fib *fibptr) 3612 { 3613 struct aac_dev *dev; 3614 struct scsi_cmnd *scsicmd; 3615 3616 struct aac_hba_resp *err = 3617 &((struct aac_native_hba *)fibptr->hw_fib_va)->resp.err; 3618 3619 scsicmd = (struct scsi_cmnd *) context; 3620 3621 if (!aac_valid_context(scsicmd, fibptr)) 3622 return; 3623 3624 WARN_ON(fibptr == NULL); 3625 dev = fibptr->dev; 3626 3627 if (!(fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF)) 3628 scsi_dma_unmap(scsicmd); 3629 3630 if (fibptr->flags & FIB_CONTEXT_FLAG_FASTRESP) { 3631 /* fast response */ 3632 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 3633 goto out; 3634 } 3635 3636 switch (err->service_response) { 3637 case HBA_RESP_SVCRES_TASK_COMPLETE: 3638 hba_resp_task_complete(dev, scsicmd, err); 3639 break; 3640 case HBA_RESP_SVCRES_FAILURE: 3641 hba_resp_task_failure(dev, scsicmd, err); 3642 break; 3643 case HBA_RESP_SVCRES_TMF_REJECTED: 3644 scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 3645 break; 3646 case HBA_RESP_SVCRES_TMF_LUN_INVALID: 3647 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 3648 break; 3649 case HBA_RESP_SVCRES_TMF_COMPLETE: 3650 case HBA_RESP_SVCRES_TMF_SUCCEEDED: 3651 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 3652 break; 3653 default: 3654 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 3655 break; 3656 } 3657 3658 out: 3659 aac_fib_complete(fibptr); 3660 3661 if (fibptr->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF) 3662 scsicmd->SCp.sent_command = 1; 3663 else 3664 scsicmd->scsi_done(scsicmd); 3665 } 3666 3667 /** 3668 * 3669 * aac_send_srb_fib 3670 * @scsicmd: the scsi command block 3671 * 3672 * This routine will form a FIB and fill in the aac_srb from the 3673 * scsicmd passed in. 3674 */ 3675 3676 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 3677 { 3678 struct fib* cmd_fibcontext; 3679 struct aac_dev* dev; 3680 int status; 3681 3682 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3683 if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 3684 scsicmd->device->lun > 7) { 3685 scsicmd->result = DID_NO_CONNECT << 16; 3686 scsicmd->scsi_done(scsicmd); 3687 return 0; 3688 } 3689 3690 /* 3691 * Allocate and initialize a Fib then setup a BlockWrite command 3692 */ 3693 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 3694 3695 status = aac_adapter_scsi(cmd_fibcontext, scsicmd); 3696 3697 /* 3698 * Check that the command queued to the controller 3699 */ 3700 if (status == -EINPROGRESS) { 3701 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 3702 return 0; 3703 } 3704 3705 printk(KERN_WARNING "aac_srb: aac_fib_send failed with status: %d\n", status); 3706 aac_fib_complete(cmd_fibcontext); 3707 aac_fib_free(cmd_fibcontext); 3708 3709 return -1; 3710 } 3711 3712 /** 3713 * 3714 * aac_send_hba_fib 3715 * @scsicmd: the scsi command block 3716 * 3717 * This routine will form a FIB and fill in the aac_hba_cmd_req from the 3718 * scsicmd passed in. 3719 */ 3720 static int aac_send_hba_fib(struct scsi_cmnd *scsicmd) 3721 { 3722 struct fib *cmd_fibcontext; 3723 struct aac_dev *dev; 3724 int status; 3725 3726 dev = shost_priv(scsicmd->device->host); 3727 if (scmd_id(scsicmd) >= dev->maximum_num_physicals || 3728 scsicmd->device->lun > AAC_MAX_LUN - 1) { 3729 scsicmd->result = DID_NO_CONNECT << 16; 3730 scsicmd->scsi_done(scsicmd); 3731 return 0; 3732 } 3733 3734 /* 3735 * Allocate and initialize a Fib then setup a BlockWrite command 3736 */ 3737 cmd_fibcontext = aac_fib_alloc_tag(dev, scsicmd); 3738 if (!cmd_fibcontext) 3739 return -1; 3740 3741 status = aac_adapter_hba(cmd_fibcontext, scsicmd); 3742 3743 /* 3744 * Check that the command queued to the controller 3745 */ 3746 if (status == -EINPROGRESS) { 3747 scsicmd->SCp.phase = AAC_OWNER_FIRMWARE; 3748 return 0; 3749 } 3750 3751 pr_warn("aac_hba_cmd_req: aac_fib_send failed with status: %d\n", 3752 status); 3753 aac_fib_complete(cmd_fibcontext); 3754 aac_fib_free(cmd_fibcontext); 3755 3756 return -1; 3757 } 3758 3759 3760 static long aac_build_sg(struct scsi_cmnd *scsicmd, struct sgmap *psg) 3761 { 3762 struct aac_dev *dev; 3763 unsigned long byte_count = 0; 3764 int nseg; 3765 3766 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3767 // Get rid of old data 3768 psg->count = 0; 3769 psg->sg[0].addr = 0; 3770 psg->sg[0].count = 0; 3771 3772 nseg = scsi_dma_map(scsicmd); 3773 if (nseg < 0) 3774 return nseg; 3775 if (nseg) { 3776 struct scatterlist *sg; 3777 int i; 3778 3779 psg->count = cpu_to_le32(nseg); 3780 3781 scsi_for_each_sg(scsicmd, sg, nseg, i) { 3782 psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 3783 psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 3784 byte_count += sg_dma_len(sg); 3785 } 3786 /* hba wants the size to be exact */ 3787 if (byte_count > scsi_bufflen(scsicmd)) { 3788 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3789 (byte_count - scsi_bufflen(scsicmd)); 3790 psg->sg[i-1].count = cpu_to_le32(temp); 3791 byte_count = scsi_bufflen(scsicmd); 3792 } 3793 /* Check for command underflow */ 3794 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3795 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3796 byte_count, scsicmd->underflow); 3797 } 3798 } 3799 return byte_count; 3800 } 3801 3802 3803 static long aac_build_sg64(struct scsi_cmnd *scsicmd, struct sgmap64 *psg) 3804 { 3805 struct aac_dev *dev; 3806 unsigned long byte_count = 0; 3807 u64 addr; 3808 int nseg; 3809 3810 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 3811 // Get rid of old data 3812 psg->count = 0; 3813 psg->sg[0].addr[0] = 0; 3814 psg->sg[0].addr[1] = 0; 3815 psg->sg[0].count = 0; 3816 3817 nseg = scsi_dma_map(scsicmd); 3818 if (nseg < 0) 3819 return nseg; 3820 if (nseg) { 3821 struct scatterlist *sg; 3822 int i; 3823 3824 scsi_for_each_sg(scsicmd, sg, nseg, i) { 3825 int count = sg_dma_len(sg); 3826 addr = sg_dma_address(sg); 3827 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 3828 psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 3829 psg->sg[i].count = cpu_to_le32(count); 3830 byte_count += count; 3831 } 3832 psg->count = cpu_to_le32(nseg); 3833 /* hba wants the size to be exact */ 3834 if (byte_count > scsi_bufflen(scsicmd)) { 3835 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3836 (byte_count - scsi_bufflen(scsicmd)); 3837 psg->sg[i-1].count = cpu_to_le32(temp); 3838 byte_count = scsi_bufflen(scsicmd); 3839 } 3840 /* Check for command underflow */ 3841 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3842 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3843 byte_count, scsicmd->underflow); 3844 } 3845 } 3846 return byte_count; 3847 } 3848 3849 static long aac_build_sgraw(struct scsi_cmnd *scsicmd, struct sgmapraw *psg) 3850 { 3851 unsigned long byte_count = 0; 3852 int nseg; 3853 3854 // Get rid of old data 3855 psg->count = 0; 3856 psg->sg[0].next = 0; 3857 psg->sg[0].prev = 0; 3858 psg->sg[0].addr[0] = 0; 3859 psg->sg[0].addr[1] = 0; 3860 psg->sg[0].count = 0; 3861 psg->sg[0].flags = 0; 3862 3863 nseg = scsi_dma_map(scsicmd); 3864 if (nseg < 0) 3865 return nseg; 3866 if (nseg) { 3867 struct scatterlist *sg; 3868 int i; 3869 3870 scsi_for_each_sg(scsicmd, sg, nseg, i) { 3871 int count = sg_dma_len(sg); 3872 u64 addr = sg_dma_address(sg); 3873 psg->sg[i].next = 0; 3874 psg->sg[i].prev = 0; 3875 psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 3876 psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 3877 psg->sg[i].count = cpu_to_le32(count); 3878 psg->sg[i].flags = 0; 3879 byte_count += count; 3880 } 3881 psg->count = cpu_to_le32(nseg); 3882 /* hba wants the size to be exact */ 3883 if (byte_count > scsi_bufflen(scsicmd)) { 3884 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 3885 (byte_count - scsi_bufflen(scsicmd)); 3886 psg->sg[i-1].count = cpu_to_le32(temp); 3887 byte_count = scsi_bufflen(scsicmd); 3888 } 3889 /* Check for command underflow */ 3890 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 3891 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3892 byte_count, scsicmd->underflow); 3893 } 3894 } 3895 return byte_count; 3896 } 3897 3898 static long aac_build_sgraw2(struct scsi_cmnd *scsicmd, 3899 struct aac_raw_io2 *rio2, int sg_max) 3900 { 3901 unsigned long byte_count = 0; 3902 int nseg; 3903 3904 nseg = scsi_dma_map(scsicmd); 3905 if (nseg < 0) 3906 return nseg; 3907 if (nseg) { 3908 struct scatterlist *sg; 3909 int i, conformable = 0; 3910 u32 min_size = PAGE_SIZE, cur_size; 3911 3912 scsi_for_each_sg(scsicmd, sg, nseg, i) { 3913 int count = sg_dma_len(sg); 3914 u64 addr = sg_dma_address(sg); 3915 3916 BUG_ON(i >= sg_max); 3917 rio2->sge[i].addrHigh = cpu_to_le32((u32)(addr>>32)); 3918 rio2->sge[i].addrLow = cpu_to_le32((u32)(addr & 0xffffffff)); 3919 cur_size = cpu_to_le32(count); 3920 rio2->sge[i].length = cur_size; 3921 rio2->sge[i].flags = 0; 3922 if (i == 0) { 3923 conformable = 1; 3924 rio2->sgeFirstSize = cur_size; 3925 } else if (i == 1) { 3926 rio2->sgeNominalSize = cur_size; 3927 min_size = cur_size; 3928 } else if ((i+1) < nseg && cur_size != rio2->sgeNominalSize) { 3929 conformable = 0; 3930 if (cur_size < min_size) 3931 min_size = cur_size; 3932 } 3933 byte_count += count; 3934 } 3935 3936 /* hba wants the size to be exact */ 3937 if (byte_count > scsi_bufflen(scsicmd)) { 3938 u32 temp = le32_to_cpu(rio2->sge[i-1].length) - 3939 (byte_count - scsi_bufflen(scsicmd)); 3940 rio2->sge[i-1].length = cpu_to_le32(temp); 3941 byte_count = scsi_bufflen(scsicmd); 3942 } 3943 3944 rio2->sgeCnt = cpu_to_le32(nseg); 3945 rio2->flags |= cpu_to_le16(RIO2_SG_FORMAT_IEEE1212); 3946 /* not conformable: evaluate required sg elements */ 3947 if (!conformable) { 3948 int j, nseg_new = nseg, err_found; 3949 for (i = min_size / PAGE_SIZE; i >= 1; --i) { 3950 err_found = 0; 3951 nseg_new = 2; 3952 for (j = 1; j < nseg - 1; ++j) { 3953 if (rio2->sge[j].length % (i*PAGE_SIZE)) { 3954 err_found = 1; 3955 break; 3956 } 3957 nseg_new += (rio2->sge[j].length / (i*PAGE_SIZE)); 3958 } 3959 if (!err_found) 3960 break; 3961 } 3962 if (i > 0 && nseg_new <= sg_max) 3963 aac_convert_sgraw2(rio2, i, nseg, nseg_new); 3964 } else 3965 rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 3966 3967 /* Check for command underflow */ 3968 if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 3969 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 3970 byte_count, scsicmd->underflow); 3971 } 3972 } 3973 3974 return byte_count; 3975 } 3976 3977 static int aac_convert_sgraw2(struct aac_raw_io2 *rio2, int pages, int nseg, int nseg_new) 3978 { 3979 struct sge_ieee1212 *sge; 3980 int i, j, pos; 3981 u32 addr_low; 3982 3983 if (aac_convert_sgl == 0) 3984 return 0; 3985 3986 sge = kmalloc(nseg_new * sizeof(struct sge_ieee1212), GFP_ATOMIC); 3987 if (sge == NULL) 3988 return -1; 3989 3990 for (i = 1, pos = 1; i < nseg-1; ++i) { 3991 for (j = 0; j < rio2->sge[i].length / (pages * PAGE_SIZE); ++j) { 3992 addr_low = rio2->sge[i].addrLow + j * pages * PAGE_SIZE; 3993 sge[pos].addrLow = addr_low; 3994 sge[pos].addrHigh = rio2->sge[i].addrHigh; 3995 if (addr_low < rio2->sge[i].addrLow) 3996 sge[pos].addrHigh++; 3997 sge[pos].length = pages * PAGE_SIZE; 3998 sge[pos].flags = 0; 3999 pos++; 4000 } 4001 } 4002 sge[pos] = rio2->sge[nseg-1]; 4003 memcpy(&rio2->sge[1], &sge[1], (nseg_new-1)*sizeof(struct sge_ieee1212)); 4004 4005 kfree(sge); 4006 rio2->sgeCnt = cpu_to_le32(nseg_new); 4007 rio2->flags |= cpu_to_le16(RIO2_SGL_CONFORMANT); 4008 rio2->sgeNominalSize = pages * PAGE_SIZE; 4009 return 0; 4010 } 4011 4012 static long aac_build_sghba(struct scsi_cmnd *scsicmd, 4013 struct aac_hba_cmd_req *hbacmd, 4014 int sg_max, 4015 u64 sg_address) 4016 { 4017 unsigned long byte_count = 0; 4018 int nseg; 4019 struct scatterlist *sg; 4020 int i; 4021 u32 cur_size; 4022 struct aac_hba_sgl *sge; 4023 4024 nseg = scsi_dma_map(scsicmd); 4025 if (nseg <= 0) { 4026 byte_count = nseg; 4027 goto out; 4028 } 4029 4030 if (nseg > HBA_MAX_SG_EMBEDDED) 4031 sge = &hbacmd->sge[2]; 4032 else 4033 sge = &hbacmd->sge[0]; 4034 4035 scsi_for_each_sg(scsicmd, sg, nseg, i) { 4036 int count = sg_dma_len(sg); 4037 u64 addr = sg_dma_address(sg); 4038 4039 WARN_ON(i >= sg_max); 4040 sge->addr_hi = cpu_to_le32((u32)(addr>>32)); 4041 sge->addr_lo = cpu_to_le32((u32)(addr & 0xffffffff)); 4042 cur_size = cpu_to_le32(count); 4043 sge->len = cur_size; 4044 sge->flags = 0; 4045 byte_count += count; 4046 sge++; 4047 } 4048 4049 sge--; 4050 /* hba wants the size to be exact */ 4051 if (byte_count > scsi_bufflen(scsicmd)) { 4052 u32 temp; 4053 4054 temp = le32_to_cpu(sge->len) - byte_count 4055 - scsi_bufflen(scsicmd); 4056 sge->len = cpu_to_le32(temp); 4057 byte_count = scsi_bufflen(scsicmd); 4058 } 4059 4060 if (nseg <= HBA_MAX_SG_EMBEDDED) { 4061 hbacmd->emb_data_desc_count = cpu_to_le32(nseg); 4062 sge->flags = cpu_to_le32(0x40000000); 4063 } else { 4064 /* not embedded */ 4065 hbacmd->sge[0].flags = cpu_to_le32(0x80000000); 4066 hbacmd->emb_data_desc_count = (u8)cpu_to_le32(1); 4067 hbacmd->sge[0].addr_hi = (u32)cpu_to_le32(sg_address >> 32); 4068 hbacmd->sge[0].addr_lo = 4069 cpu_to_le32((u32)(sg_address & 0xffffffff)); 4070 } 4071 4072 /* Check for command underflow */ 4073 if (scsicmd->underflow && (byte_count < scsicmd->underflow)) { 4074 pr_warn("aacraid: cmd len %08lX cmd underflow %08X\n", 4075 byte_count, scsicmd->underflow); 4076 } 4077 out: 4078 return byte_count; 4079 } 4080 4081 #ifdef AAC_DETAILED_STATUS_INFO 4082 4083 struct aac_srb_status_info { 4084 u32 status; 4085 char *str; 4086 }; 4087 4088 4089 static struct aac_srb_status_info srb_status_info[] = { 4090 { SRB_STATUS_PENDING, "Pending Status"}, 4091 { SRB_STATUS_SUCCESS, "Success"}, 4092 { SRB_STATUS_ABORTED, "Aborted Command"}, 4093 { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 4094 { SRB_STATUS_ERROR, "Error Event"}, 4095 { SRB_STATUS_BUSY, "Device Busy"}, 4096 { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 4097 { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 4098 { SRB_STATUS_NO_DEVICE, "No Device"}, 4099 { SRB_STATUS_TIMEOUT, "Timeout"}, 4100 { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 4101 { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 4102 { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 4103 { SRB_STATUS_BUS_RESET, "Bus Reset"}, 4104 { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 4105 { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 4106 { SRB_STATUS_NO_HBA, "No HBA"}, 4107 { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 4108 { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 4109 { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 4110 { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 4111 { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 4112 { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 4113 { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 4114 { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 4115 { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 4116 { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 4117 { SRB_STATUS_NOT_STARTED, "Not Started"}, 4118 { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 4119 { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 4120 { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 4121 { 0xff, "Unknown Error"} 4122 }; 4123 4124 char *aac_get_status_string(u32 status) 4125 { 4126 int i; 4127 4128 for (i = 0; i < ARRAY_SIZE(srb_status_info); i++) 4129 if (srb_status_info[i].status == status) 4130 return srb_status_info[i].str; 4131 4132 return "Bad Status Code"; 4133 } 4134 4135 #endif 4136