1 /* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC 2 * 3 * Current development and maintenance: 4 * (C) 2001-2002 Björn Stenberg (bjorn@haxx.se) 5 * 6 * Developed with the assistance of: 7 * (C) 2002 Alan Stern <stern@rowland.org> 8 * 9 * Initial work: 10 * (C) 2000 In-System Design, Inc. (support@in-system.com) 11 * 12 * The ISD200 ASIC does not natively support ATA devices. The chip 13 * does implement an interface, the ATA Command Block (ATACB) which provides 14 * a means of passing ATA commands and ATA register accesses to a device. 15 * 16 * This program is free software; you can redistribute it and/or modify it 17 * under the terms of the GNU General Public License as published by the 18 * Free Software Foundation; either version 2, or (at your option) any 19 * later version. 20 * 21 * This program is distributed in the hope that it will be useful, but 22 * WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 24 * General Public License for more details. 25 * 26 * You should have received a copy of the GNU General Public License along 27 * with this program; if not, write to the Free Software Foundation, Inc., 28 * 675 Mass Ave, Cambridge, MA 02139, USA. 29 * 30 * History: 31 * 32 * 2002-10-19: Removed the specialized transfer routines. 33 * (Alan Stern <stern@rowland.harvard.edu>) 34 * 2001-02-24: Removed lots of duplicate code and simplified the structure. 35 * (bjorn@haxx.se) 36 * 2002-01-16: Fixed endianness bug so it works on the ppc arch. 37 * (Luc Saillard <luc@saillard.org>) 38 * 2002-01-17: All bitfields removed. 39 * (bjorn@haxx.se) 40 */ 41 42 43 /* Include files */ 44 45 #include <linux/jiffies.h> 46 #include <linux/errno.h> 47 #include <linux/slab.h> 48 #include <linux/hdreg.h> 49 #include <linux/scatterlist.h> 50 51 #include <scsi/scsi.h> 52 #include <scsi/scsi_cmnd.h> 53 #include <scsi/scsi_device.h> 54 55 #include "usb.h" 56 #include "transport.h" 57 #include "protocol.h" 58 #include "debug.h" 59 #include "scsiglue.h" 60 #include "isd200.h" 61 62 63 /* Timeout defines (in Seconds) */ 64 65 #define ISD200_ENUM_BSY_TIMEOUT 35 66 #define ISD200_ENUM_DETECT_TIMEOUT 30 67 #define ISD200_DEFAULT_TIMEOUT 30 68 69 /* device flags */ 70 #define DF_ATA_DEVICE 0x0001 71 #define DF_MEDIA_STATUS_ENABLED 0x0002 72 #define DF_REMOVABLE_MEDIA 0x0004 73 74 /* capability bit definitions */ 75 #define CAPABILITY_DMA 0x01 76 #define CAPABILITY_LBA 0x02 77 78 /* command_setX bit definitions */ 79 #define COMMANDSET_REMOVABLE 0x02 80 #define COMMANDSET_MEDIA_STATUS 0x10 81 82 /* ATA Vendor Specific defines */ 83 #define ATA_ADDRESS_DEVHEAD_STD 0xa0 84 #define ATA_ADDRESS_DEVHEAD_LBA_MODE 0x40 85 #define ATA_ADDRESS_DEVHEAD_SLAVE 0x10 86 87 /* Action Select bits */ 88 #define ACTION_SELECT_0 0x01 89 #define ACTION_SELECT_1 0x02 90 #define ACTION_SELECT_2 0x04 91 #define ACTION_SELECT_3 0x08 92 #define ACTION_SELECT_4 0x10 93 #define ACTION_SELECT_5 0x20 94 #define ACTION_SELECT_6 0x40 95 #define ACTION_SELECT_7 0x80 96 97 /* Register Select bits */ 98 #define REG_ALTERNATE_STATUS 0x01 99 #define REG_DEVICE_CONTROL 0x01 100 #define REG_ERROR 0x02 101 #define REG_FEATURES 0x02 102 #define REG_SECTOR_COUNT 0x04 103 #define REG_SECTOR_NUMBER 0x08 104 #define REG_CYLINDER_LOW 0x10 105 #define REG_CYLINDER_HIGH 0x20 106 #define REG_DEVICE_HEAD 0x40 107 #define REG_STATUS 0x80 108 #define REG_COMMAND 0x80 109 110 /* ATA registers offset definitions */ 111 #define ATA_REG_ERROR_OFFSET 1 112 #define ATA_REG_LCYL_OFFSET 4 113 #define ATA_REG_HCYL_OFFSET 5 114 #define ATA_REG_STATUS_OFFSET 7 115 116 /* ATA error definitions not in <linux/hdreg.h> */ 117 #define ATA_ERROR_MEDIA_CHANGE 0x20 118 119 /* ATA command definitions not in <linux/hdreg.h> */ 120 #define ATA_COMMAND_GET_MEDIA_STATUS 0xDA 121 #define ATA_COMMAND_MEDIA_EJECT 0xED 122 123 /* ATA drive control definitions */ 124 #define ATA_DC_DISABLE_INTERRUPTS 0x02 125 #define ATA_DC_RESET_CONTROLLER 0x04 126 #define ATA_DC_REENABLE_CONTROLLER 0x00 127 128 /* 129 * General purpose return codes 130 */ 131 132 #define ISD200_ERROR -1 133 #define ISD200_GOOD 0 134 135 /* 136 * Transport return codes 137 */ 138 139 #define ISD200_TRANSPORT_GOOD 0 /* Transport good, command good */ 140 #define ISD200_TRANSPORT_FAILED 1 /* Transport good, command failed */ 141 #define ISD200_TRANSPORT_ERROR 2 /* Transport bad (i.e. device dead) */ 142 143 /* driver action codes */ 144 #define ACTION_READ_STATUS 0 145 #define ACTION_RESET 1 146 #define ACTION_REENABLE 2 147 #define ACTION_SOFT_RESET 3 148 #define ACTION_ENUM 4 149 #define ACTION_IDENTIFY 5 150 151 152 /* 153 * ata_cdb struct 154 */ 155 156 157 union ata_cdb { 158 struct { 159 unsigned char SignatureByte0; 160 unsigned char SignatureByte1; 161 unsigned char ActionSelect; 162 unsigned char RegisterSelect; 163 unsigned char TransferBlockSize; 164 unsigned char WriteData3F6; 165 unsigned char WriteData1F1; 166 unsigned char WriteData1F2; 167 unsigned char WriteData1F3; 168 unsigned char WriteData1F4; 169 unsigned char WriteData1F5; 170 unsigned char WriteData1F6; 171 unsigned char WriteData1F7; 172 unsigned char Reserved[3]; 173 } generic; 174 175 struct { 176 unsigned char SignatureByte0; 177 unsigned char SignatureByte1; 178 unsigned char ActionSelect; 179 unsigned char RegisterSelect; 180 unsigned char TransferBlockSize; 181 unsigned char AlternateStatusByte; 182 unsigned char ErrorByte; 183 unsigned char SectorCountByte; 184 unsigned char SectorNumberByte; 185 unsigned char CylinderLowByte; 186 unsigned char CylinderHighByte; 187 unsigned char DeviceHeadByte; 188 unsigned char StatusByte; 189 unsigned char Reserved[3]; 190 } read; 191 192 struct { 193 unsigned char SignatureByte0; 194 unsigned char SignatureByte1; 195 unsigned char ActionSelect; 196 unsigned char RegisterSelect; 197 unsigned char TransferBlockSize; 198 unsigned char DeviceControlByte; 199 unsigned char FeaturesByte; 200 unsigned char SectorCountByte; 201 unsigned char SectorNumberByte; 202 unsigned char CylinderLowByte; 203 unsigned char CylinderHighByte; 204 unsigned char DeviceHeadByte; 205 unsigned char CommandByte; 206 unsigned char Reserved[3]; 207 } write; 208 }; 209 210 211 /* 212 * Inquiry data structure. This is the data returned from the target 213 * after it receives an inquiry. 214 * 215 * This structure may be extended by the number of bytes specified 216 * in the field AdditionalLength. The defined size constant only 217 * includes fields through ProductRevisionLevel. 218 */ 219 220 /* 221 * DeviceType field 222 */ 223 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */ 224 #define DEVICE_REMOVABLE 0x80 225 226 struct inquiry_data { 227 unsigned char DeviceType; 228 unsigned char DeviceTypeModifier; 229 unsigned char Versions; 230 unsigned char Format; 231 unsigned char AdditionalLength; 232 unsigned char Reserved[2]; 233 unsigned char Capability; 234 unsigned char VendorId[8]; 235 unsigned char ProductId[16]; 236 unsigned char ProductRevisionLevel[4]; 237 unsigned char VendorSpecific[20]; 238 unsigned char Reserved3[40]; 239 } __attribute__ ((packed)); 240 241 /* 242 * INQUIRY data buffer size 243 */ 244 245 #define INQUIRYDATABUFFERSIZE 36 246 247 248 /* 249 * ISD200 CONFIG data struct 250 */ 251 252 #define ATACFG_TIMING 0x0f 253 #define ATACFG_ATAPI_RESET 0x10 254 #define ATACFG_MASTER 0x20 255 #define ATACFG_BLOCKSIZE 0xa0 256 257 #define ATACFGE_LAST_LUN 0x07 258 #define ATACFGE_DESC_OVERRIDE 0x08 259 #define ATACFGE_STATE_SUSPEND 0x10 260 #define ATACFGE_SKIP_BOOT 0x20 261 #define ATACFGE_CONF_DESC2 0x40 262 #define ATACFGE_INIT_STATUS 0x80 263 264 #define CFG_CAPABILITY_SRST 0x01 265 266 struct isd200_config { 267 unsigned char EventNotification; 268 unsigned char ExternalClock; 269 unsigned char ATAInitTimeout; 270 unsigned char ATAConfig; 271 unsigned char ATAMajorCommand; 272 unsigned char ATAMinorCommand; 273 unsigned char ATAExtraConfig; 274 unsigned char Capability; 275 }__attribute__ ((packed)); 276 277 278 /* 279 * ISD200 driver information struct 280 */ 281 282 struct isd200_info { 283 struct inquiry_data InquiryData; 284 struct hd_driveid *id; 285 struct isd200_config ConfigData; 286 unsigned char *RegsBuf; 287 unsigned char ATARegs[8]; 288 unsigned char DeviceHead; 289 unsigned char DeviceFlags; 290 291 /* maximum number of LUNs supported */ 292 unsigned char MaxLUNs; 293 unsigned char cmnd[BLK_MAX_CDB]; 294 struct scsi_cmnd srb; 295 struct scatterlist sg; 296 }; 297 298 299 /* 300 * Read Capacity Data - returned in Big Endian format 301 */ 302 303 struct read_capacity_data { 304 __be32 LogicalBlockAddress; 305 __be32 BytesPerBlock; 306 }; 307 308 /* 309 * Read Block Limits Data - returned in Big Endian format 310 * This structure returns the maximum and minimum block 311 * size for a TAPE device. 312 */ 313 314 struct read_block_limits { 315 unsigned char Reserved; 316 unsigned char BlockMaximumSize[3]; 317 unsigned char BlockMinimumSize[2]; 318 }; 319 320 321 /* 322 * Sense Data Format 323 */ 324 325 #define SENSE_ERRCODE 0x7f 326 #define SENSE_ERRCODE_VALID 0x80 327 #define SENSE_FLAG_SENSE_KEY 0x0f 328 #define SENSE_FLAG_BAD_LENGTH 0x20 329 #define SENSE_FLAG_END_OF_MEDIA 0x40 330 #define SENSE_FLAG_FILE_MARK 0x80 331 struct sense_data { 332 unsigned char ErrorCode; 333 unsigned char SegmentNumber; 334 unsigned char Flags; 335 unsigned char Information[4]; 336 unsigned char AdditionalSenseLength; 337 unsigned char CommandSpecificInformation[4]; 338 unsigned char AdditionalSenseCode; 339 unsigned char AdditionalSenseCodeQualifier; 340 unsigned char FieldReplaceableUnitCode; 341 unsigned char SenseKeySpecific[3]; 342 } __attribute__ ((packed)); 343 344 /* 345 * Default request sense buffer size 346 */ 347 348 #define SENSE_BUFFER_SIZE 18 349 350 /*********************************************************************** 351 * Helper routines 352 ***********************************************************************/ 353 354 /************************************************************************** 355 * isd200_build_sense 356 * 357 * Builds an artificial sense buffer to report the results of a 358 * failed command. 359 * 360 * RETURNS: 361 * void 362 */ 363 static void isd200_build_sense(struct us_data *us, struct scsi_cmnd *srb) 364 { 365 struct isd200_info *info = (struct isd200_info *)us->extra; 366 struct sense_data *buf = (struct sense_data *) &srb->sense_buffer[0]; 367 unsigned char error = info->ATARegs[ATA_REG_ERROR_OFFSET]; 368 369 if(error & ATA_ERROR_MEDIA_CHANGE) { 370 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 371 buf->AdditionalSenseLength = 0xb; 372 buf->Flags = UNIT_ATTENTION; 373 buf->AdditionalSenseCode = 0; 374 buf->AdditionalSenseCodeQualifier = 0; 375 } else if(error & MCR_ERR) { 376 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 377 buf->AdditionalSenseLength = 0xb; 378 buf->Flags = UNIT_ATTENTION; 379 buf->AdditionalSenseCode = 0; 380 buf->AdditionalSenseCodeQualifier = 0; 381 } else if(error & TRK0_ERR) { 382 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 383 buf->AdditionalSenseLength = 0xb; 384 buf->Flags = NOT_READY; 385 buf->AdditionalSenseCode = 0; 386 buf->AdditionalSenseCodeQualifier = 0; 387 } else if(error & ECC_ERR) { 388 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 389 buf->AdditionalSenseLength = 0xb; 390 buf->Flags = DATA_PROTECT; 391 buf->AdditionalSenseCode = 0; 392 buf->AdditionalSenseCodeQualifier = 0; 393 } else { 394 buf->ErrorCode = 0; 395 buf->AdditionalSenseLength = 0; 396 buf->Flags = 0; 397 buf->AdditionalSenseCode = 0; 398 buf->AdditionalSenseCodeQualifier = 0; 399 } 400 } 401 402 403 /*********************************************************************** 404 * Transport routines 405 ***********************************************************************/ 406 407 /************************************************************************** 408 * isd200_set_srb(), isd200_srb_set_bufflen() 409 * 410 * Two helpers to facilitate in initialization of scsi_cmnd structure 411 * Will need to change when struct scsi_cmnd changes 412 */ 413 static void isd200_set_srb(struct isd200_info *info, 414 enum dma_data_direction dir, void* buff, unsigned bufflen) 415 { 416 struct scsi_cmnd *srb = &info->srb; 417 418 if (buff) 419 sg_init_one(&info->sg, buff, bufflen); 420 421 srb->sc_data_direction = dir; 422 srb->sdb.table.sgl = buff ? &info->sg : NULL; 423 srb->sdb.length = bufflen; 424 srb->sdb.table.nents = buff ? 1 : 0; 425 } 426 427 static void isd200_srb_set_bufflen(struct scsi_cmnd *srb, unsigned bufflen) 428 { 429 srb->sdb.length = bufflen; 430 } 431 432 433 /************************************************************************** 434 * isd200_action 435 * 436 * Routine for sending commands to the isd200 437 * 438 * RETURNS: 439 * ISD status code 440 */ 441 static int isd200_action( struct us_data *us, int action, 442 void* pointer, int value ) 443 { 444 union ata_cdb ata; 445 struct scsi_device srb_dev; 446 struct isd200_info *info = (struct isd200_info *)us->extra; 447 struct scsi_cmnd *srb = &info->srb; 448 int status; 449 450 memset(&ata, 0, sizeof(ata)); 451 memset(&srb_dev, 0, sizeof(srb_dev)); 452 srb->cmnd = info->cmnd; 453 srb->device = &srb_dev; 454 ++srb->serial_number; 455 456 ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 457 ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 458 ata.generic.TransferBlockSize = 1; 459 460 switch ( action ) { 461 case ACTION_READ_STATUS: 462 US_DEBUGP(" isd200_action(READ_STATUS)\n"); 463 ata.generic.ActionSelect = ACTION_SELECT_0|ACTION_SELECT_2; 464 ata.generic.RegisterSelect = 465 REG_CYLINDER_LOW | REG_CYLINDER_HIGH | 466 REG_STATUS | REG_ERROR; 467 isd200_set_srb(info, DMA_FROM_DEVICE, pointer, value); 468 break; 469 470 case ACTION_ENUM: 471 US_DEBUGP(" isd200_action(ENUM,0x%02x)\n",value); 472 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2| 473 ACTION_SELECT_3|ACTION_SELECT_4| 474 ACTION_SELECT_5; 475 ata.generic.RegisterSelect = REG_DEVICE_HEAD; 476 ata.write.DeviceHeadByte = value; 477 isd200_set_srb(info, DMA_NONE, NULL, 0); 478 break; 479 480 case ACTION_RESET: 481 US_DEBUGP(" isd200_action(RESET)\n"); 482 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2| 483 ACTION_SELECT_3|ACTION_SELECT_4; 484 ata.generic.RegisterSelect = REG_DEVICE_CONTROL; 485 ata.write.DeviceControlByte = ATA_DC_RESET_CONTROLLER; 486 isd200_set_srb(info, DMA_NONE, NULL, 0); 487 break; 488 489 case ACTION_REENABLE: 490 US_DEBUGP(" isd200_action(REENABLE)\n"); 491 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2| 492 ACTION_SELECT_3|ACTION_SELECT_4; 493 ata.generic.RegisterSelect = REG_DEVICE_CONTROL; 494 ata.write.DeviceControlByte = ATA_DC_REENABLE_CONTROLLER; 495 isd200_set_srb(info, DMA_NONE, NULL, 0); 496 break; 497 498 case ACTION_SOFT_RESET: 499 US_DEBUGP(" isd200_action(SOFT_RESET)\n"); 500 ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5; 501 ata.generic.RegisterSelect = REG_DEVICE_HEAD | REG_COMMAND; 502 ata.write.DeviceHeadByte = info->DeviceHead; 503 ata.write.CommandByte = WIN_SRST; 504 isd200_set_srb(info, DMA_NONE, NULL, 0); 505 break; 506 507 case ACTION_IDENTIFY: 508 US_DEBUGP(" isd200_action(IDENTIFY)\n"); 509 ata.generic.RegisterSelect = REG_COMMAND; 510 ata.write.CommandByte = WIN_IDENTIFY; 511 isd200_set_srb(info, DMA_FROM_DEVICE, info->id, 512 sizeof(struct hd_driveid)); 513 break; 514 515 default: 516 US_DEBUGP("Error: Undefined action %d\n",action); 517 return ISD200_ERROR; 518 } 519 520 memcpy(srb->cmnd, &ata, sizeof(ata.generic)); 521 srb->cmd_len = sizeof(ata.generic); 522 status = usb_stor_Bulk_transport(srb, us); 523 if (status == USB_STOR_TRANSPORT_GOOD) 524 status = ISD200_GOOD; 525 else { 526 US_DEBUGP(" isd200_action(0x%02x) error: %d\n",action,status); 527 status = ISD200_ERROR; 528 /* need to reset device here */ 529 } 530 531 return status; 532 } 533 534 /************************************************************************** 535 * isd200_read_regs 536 * 537 * Read ATA Registers 538 * 539 * RETURNS: 540 * ISD status code 541 */ 542 static int isd200_read_regs( struct us_data *us ) 543 { 544 struct isd200_info *info = (struct isd200_info *)us->extra; 545 int retStatus = ISD200_GOOD; 546 int transferStatus; 547 548 US_DEBUGP("Entering isd200_IssueATAReadRegs\n"); 549 550 transferStatus = isd200_action( us, ACTION_READ_STATUS, 551 info->RegsBuf, sizeof(info->ATARegs) ); 552 if (transferStatus != ISD200_TRANSPORT_GOOD) { 553 US_DEBUGP(" Error reading ATA registers\n"); 554 retStatus = ISD200_ERROR; 555 } else { 556 memcpy(info->ATARegs, info->RegsBuf, sizeof(info->ATARegs)); 557 US_DEBUGP(" Got ATA Register[ATA_REG_ERROR_OFFSET] = 0x%x\n", 558 info->ATARegs[ATA_REG_ERROR_OFFSET]); 559 } 560 561 return retStatus; 562 } 563 564 565 /************************************************************************** 566 * Invoke the transport and basic error-handling/recovery methods 567 * 568 * This is used by the protocol layers to actually send the message to 569 * the device and receive the response. 570 */ 571 static void isd200_invoke_transport( struct us_data *us, 572 struct scsi_cmnd *srb, 573 union ata_cdb *ataCdb ) 574 { 575 int need_auto_sense = 0; 576 int transferStatus; 577 int result; 578 579 /* send the command to the transport layer */ 580 memcpy(srb->cmnd, ataCdb, sizeof(ataCdb->generic)); 581 srb->cmd_len = sizeof(ataCdb->generic); 582 transferStatus = usb_stor_Bulk_transport(srb, us); 583 584 /* if the command gets aborted by the higher layers, we need to 585 * short-circuit all other processing 586 */ 587 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) { 588 US_DEBUGP("-- command was aborted\n"); 589 goto Handle_Abort; 590 } 591 592 switch (transferStatus) { 593 594 case USB_STOR_TRANSPORT_GOOD: 595 /* Indicate a good result */ 596 srb->result = SAM_STAT_GOOD; 597 break; 598 599 case USB_STOR_TRANSPORT_NO_SENSE: 600 US_DEBUGP("-- transport indicates protocol failure\n"); 601 srb->result = SAM_STAT_CHECK_CONDITION; 602 return; 603 604 case USB_STOR_TRANSPORT_FAILED: 605 US_DEBUGP("-- transport indicates command failure\n"); 606 need_auto_sense = 1; 607 break; 608 609 case USB_STOR_TRANSPORT_ERROR: 610 US_DEBUGP("-- transport indicates transport error\n"); 611 srb->result = DID_ERROR << 16; 612 /* Need reset here */ 613 return; 614 615 default: 616 US_DEBUGP("-- transport indicates unknown error\n"); 617 srb->result = DID_ERROR << 16; 618 /* Need reset here */ 619 return; 620 } 621 622 if ((scsi_get_resid(srb) > 0) && 623 !((srb->cmnd[0] == REQUEST_SENSE) || 624 (srb->cmnd[0] == INQUIRY) || 625 (srb->cmnd[0] == MODE_SENSE) || 626 (srb->cmnd[0] == LOG_SENSE) || 627 (srb->cmnd[0] == MODE_SENSE_10))) { 628 US_DEBUGP("-- unexpectedly short transfer\n"); 629 need_auto_sense = 1; 630 } 631 632 if (need_auto_sense) { 633 result = isd200_read_regs(us); 634 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) { 635 US_DEBUGP("-- auto-sense aborted\n"); 636 goto Handle_Abort; 637 } 638 if (result == ISD200_GOOD) { 639 isd200_build_sense(us, srb); 640 srb->result = SAM_STAT_CHECK_CONDITION; 641 642 /* If things are really okay, then let's show that */ 643 if ((srb->sense_buffer[2] & 0xf) == 0x0) 644 srb->result = SAM_STAT_GOOD; 645 } else { 646 srb->result = DID_ERROR << 16; 647 /* Need reset here */ 648 } 649 } 650 651 /* Regardless of auto-sense, if we _know_ we have an error 652 * condition, show that in the result code 653 */ 654 if (transferStatus == USB_STOR_TRANSPORT_FAILED) 655 srb->result = SAM_STAT_CHECK_CONDITION; 656 return; 657 658 /* abort processing: the bulk-only transport requires a reset 659 * following an abort */ 660 Handle_Abort: 661 srb->result = DID_ABORT << 16; 662 663 /* permit the reset transfer to take place */ 664 clear_bit(US_FLIDX_ABORTING, &us->dflags); 665 /* Need reset here */ 666 } 667 668 #ifdef CONFIG_USB_STORAGE_DEBUG 669 static void isd200_log_config( struct isd200_info* info ) 670 { 671 US_DEBUGP(" Event Notification: 0x%x\n", 672 info->ConfigData.EventNotification); 673 US_DEBUGP(" External Clock: 0x%x\n", 674 info->ConfigData.ExternalClock); 675 US_DEBUGP(" ATA Init Timeout: 0x%x\n", 676 info->ConfigData.ATAInitTimeout); 677 US_DEBUGP(" ATAPI Command Block Size: 0x%x\n", 678 (info->ConfigData.ATAConfig & ATACFG_BLOCKSIZE) >> 6); 679 US_DEBUGP(" Master/Slave Selection: 0x%x\n", 680 info->ConfigData.ATAConfig & ATACFG_MASTER); 681 US_DEBUGP(" ATAPI Reset: 0x%x\n", 682 info->ConfigData.ATAConfig & ATACFG_ATAPI_RESET); 683 US_DEBUGP(" ATA Timing: 0x%x\n", 684 info->ConfigData.ATAConfig & ATACFG_TIMING); 685 US_DEBUGP(" ATA Major Command: 0x%x\n", 686 info->ConfigData.ATAMajorCommand); 687 US_DEBUGP(" ATA Minor Command: 0x%x\n", 688 info->ConfigData.ATAMinorCommand); 689 US_DEBUGP(" Init Status: 0x%x\n", 690 info->ConfigData.ATAExtraConfig & ATACFGE_INIT_STATUS); 691 US_DEBUGP(" Config Descriptor 2: 0x%x\n", 692 info->ConfigData.ATAExtraConfig & ATACFGE_CONF_DESC2); 693 US_DEBUGP(" Skip Device Boot: 0x%x\n", 694 info->ConfigData.ATAExtraConfig & ATACFGE_SKIP_BOOT); 695 US_DEBUGP(" ATA 3 State Supsend: 0x%x\n", 696 info->ConfigData.ATAExtraConfig & ATACFGE_STATE_SUSPEND); 697 US_DEBUGP(" Descriptor Override: 0x%x\n", 698 info->ConfigData.ATAExtraConfig & ATACFGE_DESC_OVERRIDE); 699 US_DEBUGP(" Last LUN Identifier: 0x%x\n", 700 info->ConfigData.ATAExtraConfig & ATACFGE_LAST_LUN); 701 US_DEBUGP(" SRST Enable: 0x%x\n", 702 info->ConfigData.ATAExtraConfig & CFG_CAPABILITY_SRST); 703 } 704 #endif 705 706 /************************************************************************** 707 * isd200_write_config 708 * 709 * Write the ISD200 Configuration data 710 * 711 * RETURNS: 712 * ISD status code 713 */ 714 static int isd200_write_config( struct us_data *us ) 715 { 716 struct isd200_info *info = (struct isd200_info *)us->extra; 717 int retStatus = ISD200_GOOD; 718 int result; 719 720 #ifdef CONFIG_USB_STORAGE_DEBUG 721 US_DEBUGP("Entering isd200_write_config\n"); 722 US_DEBUGP(" Writing the following ISD200 Config Data:\n"); 723 isd200_log_config(info); 724 #endif 725 726 /* let's send the command via the control pipe */ 727 result = usb_stor_ctrl_transfer( 728 us, 729 us->send_ctrl_pipe, 730 0x01, 731 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 732 0x0000, 733 0x0002, 734 (void *) &info->ConfigData, 735 sizeof(info->ConfigData)); 736 737 if (result >= 0) { 738 US_DEBUGP(" ISD200 Config Data was written successfully\n"); 739 } else { 740 US_DEBUGP(" Request to write ISD200 Config Data failed!\n"); 741 retStatus = ISD200_ERROR; 742 } 743 744 US_DEBUGP("Leaving isd200_write_config %08X\n", retStatus); 745 return retStatus; 746 } 747 748 749 /************************************************************************** 750 * isd200_read_config 751 * 752 * Reads the ISD200 Configuration data 753 * 754 * RETURNS: 755 * ISD status code 756 */ 757 static int isd200_read_config( struct us_data *us ) 758 { 759 struct isd200_info *info = (struct isd200_info *)us->extra; 760 int retStatus = ISD200_GOOD; 761 int result; 762 763 US_DEBUGP("Entering isd200_read_config\n"); 764 765 /* read the configuration information from ISD200. Use this to */ 766 /* determine what the special ATA CDB bytes are. */ 767 768 result = usb_stor_ctrl_transfer( 769 us, 770 us->recv_ctrl_pipe, 771 0x02, 772 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 773 0x0000, 774 0x0002, 775 (void *) &info->ConfigData, 776 sizeof(info->ConfigData)); 777 778 779 if (result >= 0) { 780 US_DEBUGP(" Retrieved the following ISD200 Config Data:\n"); 781 #ifdef CONFIG_USB_STORAGE_DEBUG 782 isd200_log_config(info); 783 #endif 784 } else { 785 US_DEBUGP(" Request to get ISD200 Config Data failed!\n"); 786 retStatus = ISD200_ERROR; 787 } 788 789 US_DEBUGP("Leaving isd200_read_config %08X\n", retStatus); 790 return retStatus; 791 } 792 793 794 /************************************************************************** 795 * isd200_atapi_soft_reset 796 * 797 * Perform an Atapi Soft Reset on the device 798 * 799 * RETURNS: 800 * NT status code 801 */ 802 static int isd200_atapi_soft_reset( struct us_data *us ) 803 { 804 int retStatus = ISD200_GOOD; 805 int transferStatus; 806 807 US_DEBUGP("Entering isd200_atapi_soft_reset\n"); 808 809 transferStatus = isd200_action( us, ACTION_SOFT_RESET, NULL, 0 ); 810 if (transferStatus != ISD200_TRANSPORT_GOOD) { 811 US_DEBUGP(" Error issuing Atapi Soft Reset\n"); 812 retStatus = ISD200_ERROR; 813 } 814 815 US_DEBUGP("Leaving isd200_atapi_soft_reset %08X\n", retStatus); 816 return retStatus; 817 } 818 819 820 /************************************************************************** 821 * isd200_srst 822 * 823 * Perform an SRST on the device 824 * 825 * RETURNS: 826 * ISD status code 827 */ 828 static int isd200_srst( struct us_data *us ) 829 { 830 int retStatus = ISD200_GOOD; 831 int transferStatus; 832 833 US_DEBUGP("Entering isd200_SRST\n"); 834 835 transferStatus = isd200_action( us, ACTION_RESET, NULL, 0 ); 836 837 /* check to see if this request failed */ 838 if (transferStatus != ISD200_TRANSPORT_GOOD) { 839 US_DEBUGP(" Error issuing SRST\n"); 840 retStatus = ISD200_ERROR; 841 } else { 842 /* delay 10ms to give the drive a chance to see it */ 843 msleep(10); 844 845 transferStatus = isd200_action( us, ACTION_REENABLE, NULL, 0 ); 846 if (transferStatus != ISD200_TRANSPORT_GOOD) { 847 US_DEBUGP(" Error taking drive out of reset\n"); 848 retStatus = ISD200_ERROR; 849 } else { 850 /* delay 50ms to give the drive a chance to recover after SRST */ 851 msleep(50); 852 } 853 } 854 855 US_DEBUGP("Leaving isd200_srst %08X\n", retStatus); 856 return retStatus; 857 } 858 859 860 /************************************************************************** 861 * isd200_try_enum 862 * 863 * Helper function for isd200_manual_enum(). Does ENUM and READ_STATUS 864 * and tries to analyze the status registers 865 * 866 * RETURNS: 867 * ISD status code 868 */ 869 static int isd200_try_enum(struct us_data *us, unsigned char master_slave, 870 int detect ) 871 { 872 int status = ISD200_GOOD; 873 unsigned long endTime; 874 struct isd200_info *info = (struct isd200_info *)us->extra; 875 unsigned char *regs = info->RegsBuf; 876 int recheckAsMaster = 0; 877 878 if ( detect ) 879 endTime = jiffies + ISD200_ENUM_DETECT_TIMEOUT * HZ; 880 else 881 endTime = jiffies + ISD200_ENUM_BSY_TIMEOUT * HZ; 882 883 /* loop until we detect !BSY or timeout */ 884 while(1) { 885 #ifdef CONFIG_USB_STORAGE_DEBUG 886 char* mstr = master_slave == ATA_ADDRESS_DEVHEAD_STD ? 887 "Master" : "Slave"; 888 #endif 889 890 status = isd200_action( us, ACTION_ENUM, NULL, master_slave ); 891 if ( status != ISD200_GOOD ) 892 break; 893 894 status = isd200_action( us, ACTION_READ_STATUS, 895 regs, 8 ); 896 if ( status != ISD200_GOOD ) 897 break; 898 899 if (!detect) { 900 if (regs[ATA_REG_STATUS_OFFSET] & BUSY_STAT) { 901 US_DEBUGP(" %s status is still BSY, try again...\n",mstr); 902 } else { 903 US_DEBUGP(" %s status !BSY, continue with next operation\n",mstr); 904 break; 905 } 906 } 907 /* check for BUSY_STAT and */ 908 /* WRERR_STAT (workaround ATA Zip drive) and */ 909 /* ERR_STAT (workaround for Archos CD-ROM) */ 910 else if (regs[ATA_REG_STATUS_OFFSET] & 911 (BUSY_STAT | WRERR_STAT | ERR_STAT )) { 912 US_DEBUGP(" Status indicates it is not ready, try again...\n"); 913 } 914 /* check for DRDY, ATA devices set DRDY after SRST */ 915 else if (regs[ATA_REG_STATUS_OFFSET] & READY_STAT) { 916 US_DEBUGP(" Identified ATA device\n"); 917 info->DeviceFlags |= DF_ATA_DEVICE; 918 info->DeviceHead = master_slave; 919 break; 920 } 921 /* check Cylinder High/Low to 922 determine if it is an ATAPI device 923 */ 924 else if (regs[ATA_REG_HCYL_OFFSET] == 0xEB && 925 regs[ATA_REG_LCYL_OFFSET] == 0x14) { 926 /* It seems that the RICOH 927 MP6200A CD/RW drive will 928 report itself okay as a 929 slave when it is really a 930 master. So this check again 931 as a master device just to 932 make sure it doesn't report 933 itself okay as a master also 934 */ 935 if ((master_slave & ATA_ADDRESS_DEVHEAD_SLAVE) && 936 !recheckAsMaster) { 937 US_DEBUGP(" Identified ATAPI device as slave. Rechecking again as master\n"); 938 recheckAsMaster = 1; 939 master_slave = ATA_ADDRESS_DEVHEAD_STD; 940 } else { 941 US_DEBUGP(" Identified ATAPI device\n"); 942 info->DeviceHead = master_slave; 943 944 status = isd200_atapi_soft_reset(us); 945 break; 946 } 947 } else { 948 US_DEBUGP(" Not ATA, not ATAPI. Weird.\n"); 949 break; 950 } 951 952 /* check for timeout on this request */ 953 if (time_after_eq(jiffies, endTime)) { 954 if (!detect) 955 US_DEBUGP(" BSY check timeout, just continue with next operation...\n"); 956 else 957 US_DEBUGP(" Device detect timeout!\n"); 958 break; 959 } 960 } 961 962 return status; 963 } 964 965 /************************************************************************** 966 * isd200_manual_enum 967 * 968 * Determines if the drive attached is an ATA or ATAPI and if it is a 969 * master or slave. 970 * 971 * RETURNS: 972 * ISD status code 973 */ 974 static int isd200_manual_enum(struct us_data *us) 975 { 976 struct isd200_info *info = (struct isd200_info *)us->extra; 977 int retStatus = ISD200_GOOD; 978 979 US_DEBUGP("Entering isd200_manual_enum\n"); 980 981 retStatus = isd200_read_config(us); 982 if (retStatus == ISD200_GOOD) { 983 int isslave; 984 /* master or slave? */ 985 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, 0); 986 if (retStatus == ISD200_GOOD) 987 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_SLAVE, 0); 988 989 if (retStatus == ISD200_GOOD) { 990 retStatus = isd200_srst(us); 991 if (retStatus == ISD200_GOOD) 992 /* ata or atapi? */ 993 retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, 1); 994 } 995 996 isslave = (info->DeviceHead & ATA_ADDRESS_DEVHEAD_SLAVE) ? 1 : 0; 997 if (!(info->ConfigData.ATAConfig & ATACFG_MASTER)) { 998 US_DEBUGP(" Setting Master/Slave selection to %d\n", isslave); 999 info->ConfigData.ATAConfig &= 0x3f; 1000 info->ConfigData.ATAConfig |= (isslave<<6); 1001 retStatus = isd200_write_config(us); 1002 } 1003 } 1004 1005 US_DEBUGP("Leaving isd200_manual_enum %08X\n", retStatus); 1006 return(retStatus); 1007 } 1008 1009 static void isd200_fix_driveid (struct hd_driveid *id) 1010 { 1011 #ifndef __LITTLE_ENDIAN 1012 # ifdef __BIG_ENDIAN 1013 int i; 1014 u16 *stringcast; 1015 1016 id->config = __le16_to_cpu(id->config); 1017 id->cyls = __le16_to_cpu(id->cyls); 1018 id->reserved2 = __le16_to_cpu(id->reserved2); 1019 id->heads = __le16_to_cpu(id->heads); 1020 id->track_bytes = __le16_to_cpu(id->track_bytes); 1021 id->sector_bytes = __le16_to_cpu(id->sector_bytes); 1022 id->sectors = __le16_to_cpu(id->sectors); 1023 id->vendor0 = __le16_to_cpu(id->vendor0); 1024 id->vendor1 = __le16_to_cpu(id->vendor1); 1025 id->vendor2 = __le16_to_cpu(id->vendor2); 1026 stringcast = (u16 *)&id->serial_no[0]; 1027 for (i = 0; i < (20/2); i++) 1028 stringcast[i] = __le16_to_cpu(stringcast[i]); 1029 id->buf_type = __le16_to_cpu(id->buf_type); 1030 id->buf_size = __le16_to_cpu(id->buf_size); 1031 id->ecc_bytes = __le16_to_cpu(id->ecc_bytes); 1032 stringcast = (u16 *)&id->fw_rev[0]; 1033 for (i = 0; i < (8/2); i++) 1034 stringcast[i] = __le16_to_cpu(stringcast[i]); 1035 stringcast = (u16 *)&id->model[0]; 1036 for (i = 0; i < (40/2); i++) 1037 stringcast[i] = __le16_to_cpu(stringcast[i]); 1038 id->dword_io = __le16_to_cpu(id->dword_io); 1039 id->reserved50 = __le16_to_cpu(id->reserved50); 1040 id->field_valid = __le16_to_cpu(id->field_valid); 1041 id->cur_cyls = __le16_to_cpu(id->cur_cyls); 1042 id->cur_heads = __le16_to_cpu(id->cur_heads); 1043 id->cur_sectors = __le16_to_cpu(id->cur_sectors); 1044 id->cur_capacity0 = __le16_to_cpu(id->cur_capacity0); 1045 id->cur_capacity1 = __le16_to_cpu(id->cur_capacity1); 1046 id->lba_capacity = __le32_to_cpu(id->lba_capacity); 1047 id->dma_1word = __le16_to_cpu(id->dma_1word); 1048 id->dma_mword = __le16_to_cpu(id->dma_mword); 1049 id->eide_pio_modes = __le16_to_cpu(id->eide_pio_modes); 1050 id->eide_dma_min = __le16_to_cpu(id->eide_dma_min); 1051 id->eide_dma_time = __le16_to_cpu(id->eide_dma_time); 1052 id->eide_pio = __le16_to_cpu(id->eide_pio); 1053 id->eide_pio_iordy = __le16_to_cpu(id->eide_pio_iordy); 1054 for (i = 0; i < 2; ++i) 1055 id->words69_70[i] = __le16_to_cpu(id->words69_70[i]); 1056 for (i = 0; i < 4; ++i) 1057 id->words71_74[i] = __le16_to_cpu(id->words71_74[i]); 1058 id->queue_depth = __le16_to_cpu(id->queue_depth); 1059 for (i = 0; i < 4; ++i) 1060 id->words76_79[i] = __le16_to_cpu(id->words76_79[i]); 1061 id->major_rev_num = __le16_to_cpu(id->major_rev_num); 1062 id->minor_rev_num = __le16_to_cpu(id->minor_rev_num); 1063 id->command_set_1 = __le16_to_cpu(id->command_set_1); 1064 id->command_set_2 = __le16_to_cpu(id->command_set_2); 1065 id->cfsse = __le16_to_cpu(id->cfsse); 1066 id->cfs_enable_1 = __le16_to_cpu(id->cfs_enable_1); 1067 id->cfs_enable_2 = __le16_to_cpu(id->cfs_enable_2); 1068 id->csf_default = __le16_to_cpu(id->csf_default); 1069 id->dma_ultra = __le16_to_cpu(id->dma_ultra); 1070 id->trseuc = __le16_to_cpu(id->trseuc); 1071 id->trsEuc = __le16_to_cpu(id->trsEuc); 1072 id->CurAPMvalues = __le16_to_cpu(id->CurAPMvalues); 1073 id->mprc = __le16_to_cpu(id->mprc); 1074 id->hw_config = __le16_to_cpu(id->hw_config); 1075 id->acoustic = __le16_to_cpu(id->acoustic); 1076 id->msrqs = __le16_to_cpu(id->msrqs); 1077 id->sxfert = __le16_to_cpu(id->sxfert); 1078 id->sal = __le16_to_cpu(id->sal); 1079 id->spg = __le32_to_cpu(id->spg); 1080 id->lba_capacity_2 = __le64_to_cpu(id->lba_capacity_2); 1081 for (i = 0; i < 22; i++) 1082 id->words104_125[i] = __le16_to_cpu(id->words104_125[i]); 1083 id->last_lun = __le16_to_cpu(id->last_lun); 1084 id->word127 = __le16_to_cpu(id->word127); 1085 id->dlf = __le16_to_cpu(id->dlf); 1086 id->csfo = __le16_to_cpu(id->csfo); 1087 for (i = 0; i < 26; i++) 1088 id->words130_155[i] = __le16_to_cpu(id->words130_155[i]); 1089 id->word156 = __le16_to_cpu(id->word156); 1090 for (i = 0; i < 3; i++) 1091 id->words157_159[i] = __le16_to_cpu(id->words157_159[i]); 1092 id->cfa_power = __le16_to_cpu(id->cfa_power); 1093 for (i = 0; i < 14; i++) 1094 id->words161_175[i] = __le16_to_cpu(id->words161_175[i]); 1095 for (i = 0; i < 31; i++) 1096 id->words176_205[i] = __le16_to_cpu(id->words176_205[i]); 1097 for (i = 0; i < 48; i++) 1098 id->words206_254[i] = __le16_to_cpu(id->words206_254[i]); 1099 id->integrity_word = __le16_to_cpu(id->integrity_word); 1100 # else 1101 # error "Please fix <asm/byteorder.h>" 1102 # endif 1103 #endif 1104 } 1105 1106 1107 /************************************************************************** 1108 * isd200_get_inquiry_data 1109 * 1110 * Get inquiry data 1111 * 1112 * RETURNS: 1113 * ISD status code 1114 */ 1115 static int isd200_get_inquiry_data( struct us_data *us ) 1116 { 1117 struct isd200_info *info = (struct isd200_info *)us->extra; 1118 int retStatus = ISD200_GOOD; 1119 struct hd_driveid *id = info->id; 1120 1121 US_DEBUGP("Entering isd200_get_inquiry_data\n"); 1122 1123 /* set default to Master */ 1124 info->DeviceHead = ATA_ADDRESS_DEVHEAD_STD; 1125 1126 /* attempt to manually enumerate this device */ 1127 retStatus = isd200_manual_enum(us); 1128 if (retStatus == ISD200_GOOD) { 1129 int transferStatus; 1130 1131 /* check for an ATA device */ 1132 if (info->DeviceFlags & DF_ATA_DEVICE) { 1133 /* this must be an ATA device */ 1134 /* perform an ATA Command Identify */ 1135 transferStatus = isd200_action( us, ACTION_IDENTIFY, 1136 id, 1137 sizeof(struct hd_driveid) ); 1138 if (transferStatus != ISD200_TRANSPORT_GOOD) { 1139 /* Error issuing ATA Command Identify */ 1140 US_DEBUGP(" Error issuing ATA Command Identify\n"); 1141 retStatus = ISD200_ERROR; 1142 } else { 1143 /* ATA Command Identify successful */ 1144 int i; 1145 __be16 *src; 1146 __u16 *dest; 1147 isd200_fix_driveid(id); 1148 1149 US_DEBUGP(" Identify Data Structure:\n"); 1150 US_DEBUGP(" config = 0x%x\n", id->config); 1151 US_DEBUGP(" cyls = 0x%x\n", id->cyls); 1152 US_DEBUGP(" heads = 0x%x\n", id->heads); 1153 US_DEBUGP(" track_bytes = 0x%x\n", id->track_bytes); 1154 US_DEBUGP(" sector_bytes = 0x%x\n", id->sector_bytes); 1155 US_DEBUGP(" sectors = 0x%x\n", id->sectors); 1156 US_DEBUGP(" serial_no[0] = 0x%x\n", id->serial_no[0]); 1157 US_DEBUGP(" buf_type = 0x%x\n", id->buf_type); 1158 US_DEBUGP(" buf_size = 0x%x\n", id->buf_size); 1159 US_DEBUGP(" ecc_bytes = 0x%x\n", id->ecc_bytes); 1160 US_DEBUGP(" fw_rev[0] = 0x%x\n", id->fw_rev[0]); 1161 US_DEBUGP(" model[0] = 0x%x\n", id->model[0]); 1162 US_DEBUGP(" max_multsect = 0x%x\n", id->max_multsect); 1163 US_DEBUGP(" dword_io = 0x%x\n", id->dword_io); 1164 US_DEBUGP(" capability = 0x%x\n", id->capability); 1165 US_DEBUGP(" tPIO = 0x%x\n", id->tPIO); 1166 US_DEBUGP(" tDMA = 0x%x\n", id->tDMA); 1167 US_DEBUGP(" field_valid = 0x%x\n", id->field_valid); 1168 US_DEBUGP(" cur_cyls = 0x%x\n", id->cur_cyls); 1169 US_DEBUGP(" cur_heads = 0x%x\n", id->cur_heads); 1170 US_DEBUGP(" cur_sectors = 0x%x\n", id->cur_sectors); 1171 US_DEBUGP(" cur_capacity = 0x%x\n", (id->cur_capacity1 << 16) + id->cur_capacity0 ); 1172 US_DEBUGP(" multsect = 0x%x\n", id->multsect); 1173 US_DEBUGP(" lba_capacity = 0x%x\n", id->lba_capacity); 1174 US_DEBUGP(" command_set_1 = 0x%x\n", id->command_set_1); 1175 US_DEBUGP(" command_set_2 = 0x%x\n", id->command_set_2); 1176 1177 memset(&info->InquiryData, 0, sizeof(info->InquiryData)); 1178 1179 /* Standard IDE interface only supports disks */ 1180 info->InquiryData.DeviceType = DIRECT_ACCESS_DEVICE; 1181 1182 /* The length must be at least 36 (5 + 31) */ 1183 info->InquiryData.AdditionalLength = 0x1F; 1184 1185 if (id->command_set_1 & COMMANDSET_MEDIA_STATUS) { 1186 /* set the removable bit */ 1187 info->InquiryData.DeviceTypeModifier = DEVICE_REMOVABLE; 1188 info->DeviceFlags |= DF_REMOVABLE_MEDIA; 1189 } 1190 1191 /* Fill in vendor identification fields */ 1192 src = (__be16*)id->model; 1193 dest = (__u16*)info->InquiryData.VendorId; 1194 for (i=0;i<4;i++) 1195 dest[i] = be16_to_cpu(src[i]); 1196 1197 src = (__be16*)(id->model+8); 1198 dest = (__u16*)info->InquiryData.ProductId; 1199 for (i=0;i<8;i++) 1200 dest[i] = be16_to_cpu(src[i]); 1201 1202 src = (__be16*)id->fw_rev; 1203 dest = (__u16*)info->InquiryData.ProductRevisionLevel; 1204 for (i=0;i<2;i++) 1205 dest[i] = be16_to_cpu(src[i]); 1206 1207 /* determine if it supports Media Status Notification */ 1208 if (id->command_set_2 & COMMANDSET_MEDIA_STATUS) { 1209 US_DEBUGP(" Device supports Media Status Notification\n"); 1210 1211 /* Indicate that it is enabled, even though it is not 1212 * This allows the lock/unlock of the media to work 1213 * correctly. 1214 */ 1215 info->DeviceFlags |= DF_MEDIA_STATUS_ENABLED; 1216 } 1217 else 1218 info->DeviceFlags &= ~DF_MEDIA_STATUS_ENABLED; 1219 1220 } 1221 } else { 1222 /* 1223 * this must be an ATAPI device 1224 * use an ATAPI protocol (Transparent SCSI) 1225 */ 1226 us->protocol_name = "Transparent SCSI"; 1227 us->proto_handler = usb_stor_transparent_scsi_command; 1228 1229 US_DEBUGP("Protocol changed to: %s\n", us->protocol_name); 1230 1231 /* Free driver structure */ 1232 us->extra_destructor(info); 1233 kfree(info); 1234 us->extra = NULL; 1235 us->extra_destructor = NULL; 1236 } 1237 } 1238 1239 US_DEBUGP("Leaving isd200_get_inquiry_data %08X\n", retStatus); 1240 1241 return(retStatus); 1242 } 1243 1244 /************************************************************************** 1245 * isd200_scsi_to_ata 1246 * 1247 * Translate SCSI commands to ATA commands. 1248 * 1249 * RETURNS: 1250 * 1 if the command needs to be sent to the transport layer 1251 * 0 otherwise 1252 */ 1253 static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us, 1254 union ata_cdb * ataCdb) 1255 { 1256 struct isd200_info *info = (struct isd200_info *)us->extra; 1257 struct hd_driveid *id = info->id; 1258 int sendToTransport = 1; 1259 unsigned char sectnum, head; 1260 unsigned short cylinder; 1261 unsigned long lba; 1262 unsigned long blockCount; 1263 unsigned char senseData[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 1264 1265 memset(ataCdb, 0, sizeof(union ata_cdb)); 1266 1267 /* SCSI Command */ 1268 switch (srb->cmnd[0]) { 1269 case INQUIRY: 1270 US_DEBUGP(" ATA OUT - INQUIRY\n"); 1271 1272 /* copy InquiryData */ 1273 usb_stor_set_xfer_buf((unsigned char *) &info->InquiryData, 1274 sizeof(info->InquiryData), srb); 1275 srb->result = SAM_STAT_GOOD; 1276 sendToTransport = 0; 1277 break; 1278 1279 case MODE_SENSE: 1280 US_DEBUGP(" ATA OUT - SCSIOP_MODE_SENSE\n"); 1281 1282 /* Initialize the return buffer */ 1283 usb_stor_set_xfer_buf(senseData, sizeof(senseData), srb); 1284 1285 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED) 1286 { 1287 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1288 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1289 ataCdb->generic.TransferBlockSize = 1; 1290 ataCdb->generic.RegisterSelect = REG_COMMAND; 1291 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1292 isd200_srb_set_bufflen(srb, 0); 1293 } else { 1294 US_DEBUGP(" Media Status not supported, just report okay\n"); 1295 srb->result = SAM_STAT_GOOD; 1296 sendToTransport = 0; 1297 } 1298 break; 1299 1300 case TEST_UNIT_READY: 1301 US_DEBUGP(" ATA OUT - SCSIOP_TEST_UNIT_READY\n"); 1302 1303 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED) 1304 { 1305 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1306 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1307 ataCdb->generic.TransferBlockSize = 1; 1308 ataCdb->generic.RegisterSelect = REG_COMMAND; 1309 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1310 isd200_srb_set_bufflen(srb, 0); 1311 } else { 1312 US_DEBUGP(" Media Status not supported, just report okay\n"); 1313 srb->result = SAM_STAT_GOOD; 1314 sendToTransport = 0; 1315 } 1316 break; 1317 1318 case READ_CAPACITY: 1319 { 1320 unsigned long capacity; 1321 struct read_capacity_data readCapacityData; 1322 1323 US_DEBUGP(" ATA OUT - SCSIOP_READ_CAPACITY\n"); 1324 1325 if (id->capability & CAPABILITY_LBA ) { 1326 capacity = id->lba_capacity - 1; 1327 } else { 1328 capacity = (id->heads * 1329 id->cyls * 1330 id->sectors) - 1; 1331 } 1332 readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity); 1333 readCapacityData.BytesPerBlock = cpu_to_be32(0x200); 1334 1335 usb_stor_set_xfer_buf((unsigned char *) &readCapacityData, 1336 sizeof(readCapacityData), srb); 1337 srb->result = SAM_STAT_GOOD; 1338 sendToTransport = 0; 1339 } 1340 break; 1341 1342 case READ_10: 1343 US_DEBUGP(" ATA OUT - SCSIOP_READ\n"); 1344 1345 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); 1346 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; 1347 1348 if (id->capability & CAPABILITY_LBA) { 1349 sectnum = (unsigned char)(lba); 1350 cylinder = (unsigned short)(lba>>8); 1351 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); 1352 } else { 1353 sectnum = (unsigned char)((lba % id->sectors) + 1); 1354 cylinder = (unsigned short)(lba / (id->sectors * 1355 id->heads)); 1356 head = (unsigned char)((lba / id->sectors) % 1357 id->heads); 1358 } 1359 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1360 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1361 ataCdb->generic.TransferBlockSize = 1; 1362 ataCdb->generic.RegisterSelect = 1363 REG_SECTOR_COUNT | REG_SECTOR_NUMBER | 1364 REG_CYLINDER_LOW | REG_CYLINDER_HIGH | 1365 REG_DEVICE_HEAD | REG_COMMAND; 1366 ataCdb->write.SectorCountByte = (unsigned char)blockCount; 1367 ataCdb->write.SectorNumberByte = sectnum; 1368 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); 1369 ataCdb->write.CylinderLowByte = (unsigned char)cylinder; 1370 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); 1371 ataCdb->write.CommandByte = WIN_READ; 1372 break; 1373 1374 case WRITE_10: 1375 US_DEBUGP(" ATA OUT - SCSIOP_WRITE\n"); 1376 1377 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); 1378 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; 1379 1380 if (id->capability & CAPABILITY_LBA) { 1381 sectnum = (unsigned char)(lba); 1382 cylinder = (unsigned short)(lba>>8); 1383 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); 1384 } else { 1385 sectnum = (unsigned char)((lba % id->sectors) + 1); 1386 cylinder = (unsigned short)(lba / (id->sectors * id->heads)); 1387 head = (unsigned char)((lba / id->sectors) % id->heads); 1388 } 1389 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1390 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1391 ataCdb->generic.TransferBlockSize = 1; 1392 ataCdb->generic.RegisterSelect = 1393 REG_SECTOR_COUNT | REG_SECTOR_NUMBER | 1394 REG_CYLINDER_LOW | REG_CYLINDER_HIGH | 1395 REG_DEVICE_HEAD | REG_COMMAND; 1396 ataCdb->write.SectorCountByte = (unsigned char)blockCount; 1397 ataCdb->write.SectorNumberByte = sectnum; 1398 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); 1399 ataCdb->write.CylinderLowByte = (unsigned char)cylinder; 1400 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); 1401 ataCdb->write.CommandByte = WIN_WRITE; 1402 break; 1403 1404 case ALLOW_MEDIUM_REMOVAL: 1405 US_DEBUGP(" ATA OUT - SCSIOP_MEDIUM_REMOVAL\n"); 1406 1407 if (info->DeviceFlags & DF_REMOVABLE_MEDIA) { 1408 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]); 1409 1410 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1411 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1412 ataCdb->generic.TransferBlockSize = 1; 1413 ataCdb->generic.RegisterSelect = REG_COMMAND; 1414 ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ? 1415 WIN_DOORLOCK : WIN_DOORUNLOCK; 1416 isd200_srb_set_bufflen(srb, 0); 1417 } else { 1418 US_DEBUGP(" Not removeable media, just report okay\n"); 1419 srb->result = SAM_STAT_GOOD; 1420 sendToTransport = 0; 1421 } 1422 break; 1423 1424 case START_STOP: 1425 US_DEBUGP(" ATA OUT - SCSIOP_START_STOP_UNIT\n"); 1426 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]); 1427 1428 if ((srb->cmnd[4] & 0x3) == 0x2) { 1429 US_DEBUGP(" Media Eject\n"); 1430 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1431 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1432 ataCdb->generic.TransferBlockSize = 0; 1433 ataCdb->generic.RegisterSelect = REG_COMMAND; 1434 ataCdb->write.CommandByte = ATA_COMMAND_MEDIA_EJECT; 1435 } else if ((srb->cmnd[4] & 0x3) == 0x1) { 1436 US_DEBUGP(" Get Media Status\n"); 1437 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1438 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1439 ataCdb->generic.TransferBlockSize = 1; 1440 ataCdb->generic.RegisterSelect = REG_COMMAND; 1441 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1442 isd200_srb_set_bufflen(srb, 0); 1443 } else { 1444 US_DEBUGP(" Nothing to do, just report okay\n"); 1445 srb->result = SAM_STAT_GOOD; 1446 sendToTransport = 0; 1447 } 1448 break; 1449 1450 default: 1451 US_DEBUGP("Unsupported SCSI command - 0x%X\n", srb->cmnd[0]); 1452 srb->result = DID_ERROR << 16; 1453 sendToTransport = 0; 1454 break; 1455 } 1456 1457 return(sendToTransport); 1458 } 1459 1460 1461 /************************************************************************** 1462 * isd200_free_info 1463 * 1464 * Frees the driver structure. 1465 */ 1466 static void isd200_free_info_ptrs(void *info_) 1467 { 1468 struct isd200_info *info = (struct isd200_info *) info_; 1469 1470 if (info) { 1471 kfree(info->id); 1472 kfree(info->RegsBuf); 1473 kfree(info->srb.sense_buffer); 1474 } 1475 } 1476 1477 /************************************************************************** 1478 * isd200_init_info 1479 * 1480 * Allocates (if necessary) and initializes the driver structure. 1481 * 1482 * RETURNS: 1483 * ISD status code 1484 */ 1485 static int isd200_init_info(struct us_data *us) 1486 { 1487 int retStatus = ISD200_GOOD; 1488 struct isd200_info *info; 1489 1490 info = (struct isd200_info *) 1491 kzalloc(sizeof(struct isd200_info), GFP_KERNEL); 1492 if (!info) 1493 retStatus = ISD200_ERROR; 1494 else { 1495 info->id = (struct hd_driveid *) 1496 kzalloc(sizeof(struct hd_driveid), GFP_KERNEL); 1497 info->RegsBuf = (unsigned char *) 1498 kmalloc(sizeof(info->ATARegs), GFP_KERNEL); 1499 info->srb.sense_buffer = 1500 kmalloc(SCSI_SENSE_BUFFERSIZE, GFP_KERNEL); 1501 if (!info->id || !info->RegsBuf || !info->srb.sense_buffer) { 1502 isd200_free_info_ptrs(info); 1503 kfree(info); 1504 retStatus = ISD200_ERROR; 1505 } 1506 } 1507 1508 if (retStatus == ISD200_GOOD) { 1509 us->extra = info; 1510 us->extra_destructor = isd200_free_info_ptrs; 1511 } else 1512 US_DEBUGP("ERROR - kmalloc failure\n"); 1513 1514 return retStatus; 1515 } 1516 1517 /************************************************************************** 1518 * Initialization for the ISD200 1519 */ 1520 1521 int isd200_Initialization(struct us_data *us) 1522 { 1523 US_DEBUGP("ISD200 Initialization...\n"); 1524 1525 /* Initialize ISD200 info struct */ 1526 1527 if (isd200_init_info(us) == ISD200_ERROR) { 1528 US_DEBUGP("ERROR Initializing ISD200 Info struct\n"); 1529 } else { 1530 /* Get device specific data */ 1531 1532 if (isd200_get_inquiry_data(us) != ISD200_GOOD) 1533 US_DEBUGP("ISD200 Initialization Failure\n"); 1534 else 1535 US_DEBUGP("ISD200 Initialization complete\n"); 1536 } 1537 1538 return 0; 1539 } 1540 1541 1542 /************************************************************************** 1543 * Protocol and Transport for the ISD200 ASIC 1544 * 1545 * This protocol and transport are for ATA devices connected to an ISD200 1546 * ASIC. An ATAPI device that is conected as a slave device will be 1547 * detected in the driver initialization function and the protocol will 1548 * be changed to an ATAPI protocol (Transparent SCSI). 1549 * 1550 */ 1551 1552 void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us) 1553 { 1554 int sendToTransport = 1, orig_bufflen; 1555 union ata_cdb ataCdb; 1556 1557 /* Make sure driver was initialized */ 1558 1559 if (us->extra == NULL) 1560 US_DEBUGP("ERROR Driver not initialized\n"); 1561 1562 scsi_set_resid(srb, 0); 1563 /* scsi_bufflen might change in protocol translation to ata */ 1564 orig_bufflen = scsi_bufflen(srb); 1565 sendToTransport = isd200_scsi_to_ata(srb, us, &ataCdb); 1566 1567 /* send the command to the transport layer */ 1568 if (sendToTransport) 1569 isd200_invoke_transport(us, srb, &ataCdb); 1570 1571 isd200_srb_set_bufflen(srb, orig_bufflen); 1572 } 1573