1 /* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC 2 * 3 * $Id: isd200.c,v 1.16 2002/04/22 03:39:43 mdharm Exp $ 4 * 5 * Current development and maintenance: 6 * (C) 2001-2002 Björn Stenberg (bjorn@haxx.se) 7 * 8 * Developed with the assistance of: 9 * (C) 2002 Alan Stern <stern@rowland.org> 10 * 11 * Initial work: 12 * (C) 2000 In-System Design, Inc. (support@in-system.com) 13 * 14 * The ISD200 ASIC does not natively support ATA devices. The chip 15 * does implement an interface, the ATA Command Block (ATACB) which provides 16 * a means of passing ATA commands and ATA register accesses to a device. 17 * 18 * This program is free software; you can redistribute it and/or modify it 19 * under the terms of the GNU General Public License as published by the 20 * Free Software Foundation; either version 2, or (at your option) any 21 * later version. 22 * 23 * This program is distributed in the hope that it will be useful, but 24 * WITHOUT ANY WARRANTY; without even the implied warranty of 25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 26 * General Public License for more details. 27 * 28 * You should have received a copy of the GNU General Public License along 29 * with this program; if not, write to the Free Software Foundation, Inc., 30 * 675 Mass Ave, Cambridge, MA 02139, USA. 31 * 32 * History: 33 * 34 * 2002-10-19: Removed the specialized transfer routines. 35 * (Alan Stern <stern@rowland.harvard.edu>) 36 * 2001-02-24: Removed lots of duplicate code and simplified the structure. 37 * (bjorn@haxx.se) 38 * 2002-01-16: Fixed endianness bug so it works on the ppc arch. 39 * (Luc Saillard <luc@saillard.org>) 40 * 2002-01-17: All bitfields removed. 41 * (bjorn@haxx.se) 42 */ 43 44 45 /* Include files */ 46 47 #include <linux/jiffies.h> 48 #include <linux/errno.h> 49 #include <linux/slab.h> 50 #include <linux/hdreg.h> 51 #include <linux/scatterlist.h> 52 53 #include <scsi/scsi.h> 54 #include <scsi/scsi_cmnd.h> 55 #include <scsi/scsi_device.h> 56 57 #include "usb.h" 58 #include "transport.h" 59 #include "protocol.h" 60 #include "debug.h" 61 #include "scsiglue.h" 62 #include "isd200.h" 63 64 65 /* Timeout defines (in Seconds) */ 66 67 #define ISD200_ENUM_BSY_TIMEOUT 35 68 #define ISD200_ENUM_DETECT_TIMEOUT 30 69 #define ISD200_DEFAULT_TIMEOUT 30 70 71 /* device flags */ 72 #define DF_ATA_DEVICE 0x0001 73 #define DF_MEDIA_STATUS_ENABLED 0x0002 74 #define DF_REMOVABLE_MEDIA 0x0004 75 76 /* capability bit definitions */ 77 #define CAPABILITY_DMA 0x01 78 #define CAPABILITY_LBA 0x02 79 80 /* command_setX bit definitions */ 81 #define COMMANDSET_REMOVABLE 0x02 82 #define COMMANDSET_MEDIA_STATUS 0x10 83 84 /* ATA Vendor Specific defines */ 85 #define ATA_ADDRESS_DEVHEAD_STD 0xa0 86 #define ATA_ADDRESS_DEVHEAD_LBA_MODE 0x40 87 #define ATA_ADDRESS_DEVHEAD_SLAVE 0x10 88 89 /* Action Select bits */ 90 #define ACTION_SELECT_0 0x01 91 #define ACTION_SELECT_1 0x02 92 #define ACTION_SELECT_2 0x04 93 #define ACTION_SELECT_3 0x08 94 #define ACTION_SELECT_4 0x10 95 #define ACTION_SELECT_5 0x20 96 #define ACTION_SELECT_6 0x40 97 #define ACTION_SELECT_7 0x80 98 99 /* Register Select bits */ 100 #define REG_ALTERNATE_STATUS 0x01 101 #define REG_DEVICE_CONTROL 0x01 102 #define REG_ERROR 0x02 103 #define REG_FEATURES 0x02 104 #define REG_SECTOR_COUNT 0x04 105 #define REG_SECTOR_NUMBER 0x08 106 #define REG_CYLINDER_LOW 0x10 107 #define REG_CYLINDER_HIGH 0x20 108 #define REG_DEVICE_HEAD 0x40 109 #define REG_STATUS 0x80 110 #define REG_COMMAND 0x80 111 112 /* ATA registers offset definitions */ 113 #define ATA_REG_ERROR_OFFSET 1 114 #define ATA_REG_LCYL_OFFSET 4 115 #define ATA_REG_HCYL_OFFSET 5 116 #define ATA_REG_STATUS_OFFSET 7 117 118 /* ATA error definitions not in <linux/hdreg.h> */ 119 #define ATA_ERROR_MEDIA_CHANGE 0x20 120 121 /* ATA command definitions not in <linux/hdreg.h> */ 122 #define ATA_COMMAND_GET_MEDIA_STATUS 0xDA 123 #define ATA_COMMAND_MEDIA_EJECT 0xED 124 125 /* ATA drive control definitions */ 126 #define ATA_DC_DISABLE_INTERRUPTS 0x02 127 #define ATA_DC_RESET_CONTROLLER 0x04 128 #define ATA_DC_REENABLE_CONTROLLER 0x00 129 130 /* 131 * General purpose return codes 132 */ 133 134 #define ISD200_ERROR -1 135 #define ISD200_GOOD 0 136 137 /* 138 * Transport return codes 139 */ 140 141 #define ISD200_TRANSPORT_GOOD 0 /* Transport good, command good */ 142 #define ISD200_TRANSPORT_FAILED 1 /* Transport good, command failed */ 143 #define ISD200_TRANSPORT_ERROR 2 /* Transport bad (i.e. device dead) */ 144 145 /* driver action codes */ 146 #define ACTION_READ_STATUS 0 147 #define ACTION_RESET 1 148 #define ACTION_REENABLE 2 149 #define ACTION_SOFT_RESET 3 150 #define ACTION_ENUM 4 151 #define ACTION_IDENTIFY 5 152 153 154 /* 155 * ata_cdb struct 156 */ 157 158 159 union ata_cdb { 160 struct { 161 unsigned char SignatureByte0; 162 unsigned char SignatureByte1; 163 unsigned char ActionSelect; 164 unsigned char RegisterSelect; 165 unsigned char TransferBlockSize; 166 unsigned char WriteData3F6; 167 unsigned char WriteData1F1; 168 unsigned char WriteData1F2; 169 unsigned char WriteData1F3; 170 unsigned char WriteData1F4; 171 unsigned char WriteData1F5; 172 unsigned char WriteData1F6; 173 unsigned char WriteData1F7; 174 unsigned char Reserved[3]; 175 } generic; 176 177 struct { 178 unsigned char SignatureByte0; 179 unsigned char SignatureByte1; 180 unsigned char ActionSelect; 181 unsigned char RegisterSelect; 182 unsigned char TransferBlockSize; 183 unsigned char AlternateStatusByte; 184 unsigned char ErrorByte; 185 unsigned char SectorCountByte; 186 unsigned char SectorNumberByte; 187 unsigned char CylinderLowByte; 188 unsigned char CylinderHighByte; 189 unsigned char DeviceHeadByte; 190 unsigned char StatusByte; 191 unsigned char Reserved[3]; 192 } read; 193 194 struct { 195 unsigned char SignatureByte0; 196 unsigned char SignatureByte1; 197 unsigned char ActionSelect; 198 unsigned char RegisterSelect; 199 unsigned char TransferBlockSize; 200 unsigned char DeviceControlByte; 201 unsigned char FeaturesByte; 202 unsigned char SectorCountByte; 203 unsigned char SectorNumberByte; 204 unsigned char CylinderLowByte; 205 unsigned char CylinderHighByte; 206 unsigned char DeviceHeadByte; 207 unsigned char CommandByte; 208 unsigned char Reserved[3]; 209 } write; 210 }; 211 212 213 /* 214 * Inquiry data structure. This is the data returned from the target 215 * after it receives an inquiry. 216 * 217 * This structure may be extended by the number of bytes specified 218 * in the field AdditionalLength. The defined size constant only 219 * includes fields through ProductRevisionLevel. 220 */ 221 222 /* 223 * DeviceType field 224 */ 225 #define DIRECT_ACCESS_DEVICE 0x00 /* disks */ 226 #define DEVICE_REMOVABLE 0x80 227 228 struct inquiry_data { 229 unsigned char DeviceType; 230 unsigned char DeviceTypeModifier; 231 unsigned char Versions; 232 unsigned char Format; 233 unsigned char AdditionalLength; 234 unsigned char Reserved[2]; 235 unsigned char Capability; 236 unsigned char VendorId[8]; 237 unsigned char ProductId[16]; 238 unsigned char ProductRevisionLevel[4]; 239 unsigned char VendorSpecific[20]; 240 unsigned char Reserved3[40]; 241 } __attribute__ ((packed)); 242 243 /* 244 * INQUIRY data buffer size 245 */ 246 247 #define INQUIRYDATABUFFERSIZE 36 248 249 250 /* 251 * ISD200 CONFIG data struct 252 */ 253 254 #define ATACFG_TIMING 0x0f 255 #define ATACFG_ATAPI_RESET 0x10 256 #define ATACFG_MASTER 0x20 257 #define ATACFG_BLOCKSIZE 0xa0 258 259 #define ATACFGE_LAST_LUN 0x07 260 #define ATACFGE_DESC_OVERRIDE 0x08 261 #define ATACFGE_STATE_SUSPEND 0x10 262 #define ATACFGE_SKIP_BOOT 0x20 263 #define ATACFGE_CONF_DESC2 0x40 264 #define ATACFGE_INIT_STATUS 0x80 265 266 #define CFG_CAPABILITY_SRST 0x01 267 268 struct isd200_config { 269 unsigned char EventNotification; 270 unsigned char ExternalClock; 271 unsigned char ATAInitTimeout; 272 unsigned char ATAConfig; 273 unsigned char ATAMajorCommand; 274 unsigned char ATAMinorCommand; 275 unsigned char ATAExtraConfig; 276 unsigned char Capability; 277 }__attribute__ ((packed)); 278 279 280 /* 281 * ISD200 driver information struct 282 */ 283 284 struct isd200_info { 285 struct inquiry_data InquiryData; 286 struct hd_driveid *id; 287 struct isd200_config ConfigData; 288 unsigned char *RegsBuf; 289 unsigned char ATARegs[8]; 290 unsigned char DeviceHead; 291 unsigned char DeviceFlags; 292 293 /* maximum number of LUNs supported */ 294 unsigned char MaxLUNs; 295 struct scsi_cmnd srb; 296 struct scatterlist sg; 297 }; 298 299 300 /* 301 * Read Capacity Data - returned in Big Endian format 302 */ 303 304 struct read_capacity_data { 305 __be32 LogicalBlockAddress; 306 __be32 BytesPerBlock; 307 }; 308 309 /* 310 * Read Block Limits Data - returned in Big Endian format 311 * This structure returns the maximum and minimum block 312 * size for a TAPE device. 313 */ 314 315 struct read_block_limits { 316 unsigned char Reserved; 317 unsigned char BlockMaximumSize[3]; 318 unsigned char BlockMinimumSize[2]; 319 }; 320 321 322 /* 323 * Sense Data Format 324 */ 325 326 #define SENSE_ERRCODE 0x7f 327 #define SENSE_ERRCODE_VALID 0x80 328 #define SENSE_FLAG_SENSE_KEY 0x0f 329 #define SENSE_FLAG_BAD_LENGTH 0x20 330 #define SENSE_FLAG_END_OF_MEDIA 0x40 331 #define SENSE_FLAG_FILE_MARK 0x80 332 struct sense_data { 333 unsigned char ErrorCode; 334 unsigned char SegmentNumber; 335 unsigned char Flags; 336 unsigned char Information[4]; 337 unsigned char AdditionalSenseLength; 338 unsigned char CommandSpecificInformation[4]; 339 unsigned char AdditionalSenseCode; 340 unsigned char AdditionalSenseCodeQualifier; 341 unsigned char FieldReplaceableUnitCode; 342 unsigned char SenseKeySpecific[3]; 343 } __attribute__ ((packed)); 344 345 /* 346 * Default request sense buffer size 347 */ 348 349 #define SENSE_BUFFER_SIZE 18 350 351 /*********************************************************************** 352 * Helper routines 353 ***********************************************************************/ 354 355 /************************************************************************** 356 * isd200_build_sense 357 * 358 * Builds an artificial sense buffer to report the results of a 359 * failed command. 360 * 361 * RETURNS: 362 * void 363 */ 364 static void isd200_build_sense(struct us_data *us, struct scsi_cmnd *srb) 365 { 366 struct isd200_info *info = (struct isd200_info *)us->extra; 367 struct sense_data *buf = (struct sense_data *) &srb->sense_buffer[0]; 368 unsigned char error = info->ATARegs[ATA_REG_ERROR_OFFSET]; 369 370 if(error & ATA_ERROR_MEDIA_CHANGE) { 371 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 372 buf->AdditionalSenseLength = 0xb; 373 buf->Flags = UNIT_ATTENTION; 374 buf->AdditionalSenseCode = 0; 375 buf->AdditionalSenseCodeQualifier = 0; 376 } else if(error & MCR_ERR) { 377 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 378 buf->AdditionalSenseLength = 0xb; 379 buf->Flags = UNIT_ATTENTION; 380 buf->AdditionalSenseCode = 0; 381 buf->AdditionalSenseCodeQualifier = 0; 382 } else if(error & TRK0_ERR) { 383 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 384 buf->AdditionalSenseLength = 0xb; 385 buf->Flags = NOT_READY; 386 buf->AdditionalSenseCode = 0; 387 buf->AdditionalSenseCodeQualifier = 0; 388 } else if(error & ECC_ERR) { 389 buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID; 390 buf->AdditionalSenseLength = 0xb; 391 buf->Flags = DATA_PROTECT; 392 buf->AdditionalSenseCode = 0; 393 buf->AdditionalSenseCodeQualifier = 0; 394 } else { 395 buf->ErrorCode = 0; 396 buf->AdditionalSenseLength = 0; 397 buf->Flags = 0; 398 buf->AdditionalSenseCode = 0; 399 buf->AdditionalSenseCodeQualifier = 0; 400 } 401 } 402 403 404 /*********************************************************************** 405 * Transport routines 406 ***********************************************************************/ 407 408 /************************************************************************** 409 * isd200_set_srb(), isd200_srb_set_bufflen() 410 * 411 * Two helpers to facilitate in initialization of scsi_cmnd structure 412 * Will need to change when struct scsi_cmnd changes 413 */ 414 static void isd200_set_srb(struct isd200_info *info, 415 enum dma_data_direction dir, void* buff, unsigned bufflen) 416 { 417 struct scsi_cmnd *srb = &info->srb; 418 419 if (buff) 420 sg_init_one(&info->sg, buff, bufflen); 421 422 srb->sc_data_direction = dir; 423 srb->sdb.table.sgl = buff ? &info->sg : NULL; 424 srb->sdb.length = bufflen; 425 srb->sdb.table.nents = buff ? 1 : 0; 426 } 427 428 static void isd200_srb_set_bufflen(struct scsi_cmnd *srb, unsigned bufflen) 429 { 430 srb->sdb.length = bufflen; 431 } 432 433 434 /************************************************************************** 435 * isd200_action 436 * 437 * Routine for sending commands to the isd200 438 * 439 * RETURNS: 440 * ISD status code 441 */ 442 static int isd200_action( struct us_data *us, int action, 443 void* pointer, int value ) 444 { 445 union ata_cdb ata; 446 struct scsi_device srb_dev; 447 struct isd200_info *info = (struct isd200_info *)us->extra; 448 struct scsi_cmnd *srb = &info->srb; 449 int status; 450 451 memset(&ata, 0, sizeof(ata)); 452 memset(&srb_dev, 0, sizeof(srb_dev)); 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->flags)) { 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->flags)) { 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->flags); 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 us->extra = NULL; 1234 us->extra_destructor = NULL; 1235 } 1236 } 1237 1238 US_DEBUGP("Leaving isd200_get_inquiry_data %08X\n", retStatus); 1239 1240 return(retStatus); 1241 } 1242 1243 /************************************************************************** 1244 * isd200_scsi_to_ata 1245 * 1246 * Translate SCSI commands to ATA commands. 1247 * 1248 * RETURNS: 1249 * 1 if the command needs to be sent to the transport layer 1250 * 0 otherwise 1251 */ 1252 static int isd200_scsi_to_ata(struct scsi_cmnd *srb, struct us_data *us, 1253 union ata_cdb * ataCdb) 1254 { 1255 struct isd200_info *info = (struct isd200_info *)us->extra; 1256 struct hd_driveid *id = info->id; 1257 int sendToTransport = 1; 1258 unsigned char sectnum, head; 1259 unsigned short cylinder; 1260 unsigned long lba; 1261 unsigned long blockCount; 1262 unsigned char senseData[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; 1263 1264 memset(ataCdb, 0, sizeof(union ata_cdb)); 1265 1266 /* SCSI Command */ 1267 switch (srb->cmnd[0]) { 1268 case INQUIRY: 1269 US_DEBUGP(" ATA OUT - INQUIRY\n"); 1270 1271 /* copy InquiryData */ 1272 usb_stor_set_xfer_buf((unsigned char *) &info->InquiryData, 1273 sizeof(info->InquiryData), srb); 1274 srb->result = SAM_STAT_GOOD; 1275 sendToTransport = 0; 1276 break; 1277 1278 case MODE_SENSE: 1279 US_DEBUGP(" ATA OUT - SCSIOP_MODE_SENSE\n"); 1280 1281 /* Initialize the return buffer */ 1282 usb_stor_set_xfer_buf(senseData, sizeof(senseData), srb); 1283 1284 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED) 1285 { 1286 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1287 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1288 ataCdb->generic.TransferBlockSize = 1; 1289 ataCdb->generic.RegisterSelect = REG_COMMAND; 1290 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1291 isd200_srb_set_bufflen(srb, 0); 1292 } else { 1293 US_DEBUGP(" Media Status not supported, just report okay\n"); 1294 srb->result = SAM_STAT_GOOD; 1295 sendToTransport = 0; 1296 } 1297 break; 1298 1299 case TEST_UNIT_READY: 1300 US_DEBUGP(" ATA OUT - SCSIOP_TEST_UNIT_READY\n"); 1301 1302 if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED) 1303 { 1304 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1305 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1306 ataCdb->generic.TransferBlockSize = 1; 1307 ataCdb->generic.RegisterSelect = REG_COMMAND; 1308 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1309 isd200_srb_set_bufflen(srb, 0); 1310 } else { 1311 US_DEBUGP(" Media Status not supported, just report okay\n"); 1312 srb->result = SAM_STAT_GOOD; 1313 sendToTransport = 0; 1314 } 1315 break; 1316 1317 case READ_CAPACITY: 1318 { 1319 unsigned long capacity; 1320 struct read_capacity_data readCapacityData; 1321 1322 US_DEBUGP(" ATA OUT - SCSIOP_READ_CAPACITY\n"); 1323 1324 if (id->capability & CAPABILITY_LBA ) { 1325 capacity = id->lba_capacity - 1; 1326 } else { 1327 capacity = (id->heads * 1328 id->cyls * 1329 id->sectors) - 1; 1330 } 1331 readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity); 1332 readCapacityData.BytesPerBlock = cpu_to_be32(0x200); 1333 1334 usb_stor_set_xfer_buf((unsigned char *) &readCapacityData, 1335 sizeof(readCapacityData), srb); 1336 srb->result = SAM_STAT_GOOD; 1337 sendToTransport = 0; 1338 } 1339 break; 1340 1341 case READ_10: 1342 US_DEBUGP(" ATA OUT - SCSIOP_READ\n"); 1343 1344 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); 1345 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; 1346 1347 if (id->capability & CAPABILITY_LBA) { 1348 sectnum = (unsigned char)(lba); 1349 cylinder = (unsigned short)(lba>>8); 1350 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); 1351 } else { 1352 sectnum = (unsigned char)((lba % id->sectors) + 1); 1353 cylinder = (unsigned short)(lba / (id->sectors * 1354 id->heads)); 1355 head = (unsigned char)((lba / id->sectors) % 1356 id->heads); 1357 } 1358 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1359 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1360 ataCdb->generic.TransferBlockSize = 1; 1361 ataCdb->generic.RegisterSelect = 1362 REG_SECTOR_COUNT | REG_SECTOR_NUMBER | 1363 REG_CYLINDER_LOW | REG_CYLINDER_HIGH | 1364 REG_DEVICE_HEAD | REG_COMMAND; 1365 ataCdb->write.SectorCountByte = (unsigned char)blockCount; 1366 ataCdb->write.SectorNumberByte = sectnum; 1367 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); 1368 ataCdb->write.CylinderLowByte = (unsigned char)cylinder; 1369 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); 1370 ataCdb->write.CommandByte = WIN_READ; 1371 break; 1372 1373 case WRITE_10: 1374 US_DEBUGP(" ATA OUT - SCSIOP_WRITE\n"); 1375 1376 lba = be32_to_cpu(*(__be32 *)&srb->cmnd[2]); 1377 blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8]; 1378 1379 if (id->capability & CAPABILITY_LBA) { 1380 sectnum = (unsigned char)(lba); 1381 cylinder = (unsigned short)(lba>>8); 1382 head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F); 1383 } else { 1384 sectnum = (unsigned char)((lba % id->sectors) + 1); 1385 cylinder = (unsigned short)(lba / (id->sectors * id->heads)); 1386 head = (unsigned char)((lba / id->sectors) % id->heads); 1387 } 1388 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1389 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1390 ataCdb->generic.TransferBlockSize = 1; 1391 ataCdb->generic.RegisterSelect = 1392 REG_SECTOR_COUNT | REG_SECTOR_NUMBER | 1393 REG_CYLINDER_LOW | REG_CYLINDER_HIGH | 1394 REG_DEVICE_HEAD | REG_COMMAND; 1395 ataCdb->write.SectorCountByte = (unsigned char)blockCount; 1396 ataCdb->write.SectorNumberByte = sectnum; 1397 ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8); 1398 ataCdb->write.CylinderLowByte = (unsigned char)cylinder; 1399 ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD); 1400 ataCdb->write.CommandByte = WIN_WRITE; 1401 break; 1402 1403 case ALLOW_MEDIUM_REMOVAL: 1404 US_DEBUGP(" ATA OUT - SCSIOP_MEDIUM_REMOVAL\n"); 1405 1406 if (info->DeviceFlags & DF_REMOVABLE_MEDIA) { 1407 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]); 1408 1409 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1410 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1411 ataCdb->generic.TransferBlockSize = 1; 1412 ataCdb->generic.RegisterSelect = REG_COMMAND; 1413 ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ? 1414 WIN_DOORLOCK : WIN_DOORUNLOCK; 1415 isd200_srb_set_bufflen(srb, 0); 1416 } else { 1417 US_DEBUGP(" Not removeable media, just report okay\n"); 1418 srb->result = SAM_STAT_GOOD; 1419 sendToTransport = 0; 1420 } 1421 break; 1422 1423 case START_STOP: 1424 US_DEBUGP(" ATA OUT - SCSIOP_START_STOP_UNIT\n"); 1425 US_DEBUGP(" srb->cmnd[4] = 0x%X\n", srb->cmnd[4]); 1426 1427 if ((srb->cmnd[4] & 0x3) == 0x2) { 1428 US_DEBUGP(" Media Eject\n"); 1429 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1430 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1431 ataCdb->generic.TransferBlockSize = 0; 1432 ataCdb->generic.RegisterSelect = REG_COMMAND; 1433 ataCdb->write.CommandByte = ATA_COMMAND_MEDIA_EJECT; 1434 } else if ((srb->cmnd[4] & 0x3) == 0x1) { 1435 US_DEBUGP(" Get Media Status\n"); 1436 ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand; 1437 ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand; 1438 ataCdb->generic.TransferBlockSize = 1; 1439 ataCdb->generic.RegisterSelect = REG_COMMAND; 1440 ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS; 1441 isd200_srb_set_bufflen(srb, 0); 1442 } else { 1443 US_DEBUGP(" Nothing to do, just report okay\n"); 1444 srb->result = SAM_STAT_GOOD; 1445 sendToTransport = 0; 1446 } 1447 break; 1448 1449 default: 1450 US_DEBUGP("Unsupported SCSI command - 0x%X\n", srb->cmnd[0]); 1451 srb->result = DID_ERROR << 16; 1452 sendToTransport = 0; 1453 break; 1454 } 1455 1456 return(sendToTransport); 1457 } 1458 1459 1460 /************************************************************************** 1461 * isd200_free_info 1462 * 1463 * Frees the driver structure. 1464 */ 1465 static void isd200_free_info_ptrs(void *info_) 1466 { 1467 struct isd200_info *info = (struct isd200_info *) info_; 1468 1469 if (info) { 1470 kfree(info->id); 1471 kfree(info->RegsBuf); 1472 } 1473 } 1474 1475 /************************************************************************** 1476 * isd200_init_info 1477 * 1478 * Allocates (if necessary) and initializes the driver structure. 1479 * 1480 * RETURNS: 1481 * ISD status code 1482 */ 1483 static int isd200_init_info(struct us_data *us) 1484 { 1485 int retStatus = ISD200_GOOD; 1486 struct isd200_info *info; 1487 1488 info = (struct isd200_info *) 1489 kzalloc(sizeof(struct isd200_info), GFP_KERNEL); 1490 if (!info) 1491 retStatus = ISD200_ERROR; 1492 else { 1493 info->id = (struct hd_driveid *) 1494 kzalloc(sizeof(struct hd_driveid), GFP_KERNEL); 1495 info->RegsBuf = (unsigned char *) 1496 kmalloc(sizeof(info->ATARegs), GFP_KERNEL); 1497 if (!info->id || !info->RegsBuf) { 1498 isd200_free_info_ptrs(info); 1499 kfree(info); 1500 retStatus = ISD200_ERROR; 1501 } 1502 } 1503 1504 if (retStatus == ISD200_GOOD) { 1505 us->extra = info; 1506 us->extra_destructor = isd200_free_info_ptrs; 1507 } else 1508 US_DEBUGP("ERROR - kmalloc failure\n"); 1509 1510 return retStatus; 1511 } 1512 1513 /************************************************************************** 1514 * Initialization for the ISD200 1515 */ 1516 1517 int isd200_Initialization(struct us_data *us) 1518 { 1519 US_DEBUGP("ISD200 Initialization...\n"); 1520 1521 /* Initialize ISD200 info struct */ 1522 1523 if (isd200_init_info(us) == ISD200_ERROR) { 1524 US_DEBUGP("ERROR Initializing ISD200 Info struct\n"); 1525 } else { 1526 /* Get device specific data */ 1527 1528 if (isd200_get_inquiry_data(us) != ISD200_GOOD) 1529 US_DEBUGP("ISD200 Initialization Failure\n"); 1530 else 1531 US_DEBUGP("ISD200 Initialization complete\n"); 1532 } 1533 1534 return 0; 1535 } 1536 1537 1538 /************************************************************************** 1539 * Protocol and Transport for the ISD200 ASIC 1540 * 1541 * This protocol and transport are for ATA devices connected to an ISD200 1542 * ASIC. An ATAPI device that is conected as a slave device will be 1543 * detected in the driver initialization function and the protocol will 1544 * be changed to an ATAPI protocol (Transparent SCSI). 1545 * 1546 */ 1547 1548 void isd200_ata_command(struct scsi_cmnd *srb, struct us_data *us) 1549 { 1550 int sendToTransport = 1, orig_bufflen; 1551 union ata_cdb ataCdb; 1552 1553 /* Make sure driver was initialized */ 1554 1555 if (us->extra == NULL) 1556 US_DEBUGP("ERROR Driver not initialized\n"); 1557 1558 scsi_set_resid(srb, 0); 1559 /* scsi_bufflen might change in protocol translation to ata */ 1560 orig_bufflen = scsi_bufflen(srb); 1561 sendToTransport = isd200_scsi_to_ata(srb, us, &ataCdb); 1562 1563 /* send the command to the transport layer */ 1564 if (sendToTransport) 1565 isd200_invoke_transport(us, srb, &ataCdb); 1566 1567 isd200_srb_set_bufflen(srb, orig_bufflen); 1568 } 1569