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