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 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/sched.h> 30 #include <linux/pci.h> 31 #include <linux/spinlock.h> 32 #include <linux/slab.h> 33 #include <linux/completion.h> 34 #include <linux/blkdev.h> 35 #include <asm/semaphore.h> 36 #include <asm/uaccess.h> 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 dacmode = -1; 148 149 static int commit = -1; 150 151 module_param(nondasd, int, 0); 152 MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices. 0=off, 1=on"); 153 module_param(dacmode, int, 0); 154 MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC. 0=off, 1=on"); 155 module_param(commit, int, 0); 156 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"); 157 158 int numacb = -1; 159 module_param(numacb, int, S_IRUGO|S_IWUSR); 160 MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control blocks (FIB) allocated. Valid\nvalues are 512 and down. Default is to use suggestion from Firmware."); 161 162 int acbsize = -1; 163 module_param(acbsize, int, S_IRUGO|S_IWUSR); 164 MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB) size. Valid values are 512,\n2048, 4096 and 8192. Default is to use suggestion from Firmware."); 165 /** 166 * aac_get_config_status - check the adapter configuration 167 * @common: adapter to query 168 * 169 * Query config status, and commit the configuration if needed. 170 */ 171 int aac_get_config_status(struct aac_dev *dev) 172 { 173 int status = 0; 174 struct fib * fibptr; 175 176 if (!(fibptr = fib_alloc(dev))) 177 return -ENOMEM; 178 179 fib_init(fibptr); 180 { 181 struct aac_get_config_status *dinfo; 182 dinfo = (struct aac_get_config_status *) fib_data(fibptr); 183 184 dinfo->command = cpu_to_le32(VM_ContainerConfig); 185 dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS); 186 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data)); 187 } 188 189 status = fib_send(ContainerCommand, 190 fibptr, 191 sizeof (struct aac_get_config_status), 192 FsaNormal, 193 1, 1, 194 NULL, NULL); 195 if (status < 0 ) { 196 printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n"); 197 } else { 198 struct aac_get_config_status_resp *reply 199 = (struct aac_get_config_status_resp *) fib_data(fibptr); 200 dprintk((KERN_WARNING 201 "aac_get_config_status: response=%d status=%d action=%d\n", 202 le32_to_cpu(reply->response), 203 le32_to_cpu(reply->status), 204 le32_to_cpu(reply->data.action))); 205 if ((le32_to_cpu(reply->response) != ST_OK) || 206 (le32_to_cpu(reply->status) != CT_OK) || 207 (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) { 208 printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n"); 209 status = -EINVAL; 210 } 211 } 212 fib_complete(fibptr); 213 /* Send a CT_COMMIT_CONFIG to enable discovery of devices */ 214 if (status >= 0) { 215 if (commit == 1) { 216 struct aac_commit_config * dinfo; 217 fib_init(fibptr); 218 dinfo = (struct aac_commit_config *) fib_data(fibptr); 219 220 dinfo->command = cpu_to_le32(VM_ContainerConfig); 221 dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG); 222 223 status = fib_send(ContainerCommand, 224 fibptr, 225 sizeof (struct aac_commit_config), 226 FsaNormal, 227 1, 1, 228 NULL, NULL); 229 fib_complete(fibptr); 230 } else if (commit == 0) { 231 printk(KERN_WARNING 232 "aac_get_config_status: Foreign device configurations are being ignored\n"); 233 } 234 } 235 fib_free(fibptr); 236 return status; 237 } 238 239 /** 240 * aac_get_containers - list containers 241 * @common: adapter to probe 242 * 243 * Make a list of all containers on this controller 244 */ 245 int aac_get_containers(struct aac_dev *dev) 246 { 247 struct fsa_dev_info *fsa_dev_ptr; 248 u32 index; 249 int status = 0; 250 struct fib * fibptr; 251 unsigned instance; 252 struct aac_get_container_count *dinfo; 253 struct aac_get_container_count_resp *dresp; 254 int maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 255 256 instance = dev->scsi_host_ptr->unique_id; 257 258 if (!(fibptr = fib_alloc(dev))) 259 return -ENOMEM; 260 261 fib_init(fibptr); 262 dinfo = (struct aac_get_container_count *) fib_data(fibptr); 263 dinfo->command = cpu_to_le32(VM_ContainerConfig); 264 dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT); 265 266 status = fib_send(ContainerCommand, 267 fibptr, 268 sizeof (struct aac_get_container_count), 269 FsaNormal, 270 1, 1, 271 NULL, NULL); 272 if (status >= 0) { 273 dresp = (struct aac_get_container_count_resp *)fib_data(fibptr); 274 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries); 275 fib_complete(fibptr); 276 } 277 278 if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS) 279 maximum_num_containers = MAXIMUM_NUM_CONTAINERS; 280 fsa_dev_ptr = (struct fsa_dev_info *) kmalloc( 281 sizeof(*fsa_dev_ptr) * maximum_num_containers, GFP_KERNEL); 282 if (!fsa_dev_ptr) { 283 fib_free(fibptr); 284 return -ENOMEM; 285 } 286 memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers); 287 288 dev->fsa_dev = fsa_dev_ptr; 289 dev->maximum_num_containers = maximum_num_containers; 290 291 for (index = 0; index < dev->maximum_num_containers; index++) { 292 struct aac_query_mount *dinfo; 293 struct aac_mount *dresp; 294 295 fsa_dev_ptr[index].devname[0] = '\0'; 296 297 fib_init(fibptr); 298 dinfo = (struct aac_query_mount *) fib_data(fibptr); 299 300 dinfo->command = cpu_to_le32(VM_NameServe); 301 dinfo->count = cpu_to_le32(index); 302 dinfo->type = cpu_to_le32(FT_FILESYS); 303 304 status = fib_send(ContainerCommand, 305 fibptr, 306 sizeof (struct aac_query_mount), 307 FsaNormal, 308 1, 1, 309 NULL, NULL); 310 if (status < 0 ) { 311 printk(KERN_WARNING "aac_get_containers: SendFIB failed.\n"); 312 break; 313 } 314 dresp = (struct aac_mount *)fib_data(fibptr); 315 316 if ((le32_to_cpu(dresp->status) == ST_OK) && 317 (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) { 318 dinfo->command = cpu_to_le32(VM_NameServe64); 319 dinfo->count = cpu_to_le32(index); 320 dinfo->type = cpu_to_le32(FT_FILESYS); 321 322 if (fib_send(ContainerCommand, 323 fibptr, 324 sizeof(struct aac_query_mount), 325 FsaNormal, 326 1, 1, 327 NULL, NULL) < 0) 328 continue; 329 } else 330 dresp->mnt[0].capacityhigh = 0; 331 332 dprintk ((KERN_DEBUG 333 "VM_NameServe cid=%d status=%d vol=%d state=%d cap=%llu\n", 334 (int)index, (int)le32_to_cpu(dresp->status), 335 (int)le32_to_cpu(dresp->mnt[0].vol), 336 (int)le32_to_cpu(dresp->mnt[0].state), 337 ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 338 (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32))); 339 if ((le32_to_cpu(dresp->status) == ST_OK) && 340 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 341 (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 342 fsa_dev_ptr[index].valid = 1; 343 fsa_dev_ptr[index].type = le32_to_cpu(dresp->mnt[0].vol); 344 fsa_dev_ptr[index].size 345 = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 346 (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 347 if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) 348 fsa_dev_ptr[index].ro = 1; 349 } 350 fib_complete(fibptr); 351 /* 352 * If there are no more containers, then stop asking. 353 */ 354 if ((index + 1) >= le32_to_cpu(dresp->count)){ 355 break; 356 } 357 } 358 fib_free(fibptr); 359 return status; 360 } 361 362 static void aac_internal_transfer(struct scsi_cmnd *scsicmd, void *data, unsigned int offset, unsigned int len) 363 { 364 void *buf; 365 unsigned int transfer_len; 366 struct scatterlist *sg = scsicmd->request_buffer; 367 368 if (scsicmd->use_sg) { 369 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 370 transfer_len = min(sg->length, len + offset); 371 } else { 372 buf = scsicmd->request_buffer; 373 transfer_len = min(scsicmd->request_bufflen, len + offset); 374 } 375 376 memcpy(buf + offset, data, transfer_len - offset); 377 378 if (scsicmd->use_sg) 379 kunmap_atomic(buf - sg->offset, KM_IRQ0); 380 381 } 382 383 static void get_container_name_callback(void *context, struct fib * fibptr) 384 { 385 struct aac_get_name_resp * get_name_reply; 386 struct scsi_cmnd * scsicmd; 387 388 scsicmd = (struct scsi_cmnd *) context; 389 390 dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies)); 391 if (fibptr == NULL) 392 BUG(); 393 394 get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr); 395 /* Failure is irrelevant, using default value instead */ 396 if ((le32_to_cpu(get_name_reply->status) == CT_OK) 397 && (get_name_reply->data[0] != '\0')) { 398 char *sp = get_name_reply->data; 399 sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0'; 400 while (*sp == ' ') 401 ++sp; 402 if (*sp) { 403 char d[sizeof(((struct inquiry_data *)NULL)->inqd_pid)]; 404 int count = sizeof(d); 405 char *dp = d; 406 do { 407 *dp++ = (*sp) ? *sp++ : ' '; 408 } while (--count > 0); 409 aac_internal_transfer(scsicmd, d, 410 offsetof(struct inquiry_data, inqd_pid), sizeof(d)); 411 } 412 } 413 414 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 415 416 fib_complete(fibptr); 417 fib_free(fibptr); 418 scsicmd->scsi_done(scsicmd); 419 } 420 421 /** 422 * aac_get_container_name - get container name, none blocking. 423 */ 424 static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid) 425 { 426 int status; 427 struct aac_get_name *dinfo; 428 struct fib * cmd_fibcontext; 429 struct aac_dev * dev; 430 431 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 432 433 if (!(cmd_fibcontext = fib_alloc(dev))) 434 return -ENOMEM; 435 436 fib_init(cmd_fibcontext); 437 dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext); 438 439 dinfo->command = cpu_to_le32(VM_ContainerConfig); 440 dinfo->type = cpu_to_le32(CT_READ_NAME); 441 dinfo->cid = cpu_to_le32(cid); 442 dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data)); 443 444 status = fib_send(ContainerCommand, 445 cmd_fibcontext, 446 sizeof (struct aac_get_name), 447 FsaNormal, 448 0, 1, 449 (fib_callback) get_container_name_callback, 450 (void *) scsicmd); 451 452 /* 453 * Check that the command queued to the controller 454 */ 455 if (status == -EINPROGRESS) 456 return 0; 457 458 printk(KERN_WARNING "aac_get_container_name: fib_send failed with status: %d.\n", status); 459 fib_complete(cmd_fibcontext); 460 fib_free(cmd_fibcontext); 461 return -1; 462 } 463 464 /** 465 * probe_container - query a logical volume 466 * @dev: device to query 467 * @cid: container identifier 468 * 469 * Queries the controller about the given volume. The volume information 470 * is updated in the struct fsa_dev_info structure rather than returned. 471 */ 472 473 int probe_container(struct aac_dev *dev, int cid) 474 { 475 struct fsa_dev_info *fsa_dev_ptr; 476 int status; 477 struct aac_query_mount *dinfo; 478 struct aac_mount *dresp; 479 struct fib * fibptr; 480 unsigned instance; 481 482 fsa_dev_ptr = dev->fsa_dev; 483 instance = dev->scsi_host_ptr->unique_id; 484 485 if (!(fibptr = fib_alloc(dev))) 486 return -ENOMEM; 487 488 fib_init(fibptr); 489 490 dinfo = (struct aac_query_mount *)fib_data(fibptr); 491 492 dinfo->command = cpu_to_le32(VM_NameServe); 493 dinfo->count = cpu_to_le32(cid); 494 dinfo->type = cpu_to_le32(FT_FILESYS); 495 496 status = fib_send(ContainerCommand, 497 fibptr, 498 sizeof(struct aac_query_mount), 499 FsaNormal, 500 1, 1, 501 NULL, NULL); 502 if (status < 0) { 503 printk(KERN_WARNING "aacraid: probe_container query failed.\n"); 504 goto error; 505 } 506 507 dresp = (struct aac_mount *) fib_data(fibptr); 508 509 if ((le32_to_cpu(dresp->status) == ST_OK) && 510 (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) { 511 dinfo->command = cpu_to_le32(VM_NameServe64); 512 dinfo->count = cpu_to_le32(cid); 513 dinfo->type = cpu_to_le32(FT_FILESYS); 514 515 if (fib_send(ContainerCommand, 516 fibptr, 517 sizeof(struct aac_query_mount), 518 FsaNormal, 519 1, 1, 520 NULL, NULL) < 0) 521 goto error; 522 } else 523 dresp->mnt[0].capacityhigh = 0; 524 525 if ((le32_to_cpu(dresp->status) == ST_OK) && 526 (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) && 527 (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) { 528 fsa_dev_ptr[cid].valid = 1; 529 fsa_dev_ptr[cid].type = le32_to_cpu(dresp->mnt[0].vol); 530 fsa_dev_ptr[cid].size 531 = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) + 532 (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32); 533 if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY) 534 fsa_dev_ptr[cid].ro = 1; 535 } 536 537 error: 538 fib_complete(fibptr); 539 fib_free(fibptr); 540 541 return status; 542 } 543 544 /* Local Structure to set SCSI inquiry data strings */ 545 struct scsi_inq { 546 char vid[8]; /* Vendor ID */ 547 char pid[16]; /* Product ID */ 548 char prl[4]; /* Product Revision Level */ 549 }; 550 551 /** 552 * InqStrCopy - string merge 553 * @a: string to copy from 554 * @b: string to copy to 555 * 556 * Copy a String from one location to another 557 * without copying \0 558 */ 559 560 static void inqstrcpy(char *a, char *b) 561 { 562 563 while(*a != (char)0) 564 *b++ = *a++; 565 } 566 567 static char *container_types[] = { 568 "None", 569 "Volume", 570 "Mirror", 571 "Stripe", 572 "RAID5", 573 "SSRW", 574 "SSRO", 575 "Morph", 576 "Legacy", 577 "RAID4", 578 "RAID10", 579 "RAID00", 580 "V-MIRRORS", 581 "PSEUDO R4", 582 "RAID50", 583 "RAID5D", 584 "RAID5D0", 585 "RAID1E", 586 "RAID6", 587 "RAID60", 588 "Unknown" 589 }; 590 591 592 593 /* Function: setinqstr 594 * 595 * Arguments: [1] pointer to void [1] int 596 * 597 * Purpose: Sets SCSI inquiry data strings for vendor, product 598 * and revision level. Allows strings to be set in platform dependant 599 * files instead of in OS dependant driver source. 600 */ 601 602 static void setinqstr(struct aac_dev *dev, void *data, int tindex) 603 { 604 struct scsi_inq *str; 605 606 str = (struct scsi_inq *)(data); /* cast data to scsi inq block */ 607 memset(str, ' ', sizeof(*str)); 608 609 if (dev->supplement_adapter_info.AdapterTypeText[0]) { 610 char * cp = dev->supplement_adapter_info.AdapterTypeText; 611 int c = sizeof(str->vid); 612 while (*cp && *cp != ' ' && --c) 613 ++cp; 614 c = *cp; 615 *cp = '\0'; 616 inqstrcpy (dev->supplement_adapter_info.AdapterTypeText, 617 str->vid); 618 *cp = c; 619 while (*cp && *cp != ' ') 620 ++cp; 621 while (*cp == ' ') 622 ++cp; 623 /* last six chars reserved for vol type */ 624 c = 0; 625 if (strlen(cp) > sizeof(str->pid)) { 626 c = cp[sizeof(str->pid)]; 627 cp[sizeof(str->pid)] = '\0'; 628 } 629 inqstrcpy (cp, str->pid); 630 if (c) 631 cp[sizeof(str->pid)] = c; 632 } else { 633 struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype); 634 635 inqstrcpy (mp->vname, str->vid); 636 /* last six chars reserved for vol type */ 637 inqstrcpy (mp->model, str->pid); 638 } 639 640 if (tindex < (sizeof(container_types)/sizeof(char *))){ 641 char *findit = str->pid; 642 643 for ( ; *findit != ' '; findit++); /* walk till we find a space */ 644 /* RAID is superfluous in the context of a RAID device */ 645 if (memcmp(findit-4, "RAID", 4) == 0) 646 *(findit -= 4) = ' '; 647 if (((findit - str->pid) + strlen(container_types[tindex])) 648 < (sizeof(str->pid) + sizeof(str->prl))) 649 inqstrcpy (container_types[tindex], findit + 1); 650 } 651 inqstrcpy ("V1.0", str->prl); 652 } 653 654 static void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code, 655 u8 a_sense_code, u8 incorrect_length, 656 u8 bit_pointer, u16 field_pointer, 657 u32 residue) 658 { 659 sense_buf[0] = 0xF0; /* Sense data valid, err code 70h (current error) */ 660 sense_buf[1] = 0; /* Segment number, always zero */ 661 662 if (incorrect_length) { 663 sense_buf[2] = sense_key | 0x20;/* Set ILI bit | sense key */ 664 sense_buf[3] = BYTE3(residue); 665 sense_buf[4] = BYTE2(residue); 666 sense_buf[5] = BYTE1(residue); 667 sense_buf[6] = BYTE0(residue); 668 } else 669 sense_buf[2] = sense_key; /* Sense key */ 670 671 if (sense_key == ILLEGAL_REQUEST) 672 sense_buf[7] = 10; /* Additional sense length */ 673 else 674 sense_buf[7] = 6; /* Additional sense length */ 675 676 sense_buf[12] = sense_code; /* Additional sense code */ 677 sense_buf[13] = a_sense_code; /* Additional sense code qualifier */ 678 if (sense_key == ILLEGAL_REQUEST) { 679 sense_buf[15] = 0; 680 681 if (sense_code == SENCODE_INVALID_PARAM_FIELD) 682 sense_buf[15] = 0x80;/* Std sense key specific field */ 683 /* Illegal parameter is in the parameter block */ 684 685 if (sense_code == SENCODE_INVALID_CDB_FIELD) 686 sense_buf[15] = 0xc0;/* Std sense key specific field */ 687 /* Illegal parameter is in the CDB block */ 688 sense_buf[15] |= bit_pointer; 689 sense_buf[16] = field_pointer >> 8; /* MSB */ 690 sense_buf[17] = field_pointer; /* LSB */ 691 } 692 } 693 694 int aac_get_adapter_info(struct aac_dev* dev) 695 { 696 struct fib* fibptr; 697 int rcode; 698 u32 tmp; 699 struct aac_adapter_info *info; 700 struct aac_bus_info *command; 701 struct aac_bus_info_response *bus_info; 702 703 if (!(fibptr = fib_alloc(dev))) 704 return -ENOMEM; 705 706 fib_init(fibptr); 707 info = (struct aac_adapter_info *) fib_data(fibptr); 708 memset(info,0,sizeof(*info)); 709 710 rcode = fib_send(RequestAdapterInfo, 711 fibptr, 712 sizeof(*info), 713 FsaNormal, 714 -1, 1, /* First `interrupt' command uses special wait */ 715 NULL, 716 NULL); 717 718 if (rcode < 0) { 719 fib_complete(fibptr); 720 fib_free(fibptr); 721 return rcode; 722 } 723 memcpy(&dev->adapter_info, info, sizeof(*info)); 724 725 if (dev->adapter_info.options & AAC_OPT_SUPPLEMENT_ADAPTER_INFO) { 726 struct aac_supplement_adapter_info * info; 727 728 fib_init(fibptr); 729 730 info = (struct aac_supplement_adapter_info *) fib_data(fibptr); 731 732 memset(info,0,sizeof(*info)); 733 734 rcode = fib_send(RequestSupplementAdapterInfo, 735 fibptr, 736 sizeof(*info), 737 FsaNormal, 738 1, 1, 739 NULL, 740 NULL); 741 742 if (rcode >= 0) 743 memcpy(&dev->supplement_adapter_info, info, sizeof(*info)); 744 } 745 746 747 /* 748 * GetBusInfo 749 */ 750 751 fib_init(fibptr); 752 753 bus_info = (struct aac_bus_info_response *) fib_data(fibptr); 754 755 memset(bus_info, 0, sizeof(*bus_info)); 756 757 command = (struct aac_bus_info *)bus_info; 758 759 command->Command = cpu_to_le32(VM_Ioctl); 760 command->ObjType = cpu_to_le32(FT_DRIVE); 761 command->MethodId = cpu_to_le32(1); 762 command->CtlCmd = cpu_to_le32(GetBusInfo); 763 764 rcode = fib_send(ContainerCommand, 765 fibptr, 766 sizeof (*bus_info), 767 FsaNormal, 768 1, 1, 769 NULL, NULL); 770 771 if (rcode >= 0 && le32_to_cpu(bus_info->Status) == ST_OK) { 772 dev->maximum_num_physicals = le32_to_cpu(bus_info->TargetsPerBus); 773 dev->maximum_num_channels = le32_to_cpu(bus_info->BusCount); 774 } 775 776 tmp = le32_to_cpu(dev->adapter_info.kernelrev); 777 printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 778 dev->name, 779 dev->id, 780 tmp>>24, 781 (tmp>>16)&0xff, 782 tmp&0xff, 783 le32_to_cpu(dev->adapter_info.kernelbuild), 784 (int)sizeof(dev->supplement_adapter_info.BuildDate), 785 dev->supplement_adapter_info.BuildDate); 786 tmp = le32_to_cpu(dev->adapter_info.monitorrev); 787 printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 788 dev->name, dev->id, 789 tmp>>24,(tmp>>16)&0xff,tmp&0xff, 790 le32_to_cpu(dev->adapter_info.monitorbuild)); 791 tmp = le32_to_cpu(dev->adapter_info.biosrev); 792 printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 793 dev->name, dev->id, 794 tmp>>24,(tmp>>16)&0xff,tmp&0xff, 795 le32_to_cpu(dev->adapter_info.biosbuild)); 796 if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) 797 printk(KERN_INFO "%s%d: serial %x\n", 798 dev->name, dev->id, 799 le32_to_cpu(dev->adapter_info.serial[0])); 800 801 dev->nondasd_support = 0; 802 dev->raid_scsi_mode = 0; 803 if(dev->adapter_info.options & AAC_OPT_NONDASD){ 804 dev->nondasd_support = 1; 805 } 806 807 /* 808 * If the firmware supports ROMB RAID/SCSI mode and we are currently 809 * in RAID/SCSI mode, set the flag. For now if in this mode we will 810 * force nondasd support on. If we decide to allow the non-dasd flag 811 * additional changes changes will have to be made to support 812 * RAID/SCSI. the function aac_scsi_cmd in this module will have to be 813 * changed to support the new dev->raid_scsi_mode flag instead of 814 * leaching off of the dev->nondasd_support flag. Also in linit.c the 815 * function aac_detect will have to be modified where it sets up the 816 * max number of channels based on the aac->nondasd_support flag only. 817 */ 818 if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) && 819 (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) { 820 dev->nondasd_support = 1; 821 dev->raid_scsi_mode = 1; 822 } 823 if (dev->raid_scsi_mode != 0) 824 printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n", 825 dev->name, dev->id); 826 827 if(nondasd != -1) { 828 dev->nondasd_support = (nondasd!=0); 829 } 830 if(dev->nondasd_support != 0){ 831 printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id); 832 } 833 834 dev->dac_support = 0; 835 if( (sizeof(dma_addr_t) > 4) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){ 836 printk(KERN_INFO "%s%d: 64bit support enabled.\n", dev->name, dev->id); 837 dev->dac_support = 1; 838 } 839 840 if(dacmode != -1) { 841 dev->dac_support = (dacmode!=0); 842 } 843 if(dev->dac_support != 0) { 844 if (!pci_set_dma_mask(dev->pdev, DMA_64BIT_MASK) && 845 !pci_set_consistent_dma_mask(dev->pdev, DMA_64BIT_MASK)) { 846 printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n", 847 dev->name, dev->id); 848 } else if (!pci_set_dma_mask(dev->pdev, DMA_32BIT_MASK) && 849 !pci_set_consistent_dma_mask(dev->pdev, DMA_32BIT_MASK)) { 850 printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n", 851 dev->name, dev->id); 852 dev->dac_support = 0; 853 } else { 854 printk(KERN_WARNING"%s%d: No suitable DMA available.\n", 855 dev->name, dev->id); 856 rcode = -ENOMEM; 857 } 858 } 859 /* 860 * 57 scatter gather elements 861 */ 862 if (!(dev->raw_io_interface)) { 863 dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size - 864 sizeof(struct aac_fibhdr) - 865 sizeof(struct aac_write) + sizeof(struct sgentry)) / 866 sizeof(struct sgentry); 867 if (dev->dac_support) { 868 /* 869 * 38 scatter gather elements 870 */ 871 dev->scsi_host_ptr->sg_tablesize = 872 (dev->max_fib_size - 873 sizeof(struct aac_fibhdr) - 874 sizeof(struct aac_write64) + 875 sizeof(struct sgentry64)) / 876 sizeof(struct sgentry64); 877 } 878 dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT; 879 if(!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) { 880 /* 881 * Worst case size that could cause sg overflow when 882 * we break up SG elements that are larger than 64KB. 883 * Would be nice if we could tell the SCSI layer what 884 * the maximum SG element size can be. Worst case is 885 * (sg_tablesize-1) 4KB elements with one 64KB 886 * element. 887 * 32bit -> 468 or 238KB 64bit -> 424 or 212KB 888 */ 889 dev->scsi_host_ptr->max_sectors = 890 (dev->scsi_host_ptr->sg_tablesize * 8) + 112; 891 } 892 } 893 894 fib_complete(fibptr); 895 fib_free(fibptr); 896 897 return rcode; 898 } 899 900 901 static void io_callback(void *context, struct fib * fibptr) 902 { 903 struct aac_dev *dev; 904 struct aac_read_reply *readreply; 905 struct scsi_cmnd *scsicmd; 906 u32 cid; 907 908 scsicmd = (struct scsi_cmnd *) context; 909 910 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 911 cid = ID_LUN_TO_CONTAINER(scsicmd->device->id, scsicmd->device->lun); 912 913 if (nblank(dprintk(x))) { 914 u64 lba; 915 switch (scsicmd->cmnd[0]) { 916 case WRITE_6: 917 case READ_6: 918 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 919 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 920 break; 921 case WRITE_16: 922 case READ_16: 923 lba = ((u64)scsicmd->cmnd[2] << 56) | 924 ((u64)scsicmd->cmnd[3] << 48) | 925 ((u64)scsicmd->cmnd[4] << 40) | 926 ((u64)scsicmd->cmnd[5] << 32) | 927 ((u64)scsicmd->cmnd[6] << 24) | 928 (scsicmd->cmnd[7] << 16) | 929 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 930 break; 931 case WRITE_12: 932 case READ_12: 933 lba = ((u64)scsicmd->cmnd[2] << 24) | 934 (scsicmd->cmnd[3] << 16) | 935 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 936 break; 937 default: 938 lba = ((u64)scsicmd->cmnd[2] << 24) | 939 (scsicmd->cmnd[3] << 16) | 940 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 941 break; 942 } 943 printk(KERN_DEBUG 944 "io_callback[cpu %d]: lba = %llu, t = %ld.\n", 945 smp_processor_id(), (unsigned long long)lba, jiffies); 946 } 947 948 if (fibptr == NULL) 949 BUG(); 950 951 if(scsicmd->use_sg) 952 pci_unmap_sg(dev->pdev, 953 (struct scatterlist *)scsicmd->buffer, 954 scsicmd->use_sg, 955 scsicmd->sc_data_direction); 956 else if(scsicmd->request_bufflen) 957 pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, 958 scsicmd->request_bufflen, 959 scsicmd->sc_data_direction); 960 readreply = (struct aac_read_reply *)fib_data(fibptr); 961 if (le32_to_cpu(readreply->status) == ST_OK) 962 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 963 else { 964 #ifdef AAC_DETAILED_STATUS_INFO 965 printk(KERN_WARNING "io_callback: io failed, status = %d\n", 966 le32_to_cpu(readreply->status)); 967 #endif 968 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 969 set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 970 HARDWARE_ERROR, 971 SENCODE_INTERNAL_TARGET_FAILURE, 972 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 973 0, 0); 974 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 975 (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 976 ? sizeof(scsicmd->sense_buffer) 977 : sizeof(dev->fsa_dev[cid].sense_data)); 978 } 979 fib_complete(fibptr); 980 fib_free(fibptr); 981 982 scsicmd->scsi_done(scsicmd); 983 } 984 985 static int aac_read(struct scsi_cmnd * scsicmd, int cid) 986 { 987 u64 lba; 988 u32 count; 989 int status; 990 991 u16 fibsize; 992 struct aac_dev *dev; 993 struct fib * cmd_fibcontext; 994 995 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 996 /* 997 * Get block address and transfer length 998 */ 999 switch (scsicmd->cmnd[0]) { 1000 case READ_6: 1001 dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", cid)); 1002 1003 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | 1004 (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 1005 count = scsicmd->cmnd[4]; 1006 1007 if (count == 0) 1008 count = 256; 1009 break; 1010 case READ_16: 1011 dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", cid)); 1012 1013 lba = ((u64)scsicmd->cmnd[2] << 56) | 1014 ((u64)scsicmd->cmnd[3] << 48) | 1015 ((u64)scsicmd->cmnd[4] << 40) | 1016 ((u64)scsicmd->cmnd[5] << 32) | 1017 ((u64)scsicmd->cmnd[6] << 24) | 1018 (scsicmd->cmnd[7] << 16) | 1019 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 1020 count = (scsicmd->cmnd[10] << 24) | 1021 (scsicmd->cmnd[11] << 16) | 1022 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 1023 break; 1024 case READ_12: 1025 dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", cid)); 1026 1027 lba = ((u64)scsicmd->cmnd[2] << 24) | 1028 (scsicmd->cmnd[3] << 16) | 1029 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1030 count = (scsicmd->cmnd[6] << 24) | 1031 (scsicmd->cmnd[7] << 16) | 1032 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 1033 break; 1034 default: 1035 dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", cid)); 1036 1037 lba = ((u64)scsicmd->cmnd[2] << 24) | 1038 (scsicmd->cmnd[3] << 16) | 1039 (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1040 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 1041 break; 1042 } 1043 dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n", 1044 smp_processor_id(), (unsigned long long)lba, jiffies)); 1045 if ((!(dev->raw_io_interface) || !(dev->raw_io_64)) && 1046 (lba & 0xffffffff00000000LL)) { 1047 dprintk((KERN_DEBUG "aac_read: Illegal lba\n")); 1048 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | 1049 SAM_STAT_CHECK_CONDITION; 1050 set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 1051 HARDWARE_ERROR, 1052 SENCODE_INTERNAL_TARGET_FAILURE, 1053 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 1054 0, 0); 1055 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1056 (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 1057 ? sizeof(scsicmd->sense_buffer) 1058 : sizeof(dev->fsa_dev[cid].sense_data)); 1059 scsicmd->scsi_done(scsicmd); 1060 return 0; 1061 } 1062 /* 1063 * Alocate and initialize a Fib 1064 */ 1065 if (!(cmd_fibcontext = fib_alloc(dev))) { 1066 return -1; 1067 } 1068 1069 fib_init(cmd_fibcontext); 1070 1071 if (dev->raw_io_interface) { 1072 struct aac_raw_io *readcmd; 1073 readcmd = (struct aac_raw_io *) fib_data(cmd_fibcontext); 1074 readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1075 readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1076 readcmd->count = cpu_to_le32(count<<9); 1077 readcmd->cid = cpu_to_le16(cid); 1078 readcmd->flags = cpu_to_le16(1); 1079 readcmd->bpTotal = 0; 1080 readcmd->bpComplete = 0; 1081 1082 aac_build_sgraw(scsicmd, &readcmd->sg); 1083 fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw)); 1084 if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr))) 1085 BUG(); 1086 /* 1087 * Now send the Fib to the adapter 1088 */ 1089 status = fib_send(ContainerRawIo, 1090 cmd_fibcontext, 1091 fibsize, 1092 FsaNormal, 1093 0, 1, 1094 (fib_callback) io_callback, 1095 (void *) scsicmd); 1096 } else if (dev->dac_support == 1) { 1097 struct aac_read64 *readcmd; 1098 readcmd = (struct aac_read64 *) fib_data(cmd_fibcontext); 1099 readcmd->command = cpu_to_le32(VM_CtHostRead64); 1100 readcmd->cid = cpu_to_le16(cid); 1101 readcmd->sector_count = cpu_to_le16(count); 1102 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1103 readcmd->pad = 0; 1104 readcmd->flags = 0; 1105 1106 aac_build_sg64(scsicmd, &readcmd->sg); 1107 fibsize = sizeof(struct aac_read64) + 1108 ((le32_to_cpu(readcmd->sg.count) - 1) * 1109 sizeof (struct sgentry64)); 1110 BUG_ON (fibsize > (dev->max_fib_size - 1111 sizeof(struct aac_fibhdr))); 1112 /* 1113 * Now send the Fib to the adapter 1114 */ 1115 status = fib_send(ContainerCommand64, 1116 cmd_fibcontext, 1117 fibsize, 1118 FsaNormal, 1119 0, 1, 1120 (fib_callback) io_callback, 1121 (void *) scsicmd); 1122 } else { 1123 struct aac_read *readcmd; 1124 readcmd = (struct aac_read *) fib_data(cmd_fibcontext); 1125 readcmd->command = cpu_to_le32(VM_CtBlockRead); 1126 readcmd->cid = cpu_to_le32(cid); 1127 readcmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1128 readcmd->count = cpu_to_le32(count * 512); 1129 1130 aac_build_sg(scsicmd, &readcmd->sg); 1131 fibsize = sizeof(struct aac_read) + 1132 ((le32_to_cpu(readcmd->sg.count) - 1) * 1133 sizeof (struct sgentry)); 1134 BUG_ON (fibsize > (dev->max_fib_size - 1135 sizeof(struct aac_fibhdr))); 1136 /* 1137 * Now send the Fib to the adapter 1138 */ 1139 status = fib_send(ContainerCommand, 1140 cmd_fibcontext, 1141 fibsize, 1142 FsaNormal, 1143 0, 1, 1144 (fib_callback) io_callback, 1145 (void *) scsicmd); 1146 } 1147 1148 1149 1150 /* 1151 * Check that the command queued to the controller 1152 */ 1153 if (status == -EINPROGRESS) 1154 return 0; 1155 1156 printk(KERN_WARNING "aac_read: fib_send failed with status: %d.\n", status); 1157 /* 1158 * For some reason, the Fib didn't queue, return QUEUE_FULL 1159 */ 1160 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 1161 scsicmd->scsi_done(scsicmd); 1162 fib_complete(cmd_fibcontext); 1163 fib_free(cmd_fibcontext); 1164 return 0; 1165 } 1166 1167 static int aac_write(struct scsi_cmnd * scsicmd, int cid) 1168 { 1169 u64 lba; 1170 u32 count; 1171 int status; 1172 u16 fibsize; 1173 struct aac_dev *dev; 1174 struct fib * cmd_fibcontext; 1175 1176 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1177 /* 1178 * Get block address and transfer length 1179 */ 1180 if (scsicmd->cmnd[0] == WRITE_6) /* 6 byte command */ 1181 { 1182 lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3]; 1183 count = scsicmd->cmnd[4]; 1184 if (count == 0) 1185 count = 256; 1186 } else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */ 1187 dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", cid)); 1188 1189 lba = ((u64)scsicmd->cmnd[2] << 56) | 1190 ((u64)scsicmd->cmnd[3] << 48) | 1191 ((u64)scsicmd->cmnd[4] << 40) | 1192 ((u64)scsicmd->cmnd[5] << 32) | 1193 ((u64)scsicmd->cmnd[6] << 24) | 1194 (scsicmd->cmnd[7] << 16) | 1195 (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 1196 count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16) | 1197 (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13]; 1198 } else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */ 1199 dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", cid)); 1200 1201 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) 1202 | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1203 count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16) 1204 | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9]; 1205 } else { 1206 dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", cid)); 1207 lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5]; 1208 count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8]; 1209 } 1210 dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n", 1211 smp_processor_id(), (unsigned long long)lba, jiffies)); 1212 if ((!(dev->raw_io_interface) || !(dev->raw_io_64)) 1213 && (lba & 0xffffffff00000000LL)) { 1214 dprintk((KERN_DEBUG "aac_write: Illegal lba\n")); 1215 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 1216 set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 1217 HARDWARE_ERROR, 1218 SENCODE_INTERNAL_TARGET_FAILURE, 1219 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 1220 0, 0); 1221 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1222 (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 1223 ? sizeof(scsicmd->sense_buffer) 1224 : sizeof(dev->fsa_dev[cid].sense_data)); 1225 scsicmd->scsi_done(scsicmd); 1226 return 0; 1227 } 1228 /* 1229 * Allocate and initialize a Fib then setup a BlockWrite command 1230 */ 1231 if (!(cmd_fibcontext = fib_alloc(dev))) { 1232 scsicmd->result = DID_ERROR << 16; 1233 scsicmd->scsi_done(scsicmd); 1234 return 0; 1235 } 1236 fib_init(cmd_fibcontext); 1237 1238 if (dev->raw_io_interface) { 1239 struct aac_raw_io *writecmd; 1240 writecmd = (struct aac_raw_io *) fib_data(cmd_fibcontext); 1241 writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff)); 1242 writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32)); 1243 writecmd->count = cpu_to_le32(count<<9); 1244 writecmd->cid = cpu_to_le16(cid); 1245 writecmd->flags = 0; 1246 writecmd->bpTotal = 0; 1247 writecmd->bpComplete = 0; 1248 1249 aac_build_sgraw(scsicmd, &writecmd->sg); 1250 fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw)); 1251 if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr))) 1252 BUG(); 1253 /* 1254 * Now send the Fib to the adapter 1255 */ 1256 status = fib_send(ContainerRawIo, 1257 cmd_fibcontext, 1258 fibsize, 1259 FsaNormal, 1260 0, 1, 1261 (fib_callback) io_callback, 1262 (void *) scsicmd); 1263 } else if (dev->dac_support == 1) { 1264 struct aac_write64 *writecmd; 1265 writecmd = (struct aac_write64 *) fib_data(cmd_fibcontext); 1266 writecmd->command = cpu_to_le32(VM_CtHostWrite64); 1267 writecmd->cid = cpu_to_le16(cid); 1268 writecmd->sector_count = cpu_to_le16(count); 1269 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1270 writecmd->pad = 0; 1271 writecmd->flags = 0; 1272 1273 aac_build_sg64(scsicmd, &writecmd->sg); 1274 fibsize = sizeof(struct aac_write64) + 1275 ((le32_to_cpu(writecmd->sg.count) - 1) * 1276 sizeof (struct sgentry64)); 1277 BUG_ON (fibsize > (dev->max_fib_size - 1278 sizeof(struct aac_fibhdr))); 1279 /* 1280 * Now send the Fib to the adapter 1281 */ 1282 status = fib_send(ContainerCommand64, 1283 cmd_fibcontext, 1284 fibsize, 1285 FsaNormal, 1286 0, 1, 1287 (fib_callback) io_callback, 1288 (void *) scsicmd); 1289 } else { 1290 struct aac_write *writecmd; 1291 writecmd = (struct aac_write *) fib_data(cmd_fibcontext); 1292 writecmd->command = cpu_to_le32(VM_CtBlockWrite); 1293 writecmd->cid = cpu_to_le32(cid); 1294 writecmd->block = cpu_to_le32((u32)(lba&0xffffffff)); 1295 writecmd->count = cpu_to_le32(count * 512); 1296 writecmd->sg.count = cpu_to_le32(1); 1297 /* ->stable is not used - it did mean which type of write */ 1298 1299 aac_build_sg(scsicmd, &writecmd->sg); 1300 fibsize = sizeof(struct aac_write) + 1301 ((le32_to_cpu(writecmd->sg.count) - 1) * 1302 sizeof (struct sgentry)); 1303 BUG_ON (fibsize > (dev->max_fib_size - 1304 sizeof(struct aac_fibhdr))); 1305 /* 1306 * Now send the Fib to the adapter 1307 */ 1308 status = fib_send(ContainerCommand, 1309 cmd_fibcontext, 1310 fibsize, 1311 FsaNormal, 1312 0, 1, 1313 (fib_callback) io_callback, 1314 (void *) scsicmd); 1315 } 1316 1317 /* 1318 * Check that the command queued to the controller 1319 */ 1320 if (status == -EINPROGRESS) 1321 { 1322 return 0; 1323 } 1324 1325 printk(KERN_WARNING "aac_write: fib_send failed with status: %d\n", status); 1326 /* 1327 * For some reason, the Fib didn't queue, return QUEUE_FULL 1328 */ 1329 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL; 1330 scsicmd->scsi_done(scsicmd); 1331 1332 fib_complete(cmd_fibcontext); 1333 fib_free(cmd_fibcontext); 1334 return 0; 1335 } 1336 1337 static void synchronize_callback(void *context, struct fib *fibptr) 1338 { 1339 struct aac_synchronize_reply *synchronizereply; 1340 struct scsi_cmnd *cmd; 1341 1342 cmd = context; 1343 1344 dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 1345 smp_processor_id(), jiffies)); 1346 BUG_ON(fibptr == NULL); 1347 1348 1349 synchronizereply = fib_data(fibptr); 1350 if (le32_to_cpu(synchronizereply->status) == CT_OK) 1351 cmd->result = DID_OK << 16 | 1352 COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1353 else { 1354 struct scsi_device *sdev = cmd->device; 1355 struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata; 1356 u32 cid = ID_LUN_TO_CONTAINER(sdev->id, sdev->lun); 1357 printk(KERN_WARNING 1358 "synchronize_callback: synchronize failed, status = %d\n", 1359 le32_to_cpu(synchronizereply->status)); 1360 cmd->result = DID_OK << 16 | 1361 COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 1362 set_sense((u8 *)&dev->fsa_dev[cid].sense_data, 1363 HARDWARE_ERROR, 1364 SENCODE_INTERNAL_TARGET_FAILURE, 1365 ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0, 1366 0, 0); 1367 memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1368 min(sizeof(dev->fsa_dev[cid].sense_data), 1369 sizeof(cmd->sense_buffer))); 1370 } 1371 1372 fib_complete(fibptr); 1373 fib_free(fibptr); 1374 cmd->scsi_done(cmd); 1375 } 1376 1377 static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid) 1378 { 1379 int status; 1380 struct fib *cmd_fibcontext; 1381 struct aac_synchronize *synchronizecmd; 1382 struct scsi_cmnd *cmd; 1383 struct scsi_device *sdev = scsicmd->device; 1384 int active = 0; 1385 unsigned long flags; 1386 1387 /* 1388 * Wait for all commands to complete to this specific 1389 * target (block). 1390 */ 1391 spin_lock_irqsave(&sdev->list_lock, flags); 1392 list_for_each_entry(cmd, &sdev->cmd_list, list) 1393 if (cmd != scsicmd && cmd->serial_number != 0) { 1394 ++active; 1395 break; 1396 } 1397 1398 spin_unlock_irqrestore(&sdev->list_lock, flags); 1399 1400 /* 1401 * Yield the processor (requeue for later) 1402 */ 1403 if (active) 1404 return SCSI_MLQUEUE_DEVICE_BUSY; 1405 1406 /* 1407 * Allocate and initialize a Fib 1408 */ 1409 if (!(cmd_fibcontext = 1410 fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) 1411 return SCSI_MLQUEUE_HOST_BUSY; 1412 1413 fib_init(cmd_fibcontext); 1414 1415 synchronizecmd = fib_data(cmd_fibcontext); 1416 synchronizecmd->command = cpu_to_le32(VM_ContainerConfig); 1417 synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE); 1418 synchronizecmd->cid = cpu_to_le32(cid); 1419 synchronizecmd->count = 1420 cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data)); 1421 1422 /* 1423 * Now send the Fib to the adapter 1424 */ 1425 status = fib_send(ContainerCommand, 1426 cmd_fibcontext, 1427 sizeof(struct aac_synchronize), 1428 FsaNormal, 1429 0, 1, 1430 (fib_callback)synchronize_callback, 1431 (void *)scsicmd); 1432 1433 /* 1434 * Check that the command queued to the controller 1435 */ 1436 if (status == -EINPROGRESS) 1437 return 0; 1438 1439 printk(KERN_WARNING 1440 "aac_synchronize: fib_send failed with status: %d.\n", status); 1441 fib_complete(cmd_fibcontext); 1442 fib_free(cmd_fibcontext); 1443 return SCSI_MLQUEUE_HOST_BUSY; 1444 } 1445 1446 /** 1447 * aac_scsi_cmd() - Process SCSI command 1448 * @scsicmd: SCSI command block 1449 * 1450 * Emulate a SCSI command and queue the required request for the 1451 * aacraid firmware. 1452 */ 1453 1454 int aac_scsi_cmd(struct scsi_cmnd * scsicmd) 1455 { 1456 u32 cid = 0; 1457 struct Scsi_Host *host = scsicmd->device->host; 1458 struct aac_dev *dev = (struct aac_dev *)host->hostdata; 1459 struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev; 1460 int ret; 1461 1462 /* 1463 * If the bus, id or lun is out of range, return fail 1464 * Test does not apply to ID 16, the pseudo id for the controller 1465 * itself. 1466 */ 1467 if (scmd_id(scsicmd) != host->this_id) { 1468 if ((scsicmd->device->channel == 0) ){ 1469 if( (scsicmd->device->id >= dev->maximum_num_containers) || (scsicmd->device->lun != 0)){ 1470 scsicmd->result = DID_NO_CONNECT << 16; 1471 scsicmd->scsi_done(scsicmd); 1472 return 0; 1473 } 1474 cid = ID_LUN_TO_CONTAINER(scsicmd->device->id, scsicmd->device->lun); 1475 1476 /* 1477 * If the target container doesn't exist, it may have 1478 * been newly created 1479 */ 1480 if ((fsa_dev_ptr[cid].valid & 1) == 0) { 1481 switch (scsicmd->cmnd[0]) { 1482 case SERVICE_ACTION_IN: 1483 if (!(dev->raw_io_interface) || 1484 !(dev->raw_io_64) || 1485 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 1486 break; 1487 case INQUIRY: 1488 case READ_CAPACITY: 1489 case TEST_UNIT_READY: 1490 spin_unlock_irq(host->host_lock); 1491 probe_container(dev, cid); 1492 if ((fsa_dev_ptr[cid].valid & 1) == 0) 1493 fsa_dev_ptr[cid].valid = 0; 1494 spin_lock_irq(host->host_lock); 1495 if (fsa_dev_ptr[cid].valid == 0) { 1496 scsicmd->result = DID_NO_CONNECT << 16; 1497 scsicmd->scsi_done(scsicmd); 1498 return 0; 1499 } 1500 default: 1501 break; 1502 } 1503 } 1504 /* 1505 * If the target container still doesn't exist, 1506 * return failure 1507 */ 1508 if (fsa_dev_ptr[cid].valid == 0) { 1509 scsicmd->result = DID_BAD_TARGET << 16; 1510 scsicmd->scsi_done(scsicmd); 1511 return 0; 1512 } 1513 } else { /* check for physical non-dasd devices */ 1514 if(dev->nondasd_support == 1){ 1515 return aac_send_srb_fib(scsicmd); 1516 } else { 1517 scsicmd->result = DID_NO_CONNECT << 16; 1518 scsicmd->scsi_done(scsicmd); 1519 return 0; 1520 } 1521 } 1522 } 1523 /* 1524 * else Command for the controller itself 1525 */ 1526 else if ((scsicmd->cmnd[0] != INQUIRY) && /* only INQUIRY & TUR cmnd supported for controller */ 1527 (scsicmd->cmnd[0] != TEST_UNIT_READY)) 1528 { 1529 dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0])); 1530 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 1531 set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 1532 ILLEGAL_REQUEST, 1533 SENCODE_INVALID_COMMAND, 1534 ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 1535 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1536 (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 1537 ? sizeof(scsicmd->sense_buffer) 1538 : sizeof(dev->fsa_dev[cid].sense_data)); 1539 scsicmd->scsi_done(scsicmd); 1540 return 0; 1541 } 1542 1543 1544 /* Handle commands here that don't really require going out to the adapter */ 1545 switch (scsicmd->cmnd[0]) { 1546 case INQUIRY: 1547 { 1548 struct inquiry_data inq_data; 1549 1550 dprintk((KERN_DEBUG "INQUIRY command, ID: %d.\n", scsicmd->device->id)); 1551 memset(&inq_data, 0, sizeof (struct inquiry_data)); 1552 1553 inq_data.inqd_ver = 2; /* claim compliance to SCSI-2 */ 1554 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 */ 1555 inq_data.inqd_len = 31; 1556 /*Format for "pad2" is RelAdr | WBus32 | WBus16 | Sync | Linked |Reserved| CmdQue | SftRe */ 1557 inq_data.inqd_pad2= 0x32 ; /*WBus16|Sync|CmdQue */ 1558 /* 1559 * Set the Vendor, Product, and Revision Level 1560 * see: <vendor>.c i.e. aac.c 1561 */ 1562 if (scmd_id(scsicmd) == host->this_id) { 1563 setinqstr(dev, (void *) (inq_data.inqd_vid), (sizeof(container_types)/sizeof(char *))); 1564 inq_data.inqd_pdt = INQD_PDT_PROC; /* Processor device */ 1565 aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 1566 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1567 scsicmd->scsi_done(scsicmd); 1568 return 0; 1569 } 1570 setinqstr(dev, (void *) (inq_data.inqd_vid), fsa_dev_ptr[cid].type); 1571 inq_data.inqd_pdt = INQD_PDT_DA; /* Direct/random access device */ 1572 aac_internal_transfer(scsicmd, &inq_data, 0, sizeof(inq_data)); 1573 return aac_get_container_name(scsicmd, cid); 1574 } 1575 case SERVICE_ACTION_IN: 1576 if (!(dev->raw_io_interface) || 1577 !(dev->raw_io_64) || 1578 ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) 1579 break; 1580 { 1581 u64 capacity; 1582 char cp[13]; 1583 1584 dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n")); 1585 capacity = fsa_dev_ptr[cid].size - 1; 1586 cp[0] = (capacity >> 56) & 0xff; 1587 cp[1] = (capacity >> 48) & 0xff; 1588 cp[2] = (capacity >> 40) & 0xff; 1589 cp[3] = (capacity >> 32) & 0xff; 1590 cp[4] = (capacity >> 24) & 0xff; 1591 cp[5] = (capacity >> 16) & 0xff; 1592 cp[6] = (capacity >> 8) & 0xff; 1593 cp[7] = (capacity >> 0) & 0xff; 1594 cp[8] = 0; 1595 cp[9] = 0; 1596 cp[10] = 2; 1597 cp[11] = 0; 1598 cp[12] = 0; 1599 aac_internal_transfer(scsicmd, cp, 0, 1600 min((unsigned int)scsicmd->cmnd[13], sizeof(cp))); 1601 if (sizeof(cp) < scsicmd->cmnd[13]) { 1602 unsigned int len, offset = sizeof(cp); 1603 1604 memset(cp, 0, offset); 1605 do { 1606 len = min(scsicmd->cmnd[13]-offset, sizeof(cp)); 1607 aac_internal_transfer(scsicmd, cp, offset, len); 1608 } while ((offset += len) < scsicmd->cmnd[13]); 1609 } 1610 1611 /* Do not cache partition table for arrays */ 1612 scsicmd->device->removable = 1; 1613 1614 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1615 scsicmd->scsi_done(scsicmd); 1616 1617 return 0; 1618 } 1619 1620 case READ_CAPACITY: 1621 { 1622 u32 capacity; 1623 char cp[8]; 1624 1625 dprintk((KERN_DEBUG "READ CAPACITY command.\n")); 1626 if (fsa_dev_ptr[cid].size <= 0x100000000ULL) 1627 capacity = fsa_dev_ptr[cid].size - 1; 1628 else 1629 capacity = (u32)-1; 1630 1631 cp[0] = (capacity >> 24) & 0xff; 1632 cp[1] = (capacity >> 16) & 0xff; 1633 cp[2] = (capacity >> 8) & 0xff; 1634 cp[3] = (capacity >> 0) & 0xff; 1635 cp[4] = 0; 1636 cp[5] = 0; 1637 cp[6] = 2; 1638 cp[7] = 0; 1639 aac_internal_transfer(scsicmd, cp, 0, sizeof(cp)); 1640 /* Do not cache partition table for arrays */ 1641 scsicmd->device->removable = 1; 1642 1643 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1644 scsicmd->scsi_done(scsicmd); 1645 1646 return 0; 1647 } 1648 1649 case MODE_SENSE: 1650 { 1651 char mode_buf[4]; 1652 1653 dprintk((KERN_DEBUG "MODE SENSE command.\n")); 1654 mode_buf[0] = 3; /* Mode data length */ 1655 mode_buf[1] = 0; /* Medium type - default */ 1656 mode_buf[2] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 1657 mode_buf[3] = 0; /* Block descriptor length */ 1658 1659 aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 1660 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1661 scsicmd->scsi_done(scsicmd); 1662 1663 return 0; 1664 } 1665 case MODE_SENSE_10: 1666 { 1667 char mode_buf[8]; 1668 1669 dprintk((KERN_DEBUG "MODE SENSE 10 byte command.\n")); 1670 mode_buf[0] = 0; /* Mode data length (MSB) */ 1671 mode_buf[1] = 6; /* Mode data length (LSB) */ 1672 mode_buf[2] = 0; /* Medium type - default */ 1673 mode_buf[3] = 0; /* Device-specific param, bit 8: 0/1 = write enabled/protected */ 1674 mode_buf[4] = 0; /* reserved */ 1675 mode_buf[5] = 0; /* reserved */ 1676 mode_buf[6] = 0; /* Block descriptor length (MSB) */ 1677 mode_buf[7] = 0; /* Block descriptor length (LSB) */ 1678 aac_internal_transfer(scsicmd, mode_buf, 0, sizeof(mode_buf)); 1679 1680 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1681 scsicmd->scsi_done(scsicmd); 1682 1683 return 0; 1684 } 1685 case REQUEST_SENSE: 1686 dprintk((KERN_DEBUG "REQUEST SENSE command.\n")); 1687 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data)); 1688 memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data)); 1689 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1690 scsicmd->scsi_done(scsicmd); 1691 return 0; 1692 1693 case ALLOW_MEDIUM_REMOVAL: 1694 dprintk((KERN_DEBUG "LOCK command.\n")); 1695 if (scsicmd->cmnd[4]) 1696 fsa_dev_ptr[cid].locked = 1; 1697 else 1698 fsa_dev_ptr[cid].locked = 0; 1699 1700 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1701 scsicmd->scsi_done(scsicmd); 1702 return 0; 1703 /* 1704 * These commands are all No-Ops 1705 */ 1706 case TEST_UNIT_READY: 1707 case RESERVE: 1708 case RELEASE: 1709 case REZERO_UNIT: 1710 case REASSIGN_BLOCKS: 1711 case SEEK_10: 1712 case START_STOP: 1713 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD; 1714 scsicmd->scsi_done(scsicmd); 1715 return 0; 1716 } 1717 1718 switch (scsicmd->cmnd[0]) 1719 { 1720 case READ_6: 1721 case READ_10: 1722 case READ_12: 1723 case READ_16: 1724 /* 1725 * Hack to keep track of ordinal number of the device that 1726 * corresponds to a container. Needed to convert 1727 * containers to /dev/sd device names 1728 */ 1729 1730 spin_unlock_irq(host->host_lock); 1731 if (scsicmd->request->rq_disk) 1732 strlcpy(fsa_dev_ptr[cid].devname, 1733 scsicmd->request->rq_disk->disk_name, 1734 min(sizeof(fsa_dev_ptr[cid].devname), 1735 sizeof(scsicmd->request->rq_disk->disk_name) + 1)); 1736 ret = aac_read(scsicmd, cid); 1737 spin_lock_irq(host->host_lock); 1738 return ret; 1739 1740 case WRITE_6: 1741 case WRITE_10: 1742 case WRITE_12: 1743 case WRITE_16: 1744 spin_unlock_irq(host->host_lock); 1745 ret = aac_write(scsicmd, cid); 1746 spin_lock_irq(host->host_lock); 1747 return ret; 1748 1749 case SYNCHRONIZE_CACHE: 1750 /* Issue FIB to tell Firmware to flush it's cache */ 1751 return aac_synchronize(scsicmd, cid); 1752 1753 default: 1754 /* 1755 * Unhandled commands 1756 */ 1757 dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0])); 1758 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 1759 set_sense((u8 *) &dev->fsa_dev[cid].sense_data, 1760 ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND, 1761 ASENCODE_INVALID_COMMAND, 0, 0, 0, 0); 1762 memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, 1763 (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer)) 1764 ? sizeof(scsicmd->sense_buffer) 1765 : sizeof(dev->fsa_dev[cid].sense_data)); 1766 scsicmd->scsi_done(scsicmd); 1767 return 0; 1768 } 1769 } 1770 1771 static int query_disk(struct aac_dev *dev, void __user *arg) 1772 { 1773 struct aac_query_disk qd; 1774 struct fsa_dev_info *fsa_dev_ptr; 1775 1776 fsa_dev_ptr = dev->fsa_dev; 1777 if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk))) 1778 return -EFAULT; 1779 if (qd.cnum == -1) 1780 qd.cnum = ID_LUN_TO_CONTAINER(qd.id, qd.lun); 1781 else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 1782 { 1783 if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers) 1784 return -EINVAL; 1785 qd.instance = dev->scsi_host_ptr->host_no; 1786 qd.bus = 0; 1787 qd.id = CONTAINER_TO_ID(qd.cnum); 1788 qd.lun = CONTAINER_TO_LUN(qd.cnum); 1789 } 1790 else return -EINVAL; 1791 1792 qd.valid = fsa_dev_ptr[qd.cnum].valid; 1793 qd.locked = fsa_dev_ptr[qd.cnum].locked; 1794 qd.deleted = fsa_dev_ptr[qd.cnum].deleted; 1795 1796 if (fsa_dev_ptr[qd.cnum].devname[0] == '\0') 1797 qd.unmapped = 1; 1798 else 1799 qd.unmapped = 0; 1800 1801 strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname, 1802 min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1)); 1803 1804 if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk))) 1805 return -EFAULT; 1806 return 0; 1807 } 1808 1809 static int force_delete_disk(struct aac_dev *dev, void __user *arg) 1810 { 1811 struct aac_delete_disk dd; 1812 struct fsa_dev_info *fsa_dev_ptr; 1813 1814 fsa_dev_ptr = dev->fsa_dev; 1815 1816 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 1817 return -EFAULT; 1818 1819 if (dd.cnum >= dev->maximum_num_containers) 1820 return -EINVAL; 1821 /* 1822 * Mark this container as being deleted. 1823 */ 1824 fsa_dev_ptr[dd.cnum].deleted = 1; 1825 /* 1826 * Mark the container as no longer valid 1827 */ 1828 fsa_dev_ptr[dd.cnum].valid = 0; 1829 return 0; 1830 } 1831 1832 static int delete_disk(struct aac_dev *dev, void __user *arg) 1833 { 1834 struct aac_delete_disk dd; 1835 struct fsa_dev_info *fsa_dev_ptr; 1836 1837 fsa_dev_ptr = dev->fsa_dev; 1838 1839 if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk))) 1840 return -EFAULT; 1841 1842 if (dd.cnum >= dev->maximum_num_containers) 1843 return -EINVAL; 1844 /* 1845 * If the container is locked, it can not be deleted by the API. 1846 */ 1847 if (fsa_dev_ptr[dd.cnum].locked) 1848 return -EBUSY; 1849 else { 1850 /* 1851 * Mark the container as no longer being valid. 1852 */ 1853 fsa_dev_ptr[dd.cnum].valid = 0; 1854 fsa_dev_ptr[dd.cnum].devname[0] = '\0'; 1855 return 0; 1856 } 1857 } 1858 1859 int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg) 1860 { 1861 switch (cmd) { 1862 case FSACTL_QUERY_DISK: 1863 return query_disk(dev, arg); 1864 case FSACTL_DELETE_DISK: 1865 return delete_disk(dev, arg); 1866 case FSACTL_FORCE_DELETE_DISK: 1867 return force_delete_disk(dev, arg); 1868 case FSACTL_GET_CONTAINERS: 1869 return aac_get_containers(dev); 1870 default: 1871 return -ENOTTY; 1872 } 1873 } 1874 1875 /** 1876 * 1877 * aac_srb_callback 1878 * @context: the context set in the fib - here it is scsi cmd 1879 * @fibptr: pointer to the fib 1880 * 1881 * Handles the completion of a scsi command to a non dasd device 1882 * 1883 */ 1884 1885 static void aac_srb_callback(void *context, struct fib * fibptr) 1886 { 1887 struct aac_dev *dev; 1888 struct aac_srb_reply *srbreply; 1889 struct scsi_cmnd *scsicmd; 1890 1891 scsicmd = (struct scsi_cmnd *) context; 1892 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 1893 1894 if (fibptr == NULL) 1895 BUG(); 1896 1897 srbreply = (struct aac_srb_reply *) fib_data(fibptr); 1898 1899 scsicmd->sense_buffer[0] = '\0'; /* Initialize sense valid flag to false */ 1900 /* 1901 * Calculate resid for sg 1902 */ 1903 1904 scsicmd->resid = scsicmd->request_bufflen - 1905 le32_to_cpu(srbreply->data_xfer_length); 1906 1907 if(scsicmd->use_sg) 1908 pci_unmap_sg(dev->pdev, 1909 (struct scatterlist *)scsicmd->buffer, 1910 scsicmd->use_sg, 1911 scsicmd->sc_data_direction); 1912 else if(scsicmd->request_bufflen) 1913 pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, scsicmd->request_bufflen, 1914 scsicmd->sc_data_direction); 1915 1916 /* 1917 * First check the fib status 1918 */ 1919 1920 if (le32_to_cpu(srbreply->status) != ST_OK){ 1921 int len; 1922 printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status)); 1923 len = (le32_to_cpu(srbreply->sense_data_size) > 1924 sizeof(scsicmd->sense_buffer)) ? 1925 sizeof(scsicmd->sense_buffer) : 1926 le32_to_cpu(srbreply->sense_data_size); 1927 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION; 1928 memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 1929 } 1930 1931 /* 1932 * Next check the srb status 1933 */ 1934 switch( (le32_to_cpu(srbreply->srb_status))&0x3f){ 1935 case SRB_STATUS_ERROR_RECOVERY: 1936 case SRB_STATUS_PENDING: 1937 case SRB_STATUS_SUCCESS: 1938 if(scsicmd->cmnd[0] == INQUIRY ){ 1939 u8 b; 1940 u8 b1; 1941 /* We can't expose disk devices because we can't tell whether they 1942 * are the raw container drives or stand alone drives. If they have 1943 * the removable bit set then we should expose them though. 1944 */ 1945 b = (*(u8*)scsicmd->buffer)&0x1f; 1946 b1 = ((u8*)scsicmd->buffer)[1]; 1947 if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER 1948 || (b==TYPE_DISK && (b1&0x80)) ){ 1949 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 1950 /* 1951 * We will allow disk devices if in RAID/SCSI mode and 1952 * the channel is 2 1953 */ 1954 } else if ((dev->raid_scsi_mode) && 1955 (scmd_channel(scsicmd) == 2)) { 1956 scsicmd->result = DID_OK << 16 | 1957 COMMAND_COMPLETE << 8; 1958 } else { 1959 scsicmd->result = DID_NO_CONNECT << 16 | 1960 COMMAND_COMPLETE << 8; 1961 } 1962 } else { 1963 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 1964 } 1965 break; 1966 case SRB_STATUS_DATA_OVERRUN: 1967 switch(scsicmd->cmnd[0]){ 1968 case READ_6: 1969 case WRITE_6: 1970 case READ_10: 1971 case WRITE_10: 1972 case READ_12: 1973 case WRITE_12: 1974 case READ_16: 1975 case WRITE_16: 1976 if(le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow ) { 1977 printk(KERN_WARNING"aacraid: SCSI CMD underflow\n"); 1978 } else { 1979 printk(KERN_WARNING"aacraid: SCSI CMD Data Overrun\n"); 1980 } 1981 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 1982 break; 1983 case INQUIRY: { 1984 u8 b; 1985 u8 b1; 1986 /* We can't expose disk devices because we can't tell whether they 1987 * are the raw container drives or stand alone drives 1988 */ 1989 b = (*(u8*)scsicmd->buffer)&0x0f; 1990 b1 = ((u8*)scsicmd->buffer)[1]; 1991 if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER 1992 || (b==TYPE_DISK && (b1&0x80)) ){ 1993 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 1994 /* 1995 * We will allow disk devices if in RAID/SCSI mode and 1996 * the channel is 2 1997 */ 1998 } else if ((dev->raid_scsi_mode) && 1999 (scmd_channel(scsicmd) == 2)) { 2000 scsicmd->result = DID_OK << 16 | 2001 COMMAND_COMPLETE << 8; 2002 } else { 2003 scsicmd->result = DID_NO_CONNECT << 16 | 2004 COMMAND_COMPLETE << 8; 2005 } 2006 break; 2007 } 2008 default: 2009 scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8; 2010 break; 2011 } 2012 break; 2013 case SRB_STATUS_ABORTED: 2014 scsicmd->result = DID_ABORT << 16 | ABORT << 8; 2015 break; 2016 case SRB_STATUS_ABORT_FAILED: 2017 // Not sure about this one - but assuming the hba was trying to abort for some reason 2018 scsicmd->result = DID_ERROR << 16 | ABORT << 8; 2019 break; 2020 case SRB_STATUS_PARITY_ERROR: 2021 scsicmd->result = DID_PARITY << 16 | MSG_PARITY_ERROR << 8; 2022 break; 2023 case SRB_STATUS_NO_DEVICE: 2024 case SRB_STATUS_INVALID_PATH_ID: 2025 case SRB_STATUS_INVALID_TARGET_ID: 2026 case SRB_STATUS_INVALID_LUN: 2027 case SRB_STATUS_SELECTION_TIMEOUT: 2028 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 2029 break; 2030 2031 case SRB_STATUS_COMMAND_TIMEOUT: 2032 case SRB_STATUS_TIMEOUT: 2033 scsicmd->result = DID_TIME_OUT << 16 | COMMAND_COMPLETE << 8; 2034 break; 2035 2036 case SRB_STATUS_BUSY: 2037 scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8; 2038 break; 2039 2040 case SRB_STATUS_BUS_RESET: 2041 scsicmd->result = DID_RESET << 16 | COMMAND_COMPLETE << 8; 2042 break; 2043 2044 case SRB_STATUS_MESSAGE_REJECTED: 2045 scsicmd->result = DID_ERROR << 16 | MESSAGE_REJECT << 8; 2046 break; 2047 case SRB_STATUS_REQUEST_FLUSHED: 2048 case SRB_STATUS_ERROR: 2049 case SRB_STATUS_INVALID_REQUEST: 2050 case SRB_STATUS_REQUEST_SENSE_FAILED: 2051 case SRB_STATUS_NO_HBA: 2052 case SRB_STATUS_UNEXPECTED_BUS_FREE: 2053 case SRB_STATUS_PHASE_SEQUENCE_FAILURE: 2054 case SRB_STATUS_BAD_SRB_BLOCK_LENGTH: 2055 case SRB_STATUS_DELAYED_RETRY: 2056 case SRB_STATUS_BAD_FUNCTION: 2057 case SRB_STATUS_NOT_STARTED: 2058 case SRB_STATUS_NOT_IN_USE: 2059 case SRB_STATUS_FORCE_ABORT: 2060 case SRB_STATUS_DOMAIN_VALIDATION_FAIL: 2061 default: 2062 #ifdef AAC_DETAILED_STATUS_INFO 2063 printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n", 2064 le32_to_cpu(srbreply->srb_status) & 0x3F, 2065 aac_get_status_string( 2066 le32_to_cpu(srbreply->srb_status) & 0x3F), 2067 scsicmd->cmnd[0], 2068 le32_to_cpu(srbreply->scsi_status)); 2069 #endif 2070 scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8; 2071 break; 2072 } 2073 if (le32_to_cpu(srbreply->scsi_status) == 0x02 ){ // Check Condition 2074 int len; 2075 scsicmd->result |= SAM_STAT_CHECK_CONDITION; 2076 len = (le32_to_cpu(srbreply->sense_data_size) > 2077 sizeof(scsicmd->sense_buffer)) ? 2078 sizeof(scsicmd->sense_buffer) : 2079 le32_to_cpu(srbreply->sense_data_size); 2080 #ifdef AAC_DETAILED_STATUS_INFO 2081 printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", 2082 le32_to_cpu(srbreply->status), len); 2083 #endif 2084 memcpy(scsicmd->sense_buffer, srbreply->sense_data, len); 2085 2086 } 2087 /* 2088 * OR in the scsi status (already shifted up a bit) 2089 */ 2090 scsicmd->result |= le32_to_cpu(srbreply->scsi_status); 2091 2092 fib_complete(fibptr); 2093 fib_free(fibptr); 2094 scsicmd->scsi_done(scsicmd); 2095 } 2096 2097 /** 2098 * 2099 * aac_send_scb_fib 2100 * @scsicmd: the scsi command block 2101 * 2102 * This routine will form a FIB and fill in the aac_srb from the 2103 * scsicmd passed in. 2104 */ 2105 2106 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd) 2107 { 2108 struct fib* cmd_fibcontext; 2109 struct aac_dev* dev; 2110 int status; 2111 struct aac_srb *srbcmd; 2112 u16 fibsize; 2113 u32 flag; 2114 u32 timeout; 2115 2116 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2117 if (scsicmd->device->id >= dev->maximum_num_physicals || 2118 scsicmd->device->lun > 7) { 2119 scsicmd->result = DID_NO_CONNECT << 16; 2120 scsicmd->scsi_done(scsicmd); 2121 return 0; 2122 } 2123 2124 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2125 switch(scsicmd->sc_data_direction){ 2126 case DMA_TO_DEVICE: 2127 flag = SRB_DataOut; 2128 break; 2129 case DMA_BIDIRECTIONAL: 2130 flag = SRB_DataIn | SRB_DataOut; 2131 break; 2132 case DMA_FROM_DEVICE: 2133 flag = SRB_DataIn; 2134 break; 2135 case DMA_NONE: 2136 default: /* shuts up some versions of gcc */ 2137 flag = SRB_NoDataXfer; 2138 break; 2139 } 2140 2141 2142 /* 2143 * Allocate and initialize a Fib then setup a BlockWrite command 2144 */ 2145 if (!(cmd_fibcontext = fib_alloc(dev))) { 2146 return -1; 2147 } 2148 fib_init(cmd_fibcontext); 2149 2150 srbcmd = (struct aac_srb*) fib_data(cmd_fibcontext); 2151 srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi); 2152 srbcmd->channel = cpu_to_le32(aac_logical_to_phys(scsicmd->device->channel)); 2153 srbcmd->id = cpu_to_le32(scsicmd->device->id); 2154 srbcmd->lun = cpu_to_le32(scsicmd->device->lun); 2155 srbcmd->flags = cpu_to_le32(flag); 2156 timeout = scsicmd->timeout_per_command/HZ; 2157 if(timeout == 0){ 2158 timeout = 1; 2159 } 2160 srbcmd->timeout = cpu_to_le32(timeout); // timeout in seconds 2161 srbcmd->retry_limit = 0; /* Obsolete parameter */ 2162 srbcmd->cdb_size = cpu_to_le32(scsicmd->cmd_len); 2163 2164 if( dev->dac_support == 1 ) { 2165 aac_build_sg64(scsicmd, (struct sgmap64*) &srbcmd->sg); 2166 srbcmd->count = cpu_to_le32(scsicmd->request_bufflen); 2167 2168 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 2169 memcpy(srbcmd->cdb, scsicmd->cmnd, scsicmd->cmd_len); 2170 /* 2171 * Build Scatter/Gather list 2172 */ 2173 fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) + 2174 ((le32_to_cpu(srbcmd->sg.count) & 0xff) * 2175 sizeof (struct sgentry64)); 2176 BUG_ON (fibsize > (dev->max_fib_size - 2177 sizeof(struct aac_fibhdr))); 2178 2179 /* 2180 * Now send the Fib to the adapter 2181 */ 2182 status = fib_send(ScsiPortCommand64, cmd_fibcontext, 2183 fibsize, FsaNormal, 0, 1, 2184 (fib_callback) aac_srb_callback, 2185 (void *) scsicmd); 2186 } else { 2187 aac_build_sg(scsicmd, (struct sgmap*)&srbcmd->sg); 2188 srbcmd->count = cpu_to_le32(scsicmd->request_bufflen); 2189 2190 memset(srbcmd->cdb, 0, sizeof(srbcmd->cdb)); 2191 memcpy(srbcmd->cdb, scsicmd->cmnd, scsicmd->cmd_len); 2192 /* 2193 * Build Scatter/Gather list 2194 */ 2195 fibsize = sizeof (struct aac_srb) + 2196 (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 2197 sizeof (struct sgentry)); 2198 BUG_ON (fibsize > (dev->max_fib_size - 2199 sizeof(struct aac_fibhdr))); 2200 2201 /* 2202 * Now send the Fib to the adapter 2203 */ 2204 status = fib_send(ScsiPortCommand, cmd_fibcontext, fibsize, FsaNormal, 0, 1, 2205 (fib_callback) aac_srb_callback, (void *) scsicmd); 2206 } 2207 /* 2208 * Check that the command queued to the controller 2209 */ 2210 if (status == -EINPROGRESS){ 2211 return 0; 2212 } 2213 2214 printk(KERN_WARNING "aac_srb: fib_send failed with status: %d\n", status); 2215 fib_complete(cmd_fibcontext); 2216 fib_free(cmd_fibcontext); 2217 2218 return -1; 2219 } 2220 2221 static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg) 2222 { 2223 struct aac_dev *dev; 2224 unsigned long byte_count = 0; 2225 2226 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2227 // Get rid of old data 2228 psg->count = 0; 2229 psg->sg[0].addr = 0; 2230 psg->sg[0].count = 0; 2231 if (scsicmd->use_sg) { 2232 struct scatterlist *sg; 2233 int i; 2234 int sg_count; 2235 sg = (struct scatterlist *) scsicmd->request_buffer; 2236 2237 sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 2238 scsicmd->sc_data_direction); 2239 psg->count = cpu_to_le32(sg_count); 2240 2241 byte_count = 0; 2242 2243 for (i = 0; i < sg_count; i++) { 2244 psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg)); 2245 psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 2246 byte_count += sg_dma_len(sg); 2247 sg++; 2248 } 2249 /* hba wants the size to be exact */ 2250 if(byte_count > scsicmd->request_bufflen){ 2251 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2252 (byte_count - scsicmd->request_bufflen); 2253 psg->sg[i-1].count = cpu_to_le32(temp); 2254 byte_count = scsicmd->request_bufflen; 2255 } 2256 /* Check for command underflow */ 2257 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 2258 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 2259 byte_count, scsicmd->underflow); 2260 } 2261 } 2262 else if(scsicmd->request_bufflen) { 2263 dma_addr_t addr; 2264 addr = pci_map_single(dev->pdev, 2265 scsicmd->request_buffer, 2266 scsicmd->request_bufflen, 2267 scsicmd->sc_data_direction); 2268 psg->count = cpu_to_le32(1); 2269 psg->sg[0].addr = cpu_to_le32(addr); 2270 psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 2271 scsicmd->SCp.dma_handle = addr; 2272 byte_count = scsicmd->request_bufflen; 2273 } 2274 return byte_count; 2275 } 2276 2277 2278 static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg) 2279 { 2280 struct aac_dev *dev; 2281 unsigned long byte_count = 0; 2282 u64 addr; 2283 2284 dev = (struct aac_dev *)scsicmd->device->host->hostdata; 2285 // Get rid of old data 2286 psg->count = 0; 2287 psg->sg[0].addr[0] = 0; 2288 psg->sg[0].addr[1] = 0; 2289 psg->sg[0].count = 0; 2290 if (scsicmd->use_sg) { 2291 struct scatterlist *sg; 2292 int i; 2293 int sg_count; 2294 sg = (struct scatterlist *) scsicmd->request_buffer; 2295 2296 sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 2297 scsicmd->sc_data_direction); 2298 psg->count = cpu_to_le32(sg_count); 2299 2300 byte_count = 0; 2301 2302 for (i = 0; i < sg_count; i++) { 2303 addr = sg_dma_address(sg); 2304 psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff); 2305 psg->sg[i].addr[1] = cpu_to_le32(addr>>32); 2306 psg->sg[i].count = cpu_to_le32(sg_dma_len(sg)); 2307 byte_count += sg_dma_len(sg); 2308 sg++; 2309 } 2310 /* hba wants the size to be exact */ 2311 if(byte_count > scsicmd->request_bufflen){ 2312 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2313 (byte_count - scsicmd->request_bufflen); 2314 psg->sg[i-1].count = cpu_to_le32(temp); 2315 byte_count = scsicmd->request_bufflen; 2316 } 2317 /* Check for command underflow */ 2318 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 2319 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 2320 byte_count, scsicmd->underflow); 2321 } 2322 } 2323 else if(scsicmd->request_bufflen) { 2324 u64 addr; 2325 addr = pci_map_single(dev->pdev, 2326 scsicmd->request_buffer, 2327 scsicmd->request_bufflen, 2328 scsicmd->sc_data_direction); 2329 psg->count = cpu_to_le32(1); 2330 psg->sg[0].addr[0] = cpu_to_le32(addr & 0xffffffff); 2331 psg->sg[0].addr[1] = cpu_to_le32(addr >> 32); 2332 psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen); 2333 scsicmd->SCp.dma_handle = addr; 2334 byte_count = scsicmd->request_bufflen; 2335 } 2336 return byte_count; 2337 } 2338 2339 static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg) 2340 { 2341 struct Scsi_Host *host = scsicmd->device->host; 2342 struct aac_dev *dev = (struct aac_dev *)host->hostdata; 2343 unsigned long byte_count = 0; 2344 2345 // Get rid of old data 2346 psg->count = 0; 2347 psg->sg[0].next = 0; 2348 psg->sg[0].prev = 0; 2349 psg->sg[0].addr[0] = 0; 2350 psg->sg[0].addr[1] = 0; 2351 psg->sg[0].count = 0; 2352 psg->sg[0].flags = 0; 2353 if (scsicmd->use_sg) { 2354 struct scatterlist *sg; 2355 int i; 2356 int sg_count; 2357 sg = (struct scatterlist *) scsicmd->request_buffer; 2358 2359 sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg, 2360 scsicmd->sc_data_direction); 2361 2362 for (i = 0; i < sg_count; i++) { 2363 int count = sg_dma_len(sg); 2364 u64 addr = sg_dma_address(sg); 2365 psg->sg[i].next = 0; 2366 psg->sg[i].prev = 0; 2367 psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32)); 2368 psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 2369 psg->sg[i].count = cpu_to_le32(count); 2370 psg->sg[i].flags = 0; 2371 byte_count += count; 2372 sg++; 2373 } 2374 psg->count = cpu_to_le32(sg_count); 2375 /* hba wants the size to be exact */ 2376 if(byte_count > scsicmd->request_bufflen){ 2377 u32 temp = le32_to_cpu(psg->sg[i-1].count) - 2378 (byte_count - scsicmd->request_bufflen); 2379 psg->sg[i-1].count = cpu_to_le32(temp); 2380 byte_count = scsicmd->request_bufflen; 2381 } 2382 /* Check for command underflow */ 2383 if(scsicmd->underflow && (byte_count < scsicmd->underflow)){ 2384 printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n", 2385 byte_count, scsicmd->underflow); 2386 } 2387 } 2388 else if(scsicmd->request_bufflen) { 2389 int count; 2390 u64 addr; 2391 scsicmd->SCp.dma_handle = pci_map_single(dev->pdev, 2392 scsicmd->request_buffer, 2393 scsicmd->request_bufflen, 2394 scsicmd->sc_data_direction); 2395 addr = scsicmd->SCp.dma_handle; 2396 count = scsicmd->request_bufflen; 2397 psg->count = cpu_to_le32(1); 2398 psg->sg[0].next = 0; 2399 psg->sg[0].prev = 0; 2400 psg->sg[0].addr[1] = cpu_to_le32((u32)(addr>>32)); 2401 psg->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff)); 2402 psg->sg[0].count = cpu_to_le32(count); 2403 psg->sg[0].flags = 0; 2404 byte_count = scsicmd->request_bufflen; 2405 } 2406 return byte_count; 2407 } 2408 2409 #ifdef AAC_DETAILED_STATUS_INFO 2410 2411 struct aac_srb_status_info { 2412 u32 status; 2413 char *str; 2414 }; 2415 2416 2417 static struct aac_srb_status_info srb_status_info[] = { 2418 { SRB_STATUS_PENDING, "Pending Status"}, 2419 { SRB_STATUS_SUCCESS, "Success"}, 2420 { SRB_STATUS_ABORTED, "Aborted Command"}, 2421 { SRB_STATUS_ABORT_FAILED, "Abort Failed"}, 2422 { SRB_STATUS_ERROR, "Error Event"}, 2423 { SRB_STATUS_BUSY, "Device Busy"}, 2424 { SRB_STATUS_INVALID_REQUEST, "Invalid Request"}, 2425 { SRB_STATUS_INVALID_PATH_ID, "Invalid Path ID"}, 2426 { SRB_STATUS_NO_DEVICE, "No Device"}, 2427 { SRB_STATUS_TIMEOUT, "Timeout"}, 2428 { SRB_STATUS_SELECTION_TIMEOUT, "Selection Timeout"}, 2429 { SRB_STATUS_COMMAND_TIMEOUT, "Command Timeout"}, 2430 { SRB_STATUS_MESSAGE_REJECTED, "Message Rejected"}, 2431 { SRB_STATUS_BUS_RESET, "Bus Reset"}, 2432 { SRB_STATUS_PARITY_ERROR, "Parity Error"}, 2433 { SRB_STATUS_REQUEST_SENSE_FAILED,"Request Sense Failed"}, 2434 { SRB_STATUS_NO_HBA, "No HBA"}, 2435 { SRB_STATUS_DATA_OVERRUN, "Data Overrun/Data Underrun"}, 2436 { SRB_STATUS_UNEXPECTED_BUS_FREE,"Unexpected Bus Free"}, 2437 { SRB_STATUS_PHASE_SEQUENCE_FAILURE,"Phase Error"}, 2438 { SRB_STATUS_BAD_SRB_BLOCK_LENGTH,"Bad Srb Block Length"}, 2439 { SRB_STATUS_REQUEST_FLUSHED, "Request Flushed"}, 2440 { SRB_STATUS_DELAYED_RETRY, "Delayed Retry"}, 2441 { SRB_STATUS_INVALID_LUN, "Invalid LUN"}, 2442 { SRB_STATUS_INVALID_TARGET_ID, "Invalid TARGET ID"}, 2443 { SRB_STATUS_BAD_FUNCTION, "Bad Function"}, 2444 { SRB_STATUS_ERROR_RECOVERY, "Error Recovery"}, 2445 { SRB_STATUS_NOT_STARTED, "Not Started"}, 2446 { SRB_STATUS_NOT_IN_USE, "Not In Use"}, 2447 { SRB_STATUS_FORCE_ABORT, "Force Abort"}, 2448 { SRB_STATUS_DOMAIN_VALIDATION_FAIL,"Domain Validation Failure"}, 2449 { 0xff, "Unknown Error"} 2450 }; 2451 2452 char *aac_get_status_string(u32 status) 2453 { 2454 int i; 2455 2456 for(i=0; i < (sizeof(srb_status_info)/sizeof(struct aac_srb_status_info)); i++ ){ 2457 if(srb_status_info[i].status == status){ 2458 return srb_status_info[i].str; 2459 } 2460 } 2461 2462 return "Bad Status Code"; 2463 } 2464 2465 #endif 2466