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