git.oblomov.eu Git - linux-2.6/blob - drivers/usb/storage/isd200.c

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