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