开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
isd200.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：55k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

isd200.c：源码内容
  1. /* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC
  2.  *
  3.  * $Id: isd200.c,v 1.14 2002/02/25 00:40:13 mdharm Exp $
  4.  *
  5.  * Current development and maintenance:
  6.  *   (C) 2001-2002 Bj鰎n Stenberg (bjorn@haxx.se)
  7.  *
  8.  * Developed with the assistance of:
  9.  *   (C) 2002 Alan Stern <stern@rowland.org>
  10.  *
  11.  * Initial work:
  12.  *   (C) 2000 In-System Design, Inc. (support@in-system.com)
  13.  *
  14.  * The ISD200 ASIC does not natively support ATA devices.  The chip
  15.  * does implement an interface, the ATA Command Block (ATACB) which provides
  16.  * a means of passing ATA commands and ATA register accesses to a device.
  17.  *
  18.  * This program is free software; you can redistribute it and/or modify it
  19.  * under the terms of the GNU General Public License as published by the
  20.  * Free Software Foundation; either version 2, or (at your option) any
  21.  * later version.
  22.  *
  23.  * This program is distributed in the hope that it will be useful, but
  24.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  25.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26.  * General Public License for more details.
  27.  *
  28.  * You should have received a copy of the GNU General Public License along
  29.  * with this program; if not, write to the Free Software Foundation, Inc.,
  30.  * 675 Mass Ave, Cambridge, MA 02139, USA.
  31.  *
  32.  * History:
  33.  *
  34.  *  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.  */
  43. /* Include files */
  45. #include "transport.h"
  46. #include "protocol.h"
  47. #include "usb.h"
  48. #include "debug.h"
  49. #include "scsiglue.h"
  50. #include "isd200.h"
  52. #include <linux/sched.h>
  53. #include <linux/errno.h>
  54. #include <linux/slab.h>
  55. #include <linux/hdreg.h>
  56. #include <linux/ide.h>
  58. /* Timeout defines (in Seconds) */
  60. #define ISD200_ENUM_BSY_TIMEOUT         35
  61. #define ISD200_ENUM_DETECT_TIMEOUT      30
  62. #define ISD200_DEFAULT_TIMEOUT          30
  64. /* device flags */
  65. #define DF_ATA_DEVICE               0x0001
  66. #define DF_MEDIA_STATUS_ENABLED     0x0002
  67. #define DF_REMOVABLE_MEDIA          0x0004
  69. /* capability bit definitions */
  70. #define CAPABILITY_DMA 0x01
  71. #define CAPABILITY_LBA 0x02
  73. /* command_setX bit definitions */
  74. #define COMMANDSET_REMOVABLE 0x02
  75. #define COMMANDSET_MEDIA_STATUS 0x10
  77. /* ATA Vendor Specific defines */
  78. #define ATA_ADDRESS_DEVHEAD_STD      0xa0
  79. #define ATA_ADDRESS_DEVHEAD_LBA_MODE 0x40    
  80. #define ATA_ADDRESS_DEVHEAD_SLAVE    0x10
  82. /* Action Select bits */
  83. #define ACTION_SELECT_0             0x01
  84. #define ACTION_SELECT_1             0x02
  85. #define ACTION_SELECT_2             0x04
  86. #define ACTION_SELECT_3             0x08
  87. #define ACTION_SELECT_4             0x10
  88. #define ACTION_SELECT_5             0x20
  89. #define ACTION_SELECT_6             0x40
  90. #define ACTION_SELECT_7             0x80
  92. /* Register Select bits */
  93. #define REG_ALTERNATE_STATUS 0x01
  94. #define REG_DEVICE_CONTROL   0x01
  95. #define REG_ERROR            0x02
  96. #define REG_FEATURES         0x02
  97. #define REG_SECTOR_COUNT     0x04
  98. #define REG_SECTOR_NUMBER    0x08
  99. #define REG_CYLINDER_LOW     0x10
  100. #define REG_CYLINDER_HIGH    0x20
  101. #define REG_DEVICE_HEAD      0x40
  102. #define REG_STATUS           0x80
  103. #define REG_COMMAND          0x80
  105. /* ATA error definitions not in <linux/hdreg.h> */
  106. #define ATA_ERROR_MEDIA_CHANGE       0x20
  108. /* ATA command definitions not in <linux/hdreg.h> */
  109. #define ATA_COMMAND_GET_MEDIA_STATUS        0xDA
  110. #define ATA_COMMAND_MEDIA_EJECT             0xED
  112. /* ATA drive control definitions */
  113. #define ATA_DC_DISABLE_INTERRUPTS    0x02
  114. #define ATA_DC_RESET_CONTROLLER      0x04
  115. #define ATA_DC_REENABLE_CONTROLLER   0x00
  117. /*
  118.  *  General purpose return codes
  119.  */ 
  121. #define ISD200_ERROR                -1
  122. #define ISD200_GOOD                 0
  124. /*
  125.  * Transport return codes
  126.  */
  128. #define ISD200_TRANSPORT_GOOD       0   /* Transport good, command good     */
  129. #define ISD200_TRANSPORT_FAILED     1   /* Transport good, command failed   */
  130. #define ISD200_TRANSPORT_ERROR      2   /* Transport bad (i.e. device dead) */
  131. #define ISD200_TRANSPORT_ABORTED    3   /* Transport aborted                */
  132. #define ISD200_TRANSPORT_SHORT      4   /* Transport short                  */
  134. /* driver action codes */
  135. #define ACTION_READ_STATUS 0
  136. #define ACTION_RESET 1
  137. #define ACTION_REENABLE 2
  138. #define ACTION_SOFT_RESET 3
  139. #define ACTION_ENUM 4
  140. #define ACTION_IDENTIFY 5
  143. /*
  144.  * ata_cdb struct
  145.  */
  148. union ata_cdb {
  149. struct {
  150. unsigned char SignatureByte0;
  151. unsigned char SignatureByte1;
  152. unsigned char ActionSelect;
  153. unsigned char RegisterSelect;
  154. unsigned char TransferBlockSize;
  155. unsigned char WriteData3F6;
  156. unsigned char WriteData1F1;
  157. unsigned char WriteData1F2;
  158. unsigned char WriteData1F3;
  159. unsigned char WriteData1F4;
  160. unsigned char WriteData1F5;
  161. unsigned char WriteData1F6;
  162. unsigned char WriteData1F7;
  163. unsigned char Reserved[3];
  164. } generic;
  165.         
  166. struct {
  167. unsigned char SignatureByte0;
  168. unsigned char SignatureByte1;
  169. unsigned char ActionSelect;
  170. unsigned char RegisterSelect;
  171. unsigned char TransferBlockSize;
  172. unsigned char AlternateStatusByte;
  173. unsigned char ErrorByte;
  174. unsigned char SectorCountByte;
  175. unsigned char SectorNumberByte;
  176. unsigned char CylinderLowByte;
  177. unsigned char CylinderHighByte;
  178. unsigned char DeviceHeadByte;
  179. unsigned char StatusByte;
  180. unsigned char Reserved[3];
  181. } read;
  183.         struct {
  184. unsigned char SignatureByte0;
  185. unsigned char SignatureByte1;
  186. unsigned char ActionSelect;
  187. unsigned char RegisterSelect;
  188. unsigned char TransferBlockSize;
  189. unsigned char DeviceControlByte;
  190. unsigned char FeaturesByte;
  191. unsigned char SectorCountByte;
  192. unsigned char SectorNumberByte;
  193. unsigned char CylinderLowByte;
  194. unsigned char CylinderHighByte;
  195. unsigned char DeviceHeadByte;
  196. unsigned char CommandByte;
  197. unsigned char Reserved[3];
  198. } write;
  199. };
  202. /*
  203.  * Inquiry data structure. This is the data returned from the target
  204.  * after it receives an inquiry.
  205.  *
  206.  * This structure may be extended by the number of bytes specified
  207.  * in the field AdditionalLength. The defined size constant only
  208.  * includes fields through ProductRevisionLevel.
  209.  */
  211. /*
  212.  * DeviceType field
  213.  */
  214. #define DIRECT_ACCESS_DEVICE            0x00    /* disks */
  215. #define DEVICE_REMOVABLE                0x80
  217. struct inquiry_data {
  218.     unsigned char DeviceType;
  219. unsigned char DeviceTypeModifier;
  220. unsigned char Versions;
  221. unsigned char Format; 
  222. unsigned char AdditionalLength;
  223. unsigned char Reserved[2];
  224. unsigned char Capability;
  225. unsigned char VendorId[8];
  226. unsigned char ProductId[16];
  227. unsigned char ProductRevisionLevel[4];
  228. unsigned char VendorSpecific[20];
  229. unsigned char Reserved3[40];
  230. } __attribute__ ((packed));
  232. /*
  233.  * INQUIRY data buffer size
  234.  */
  236. #define INQUIRYDATABUFFERSIZE 36
  239. /*
  240.  * ISD200 CONFIG data struct
  241.  */
  243. #define ATACFG_TIMING          0x0f
  244. #define ATACFG_ATAPI_RESET     0x10
  245. #define ATACFG_MASTER          0x20
  246. #define ATACFG_BLOCKSIZE       0xa0
  248. #define ATACFGE_LAST_LUN       0x07
  249. #define ATACFGE_DESC_OVERRIDE  0x08
  250. #define ATACFGE_STATE_SUSPEND  0x10
  251. #define ATACFGE_SKIP_BOOT      0x20
  252. #define ATACFGE_CONF_DESC2     0x40
  253. #define ATACFGE_INIT_STATUS    0x80
  255. #define CFG_CAPABILITY_SRST    0x01
  257. struct isd200_config {
  258.         unsigned char EventNotification;
  259.         unsigned char ExternalClock;
  260.         unsigned char ATAInitTimeout;
  261. unsigned char ATAConfig;
  262.         unsigned char ATAMajorCommand;
  263.         unsigned char ATAMinorCommand;
  264. unsigned char ATAExtraConfig;
  265. unsigned char Capability;
  266. }__attribute__ ((packed));
  269. /*
  270.  * ISD200 driver information struct
  271.  */
  273. struct isd200_info {
  274. struct inquiry_data InquiryData;
  275. struct hd_driveid drive;
  276. struct isd200_config ConfigData;
  277. unsigned char ATARegs[8];
  278. unsigned char DeviceHead;
  279. unsigned char DeviceFlags;
  281. /* maximum number of LUNs supported */
  282. unsigned char MaxLUNs;
  283. };
  286. /*
  287.  * Read Capacity Data - returned in Big Endian format
  288.  */
  290. struct read_capacity_data {
  291. unsigned long LogicalBlockAddress;
  292. unsigned long BytesPerBlock;
  293. };
  295. /*
  296.  * Read Block Limits Data - returned in Big Endian format
  297.  * This structure returns the maximum and minimum block
  298.  * size for a TAPE device.
  299.  */
  301. struct read_block_limits {
  302. unsigned char Reserved;
  303. unsigned char BlockMaximumSize[3];
  304. unsigned char BlockMinimumSize[2];
  305. };
  308. /*
  309.  * Sense Data Format
  310.  */
  312. #define SENSE_ERRCODE           0x7f
  313. #define SENSE_ERRCODE_VALID     0x80
  314. #define SENSE_FLAG_SENSE_KEY    0x0f
  315. #define SENSE_FLAG_BAD_LENGTH   0x20
  316. #define SENSE_FLAG_END_OF_MEDIA 0x40
  317. #define SENSE_FLAG_FILE_MARK    0x80
  318. struct sense_data {
  319. unsigned char ErrorCode;
  320. unsigned char SegmentNumber;
  321. unsigned char Flags;
  322.         unsigned char Information[4];
  323.         unsigned char AdditionalSenseLength;
  324.         unsigned char CommandSpecificInformation[4];
  325.         unsigned char AdditionalSenseCode;
  326.         unsigned char AdditionalSenseCodeQualifier;
  327.         unsigned char FieldReplaceableUnitCode;
  328.         unsigned char SenseKeySpecific[3];
  329. } __attribute__ ((packed));
  331. /*
  332.  * Default request sense buffer size
  333.  */
  335. #define SENSE_BUFFER_SIZE 18
  337. /***********************************************************************
  338.  * Helper routines
  339.  ***********************************************************************/
  341. /**************************************************************************
  342.  * isd200_build_sense
  343.  *                                                                         
  344.  *  Builds an artificial sense buffer to report the results of a 
  345.  *  failed command.
  346.  *                                                                       
  347.  * RETURNS:
  348.  *    void
  349.  */                                                                        
  350. void isd200_build_sense(struct us_data *us, Scsi_Cmnd *srb)
  351. {
  352.         struct isd200_info *info = (struct isd200_info *)us->extra;
  353.         struct sense_data *buf = (struct sense_data *) &srb->sense_buffer[0];
  354.         unsigned char error = info->ATARegs[IDE_ERROR_OFFSET];
  356. if(error & ATA_ERROR_MEDIA_CHANGE) {
  357. buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
  358. buf->AdditionalSenseLength = 0xb;
  359. buf->Flags = UNIT_ATTENTION;
  360. buf->AdditionalSenseCode = 0;
  361. buf->AdditionalSenseCodeQualifier = 0;
  362.         } else if(error & MCR_ERR) {
  363. buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
  364. buf->AdditionalSenseLength = 0xb;
  365. buf->Flags =  UNIT_ATTENTION;
  366. buf->AdditionalSenseCode = 0;
  367. buf->AdditionalSenseCodeQualifier = 0;
  368.         } else if(error & TRK0_ERR) {
  369. buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
  370. buf->AdditionalSenseLength = 0xb;
  371. buf->Flags =  NOT_READY;
  372. buf->AdditionalSenseCode = 0;
  373. buf->AdditionalSenseCodeQualifier = 0;
  374.         } else if(error & ECC_ERR) {
  375. buf->ErrorCode = 0x70 | SENSE_ERRCODE_VALID;
  376. buf->AdditionalSenseLength = 0xb;
  377. buf->Flags =  DATA_PROTECT;
  378. buf->AdditionalSenseCode = 0;
  379. buf->AdditionalSenseCodeQualifier = 0;
  380.         } else {
  381. buf->ErrorCode = 0;
  382. buf->AdditionalSenseLength = 0;
  383. buf->Flags =  0;
  384. buf->AdditionalSenseCode = 0;
  385. buf->AdditionalSenseCodeQualifier = 0;
  386.         }
  387. }
  389. /***********************************************************************
  390.  * Data transfer routines
  391.  ***********************************************************************/
  394. /**************************************************************************
  395.  * Transfer one SCSI scatter-gather buffer via bulk transfer
  396.  *
  397.  * Note that this function is necessary because we want the ability to
  398.  * use scatter-gather memory.  Good performance is achieved by a combination
  399.  * of scatter-gather and clustering (which makes each chunk bigger).
  400.  *
  401.  * Note that the lower layer will always retry when a NAK occurs, up to the
  402.  * timeout limit.  Thus we don't have to worry about it for individual
  403.  * packets.
  404.  */
  405. static int isd200_transfer_partial( struct us_data *us, 
  406.     unsigned char dataDirection,
  407.     char *buf, int length )
  408. {
  409.         int result;
  410.         int partial;
  411.         int pipe;
  413.         /* calculate the appropriate pipe information */
  414. if (dataDirection == SCSI_DATA_READ)
  415.                 pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  416.         else
  417.                 pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  419.         /* transfer the data */
  420.         US_DEBUGP("isd200_transfer_partial(): xfer %d bytesn", length);
  421.         result = usb_stor_bulk_msg(us, buf, pipe, length, &partial);
  422.         US_DEBUGP("usb_stor_bulk_msg() returned %d xferred %d/%dn",
  423.                   result, partial, length);
  425.         /* if we stall, we need to clear it before we go on */
  426.         if (result == -EPIPE) {
  427.                 US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  428.                 usb_stor_clear_halt(us, pipe);
  429.         }
  430.     
  431.         /* did we send all the data? */
  432.         if (partial == length) {
  433.                 US_DEBUGP("isd200_transfer_partial(): transfer completen");
  434.                 return ISD200_TRANSPORT_GOOD;
  435.         }
  437.         /* uh oh... we have an error code, so something went wrong. */
  438.         if (result) {
  439.                 /* NAK - that means we've retried a few times already */
  440.                 if (result == -ETIMEDOUT) {
  441.                         US_DEBUGP("isd200_transfer_partial(): device NAKedn");
  442.                         return ISD200_TRANSPORT_FAILED;
  443.                 }
  445.                 /* -ENOENT -- we canceled this transfer */
  446.                 if (result == -ENOENT) {
  447.                         US_DEBUGP("isd200_transfer_partial(): transfer abortedn");
  448.                         return ISD200_TRANSPORT_ABORTED;
  449.                 }
  451.                 /* the catch-all case */
  452.                 US_DEBUGP("isd200_transfer_partial(): unknown errorn");
  453.                 return ISD200_TRANSPORT_FAILED;
  454.         }
  456.         /* no error code, so we must have transferred some data, 
  457.          * just not all of it */
  458.         return ISD200_TRANSPORT_SHORT;
  459. }
  462. /**************************************************************************
  463.  * Transfer an entire SCSI command's worth of data payload over the bulk
  464.  * pipe.
  465.  *
  466.  * Note that this uses us_transfer_partial to achieve it's goals -- this
  467.  * function simply determines if we're going to use scatter-gather or not,
  468.  * and acts appropriately.  For now, it also re-interprets the error codes.
  469.  */
  470. static void isd200_transfer( struct us_data *us, Scsi_Cmnd *srb )
  471. {
  472.         int i;
  473.         int result = -1;
  474.         struct scatterlist *sg;
  475.         unsigned int total_transferred = 0;
  476.         unsigned int transfer_amount;
  478.         /* calculate how much we want to transfer */
  479. int dir = srb->sc_data_direction;
  480. srb->sc_data_direction = SCSI_DATA_WRITE;
  481.         transfer_amount = usb_stor_transfer_length(srb);
  482. srb->sc_data_direction = dir;
  484.         /* was someone foolish enough to request more data than available
  485.          * buffer space? */
  486.         if (transfer_amount > srb->request_bufflen)
  487.                 transfer_amount = srb->request_bufflen;
  489.         /* are we scatter-gathering? */
  490.         if (srb->use_sg) {
  492.                 /* loop over all the scatter gather structures and 
  493.                  * make the appropriate requests for each, until done
  494.                  */
  495.                 sg = (struct scatterlist *) srb->request_buffer;
  496.                 for (i = 0; i < srb->use_sg; i++) {
  498.                         /* transfer the lesser of the next buffer or the
  499.                          * remaining data */
  500.                         if (transfer_amount - total_transferred >= 
  501.                             sg[i].length) {
  502.                                 result = isd200_transfer_partial(us, 
  503.                                                                  srb->sc_data_direction,
  504.                                                                  sg[i].address, 
  505.                                                                  sg[i].length);
  506.                                 total_transferred += sg[i].length;
  507.                         } else
  508.                                 result = isd200_transfer_partial(us, 
  509.                                                                  srb->sc_data_direction,                            
  510.                                                                  sg[i].address,
  511.                                                                  transfer_amount - total_transferred);
  513.                         /* if we get an error, end the loop here */
  514.                         if (result)
  515.                                 break;
  516.                 }
  517.         }
  518.         else
  519.                 /* no scatter-gather, just make the request */
  520.                 result = isd200_transfer_partial(us, 
  521.                                                  srb->sc_data_direction,
  522.                                                  srb->request_buffer, 
  523.                                                  transfer_amount);
  525.         /* return the result in the data structure itself */
  526.         srb->result = result;
  527. }
  530. /***********************************************************************
  531.  * Transport routines
  532.  ***********************************************************************/
  535. /**************************************************************************
  536.  *  ISD200 Bulk Transport
  537.  *
  538.  * Note:  This routine was copied from the usb_stor_Bulk_transport routine
  539.  * located in the transport.c source file.  The scsi command is limited to
  540.  * only 12 bytes while the CDB for the ISD200 must be 16 bytes.
  541.  */
  542. int isd200_Bulk_transport( struct us_data *us, Scsi_Cmnd *srb, 
  543.                            union ata_cdb *AtaCdb, unsigned char AtaCdbLength )
  544. {
  545.         struct bulk_cb_wrap bcb;
  546.         struct bulk_cs_wrap bcs;
  547.         int result;
  548.         int pipe;
  549.         int partial;
  550.         unsigned int transfer_amount;
  552. int dir = srb->sc_data_direction;
  553. srb->sc_data_direction = SCSI_DATA_WRITE;
  554.         transfer_amount = usb_stor_transfer_length(srb);
  555. srb->sc_data_direction = dir;
  556.     
  557.         /* set up the command wrapper */
  558.         bcb.Signature = cpu_to_le32(US_BULK_CB_SIGN);
  559.         bcb.DataTransferLength = cpu_to_le32(transfer_amount);
  560.         bcb.Flags = srb->sc_data_direction == SCSI_DATA_READ ? 1 << 7 : 0;
  561.         bcb.Tag = srb->serial_number;
  562.         bcb.Lun = srb->cmnd[1] >> 5;
  563.         if (us->flags & US_FL_SCM_MULT_TARG)
  564.                 bcb.Lun |= srb->target << 4;
  566.         bcb.Length = AtaCdbLength;
  567.     
  568.         /* construct the pipe handle */
  569.         pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  570.     
  571.         /* copy the command payload */
  572.         memset(bcb.CDB, 0, sizeof(bcb.CDB));
  573.         memcpy(bcb.CDB, AtaCdb, bcb.Length);
  574.     
  575.         /* send it to out endpoint */
  576.         US_DEBUGP("Bulk command S 0x%x T 0x%x Trg %d LUN %d L %d F %d CL %dn",
  577.                   le32_to_cpu(bcb.Signature), bcb.Tag,
  578.                   (bcb.Lun >> 4), (bcb.Lun & 0xFF), 
  579.                   le32_to_cpu(bcb.DataTransferLength), bcb.Flags, bcb.Length);
  580.         result = usb_stor_bulk_msg(us, &bcb, pipe, US_BULK_CB_WRAP_LEN, 
  581.    &partial);
  582.         US_DEBUGP("Bulk command transfer result=%dn", result);
  583.     
  584. if (result == -ENOENT)
  585. return ISD200_TRANSPORT_ABORTED;
  586. else if (result == -EPIPE) {
  587. /* if we stall, we need to clear it before we go on */
  588.                 US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  589.                 usb_stor_clear_halt(us, pipe);
  590. } else if (result)  
  591.                 return ISD200_TRANSPORT_ERROR;
  592.     
  593.         /* if the command transfered well, then we go to the data stage */
  594.         if (!result && bcb.DataTransferLength) {
  595. isd200_transfer(us, srb);
  596. US_DEBUGP("Bulk data transfer result 0x%xn", srb->result);
  598. if (srb->result == ISD200_TRANSPORT_ABORTED)
  599. return ISD200_TRANSPORT_ABORTED;
  600.         }
  601.     
  602.         /* See flow chart on pg 15 of the Bulk Only Transport spec for
  603.          * an explanation of how this code works.
  604.          */
  605.     
  606.         /* construct the pipe handle */
  607.         pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  608.     
  609.         /* get CSW for device status */
  610.         US_DEBUGP("Attempting to get CSW...n");
  611.         result = usb_stor_bulk_msg(us, &bcs, pipe, US_BULK_CS_WRAP_LEN, 
  612.    &partial);
  613.         if (result == -ENOENT)
  614.                 return ISD200_TRANSPORT_ABORTED;
  616.         /* did the attempt to read the CSW fail? */
  617.         if (result == -EPIPE) {
  618.                 US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  619.                 usb_stor_clear_halt(us, pipe);
  620.            
  621.                 /* get the status again */
  622.                 US_DEBUGP("Attempting to get CSW (2nd try)...n");
  623.                 result = usb_stor_bulk_msg(us, &bcs, pipe,
  624.                                            US_BULK_CS_WRAP_LEN, &partial);
  626.                 /* if the command was aborted, indicate that */
  627.                 if (result == -ENOENT)
  628.                         return ISD200_TRANSPORT_ABORTED;
  629.         
  630.                 /* if it fails again, we need a reset and return an error*/
  631.                 if (result == -EPIPE) {
  632.                         US_DEBUGP("clearing halt for pipe 0x%xn", pipe);
  633.                         usb_stor_clear_halt(us, pipe);
  634.                         return ISD200_TRANSPORT_ERROR;
  635.                 }
  636.         }
  637.     
  638.         /* if we still have a failure at this point, we're in trouble */
  639.         US_DEBUGP("Bulk status result = %dn", result);
  640.         if (result)
  641.                 return ISD200_TRANSPORT_ERROR;
  642.     
  643.         /* check bulk status */
  644.         US_DEBUGP("Bulk status Sig 0x%x T 0x%x R %d Stat 0x%xn",
  645.                   le32_to_cpu(bcs.Signature), bcs.Tag, 
  646.                   bcs.Residue, bcs.Status);
  647.         if (bcs.Signature != cpu_to_le32(US_BULK_CS_SIGN) || 
  648.             bcs.Tag != bcb.Tag || 
  649.             bcs.Status > US_BULK_STAT_PHASE || partial != 13) {
  650.                 US_DEBUGP("Bulk logical errorn");
  651.                 return ISD200_TRANSPORT_ERROR;
  652.         }
  653.     
  654.         /* based on the status code, we report good or bad */
  655.         switch (bcs.Status) {
  656.         case US_BULK_STAT_OK:
  657.                 /* command good -- note that we could be short on data */
  658.                 return ISD200_TRANSPORT_GOOD;
  660.         case US_BULK_STAT_FAIL:
  661.                 /* command failed */
  662.                 return ISD200_TRANSPORT_FAILED;
  663.         
  664.         case US_BULK_STAT_PHASE:
  665.                 /* phase error */
  666.                 usb_stor_Bulk_reset(us);
  667.                 return ISD200_TRANSPORT_ERROR;
  668.         }
  669.     
  670.         /* we should never get here, but if we do, we're in trouble */
  671.         return ISD200_TRANSPORT_ERROR;
  672. }
  675. /**************************************************************************
  676.  *  isd200_action
  677.  *
  678.  * Routine for sending commands to the isd200
  679.  *
  680.  * RETURNS:
  681.  *    ISD status code
  682.  */
  683. static int isd200_action( struct us_data *us, int action, 
  684.   void* pointer, int value )
  685. {
  686. union ata_cdb ata;
  687. struct scsi_cmnd srb;
  688. struct isd200_info *info = (struct isd200_info *)us->extra;
  689. int status;
  691. memset(&ata, 0, sizeof(ata));
  692. memset(&srb, 0, sizeof(srb));
  694. ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  695. ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  696. ata.generic.TransferBlockSize = 1;
  698. switch ( action ) {
  699. case ACTION_READ_STATUS:
  700. US_DEBUGP("   isd200_action(READ_STATUS)n");
  701. ata.generic.ActionSelect = ACTION_SELECT_0|ACTION_SELECT_2;
  702. ata.generic.RegisterSelect =
  703.   REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
  704.   REG_STATUS | REG_ERROR;
  705. srb.sc_data_direction = SCSI_DATA_READ;
  706. srb.request_buffer = pointer;
  707. srb.request_bufflen = value;
  708. break;
  710. case ACTION_ENUM:
  711. US_DEBUGP("   isd200_action(ENUM,0x%02x)n",value);
  712. ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
  713.                    ACTION_SELECT_3|ACTION_SELECT_4|
  714.                            ACTION_SELECT_5;
  715. ata.generic.RegisterSelect = REG_DEVICE_HEAD;
  716. ata.write.DeviceHeadByte = value;
  717. srb.sc_data_direction = SCSI_DATA_NONE;
  718. break;
  720. case ACTION_RESET:
  721. US_DEBUGP("   isd200_action(RESET)n");
  722. ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
  723.                    ACTION_SELECT_3|ACTION_SELECT_4;
  724. ata.generic.RegisterSelect = REG_DEVICE_CONTROL;
  725. ata.write.DeviceControlByte = ATA_DC_RESET_CONTROLLER;
  726. srb.sc_data_direction = SCSI_DATA_NONE;
  727. break;
  729. case ACTION_REENABLE:
  730. US_DEBUGP("   isd200_action(REENABLE)n");
  731. ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_2|
  732.                    ACTION_SELECT_3|ACTION_SELECT_4;
  733. ata.generic.RegisterSelect = REG_DEVICE_CONTROL;
  734. ata.write.DeviceControlByte = ATA_DC_REENABLE_CONTROLLER;
  735. srb.sc_data_direction = SCSI_DATA_NONE;
  736. break;
  738. case ACTION_SOFT_RESET:
  739. US_DEBUGP("   isd200_action(SOFT_RESET)n");
  740. ata.generic.ActionSelect = ACTION_SELECT_1|ACTION_SELECT_5;
  741. ata.generic.RegisterSelect = REG_DEVICE_HEAD | REG_COMMAND;
  742. ata.write.DeviceHeadByte = info->DeviceHead;
  743. ata.write.CommandByte = WIN_SRST;
  744. srb.sc_data_direction = SCSI_DATA_NONE;
  745. break;
  747. case ACTION_IDENTIFY:
  748. US_DEBUGP("   isd200_action(IDENTIFY)n");
  749. ata.generic.RegisterSelect = REG_COMMAND;
  750. ata.write.CommandByte = WIN_IDENTIFY;
  751. srb.sc_data_direction = SCSI_DATA_READ;
  752. srb.request_buffer = (void *)&info->drive;
  753. srb.request_bufflen = sizeof(struct hd_driveid);
  754. break;
  756. default:
  757. US_DEBUGP("Error: Undefined action %dn",action);
  758. break;
  759. }
  761. status = isd200_Bulk_transport(us, &srb, &ata, sizeof(ata.generic));
  762. if (status != ISD200_TRANSPORT_GOOD) {
  763. US_DEBUGP("   isd200_action(0x%02x) error: %dn",action,status);
  764. status = ISD200_ERROR;
  765. /* need to reset device here */
  766. }
  768. return status;
  769. }
  771. /**************************************************************************
  772.  * isd200_read_regs
  773.  *                                                                         
  774.  * Read ATA Registers
  775.  *
  776.  * RETURNS:
  777.  *    ISD status code
  778.  */                                                                        
  779. int isd200_read_regs( struct us_data *us )
  780. {
  781. struct isd200_info *info = (struct isd200_info *)us->extra;
  782. int retStatus = ISD200_GOOD;
  783. int transferStatus;
  785. US_DEBUGP("Entering isd200_IssueATAReadRegsn");
  787. transferStatus = isd200_action( us, ACTION_READ_STATUS,
  788.     info->ATARegs, sizeof(info->ATARegs) );
  789. if (transferStatus != ISD200_TRANSPORT_GOOD) {
  790. US_DEBUGP("   Error reading ATA registersn");
  791. retStatus = ISD200_ERROR;
  792.         } else {
  793. US_DEBUGP("   Got ATA Register[IDE_ERROR_OFFSET] = 0x%xn", 
  794.   info->ATARegs[IDE_ERROR_OFFSET]);
  795.         }
  797. return retStatus;
  798. }
  801. /**************************************************************************
  802.  * Invoke the transport and basic error-handling/recovery methods
  803.  *
  804.  * This is used by the protocol layers to actually send the message to
  805.  * the device and receive the response.
  806.  */
  807. void isd200_invoke_transport( struct us_data *us, 
  808.       Scsi_Cmnd *srb, 
  809.       union ata_cdb *ataCdb )
  810. {
  811. int need_auto_sense = 0;
  812. int transferStatus;
  814. /* send the command to the transport layer */
  815. transferStatus = isd200_Bulk_transport(us, srb, ataCdb,
  816.        sizeof(ataCdb->generic));
  817. switch (transferStatus) {
  819. case ISD200_TRANSPORT_GOOD:
  820. /* Indicate a good result */
  821. srb->result = GOOD;
  822. break;
  824. case ISD200_TRANSPORT_ABORTED:
  825. /* if the command gets aborted by the higher layers, we need to
  826.  * short-circuit all other processing
  827.  */
  828. US_DEBUGP("-- transport indicates command was abortedn");
  829. srb->result = DID_ABORT << 16;
  830. break;
  832. case ISD200_TRANSPORT_FAILED:
  833. US_DEBUGP("-- transport indicates command failuren");
  834. need_auto_sense = 1;
  835. break;
  837. case ISD200_TRANSPORT_ERROR:
  838. US_DEBUGP("-- transport indicates transport failuren");
  839. srb->result = DID_ERROR << 16;
  840. break;
  842. case ISD200_TRANSPORT_SHORT:
  843. if (!((srb->cmnd[0] == REQUEST_SENSE) ||
  844.       (srb->cmnd[0] == INQUIRY) ||
  845.       (srb->cmnd[0] == MODE_SENSE) ||
  846.       (srb->cmnd[0] == LOG_SENSE) ||
  847.       (srb->cmnd[0] == MODE_SENSE_10))) {
  848. US_DEBUGP("-- unexpectedly short transfern");
  849. need_auto_sense = 1;
  850. }
  851. break;
  852.     
  853. default:
  854. US_DEBUGP("-- transport indicates unknown failuren");   
  855. srb->result = DID_ERROR << 16;
  856.        
  857. }
  859. if (need_auto_sense)
  860. if (isd200_read_regs(us) == ISD200_GOOD)
  861. isd200_build_sense(us, srb);
  863. /* Regardless of auto-sense, if we _know_ we have an error
  864.  * condition, show that in the result code
  865.  */
  866. if (transferStatus == ISD200_TRANSPORT_FAILED)
  867. srb->result = CHECK_CONDITION;
  868. }
  870. #ifdef CONFIG_USB_STORAGE_DEBUG
  871. static void isd200_log_config( struct isd200_info* info )
  872. {
  873. US_DEBUGP("      Event Notification: 0x%xn", 
  874.   info->ConfigData.EventNotification);
  875. US_DEBUGP("      External Clock: 0x%xn", 
  876.   info->ConfigData.ExternalClock);
  877. US_DEBUGP("      ATA Init Timeout: 0x%xn", 
  878.   info->ConfigData.ATAInitTimeout);
  879. US_DEBUGP("      ATAPI Command Block Size: 0x%xn", 
  880.   (info->ConfigData.ATAConfig & ATACFG_BLOCKSIZE) >> 6);
  881. US_DEBUGP("      Master/Slave Selection: 0x%xn", 
  882.   info->ConfigData.ATAConfig & ATACFG_MASTER);
  883. US_DEBUGP("      ATAPI Reset: 0x%xn",
  884.   info->ConfigData.ATAConfig & ATACFG_ATAPI_RESET);
  885. US_DEBUGP("      ATA Timing: 0x%xn",
  886.   info->ConfigData.ATAConfig & ATACFG_TIMING);
  887. US_DEBUGP("      ATA Major Command: 0x%xn", 
  888.   info->ConfigData.ATAMajorCommand);
  889. US_DEBUGP("      ATA Minor Command: 0x%xn", 
  890.   info->ConfigData.ATAMinorCommand);
  891. US_DEBUGP("      Init Status: 0x%xn", 
  892.   info->ConfigData.ATAExtraConfig & ATACFGE_INIT_STATUS);
  893. US_DEBUGP("      Config Descriptor 2: 0x%xn", 
  894.   info->ConfigData.ATAExtraConfig & ATACFGE_CONF_DESC2);
  895. US_DEBUGP("      Skip Device Boot: 0x%xn",
  896.   info->ConfigData.ATAExtraConfig & ATACFGE_SKIP_BOOT);
  897. US_DEBUGP("      ATA 3 State Supsend: 0x%xn",
  898.   info->ConfigData.ATAExtraConfig & ATACFGE_STATE_SUSPEND);
  899. US_DEBUGP("      Descriptor Override: 0x%xn", 
  900.   info->ConfigData.ATAExtraConfig & ATACFGE_DESC_OVERRIDE);
  901. US_DEBUGP("      Last LUN Identifier: 0x%xn",
  902.   info->ConfigData.ATAExtraConfig & ATACFGE_LAST_LUN);
  903. US_DEBUGP("      SRST Enable: 0x%xn", 
  904.   info->ConfigData.ATAExtraConfig & CFG_CAPABILITY_SRST);
  905. }
  906. #endif
  908. /**************************************************************************
  909.  * isd200_write_config
  910.  *                                                                         
  911.  * Write the ISD200 Configuraton data
  912.  *
  913.  * RETURNS:
  914.  *    ISD status code
  915.  */                                                                        
  916. int isd200_write_config( struct us_data *us ) 
  917. {
  918. struct isd200_info *info = (struct isd200_info *)us->extra;
  919. int retStatus = ISD200_GOOD;
  920. int result;
  922. #ifdef CONFIG_USB_STORAGE_DEBUG
  923. US_DEBUGP("Entering isd200_write_confign");
  924. US_DEBUGP("   Writing the following ISD200 Config Data:n");
  925. isd200_log_config(info);
  926. #endif
  928. /* let's send the command via the control pipe */
  929. result = usb_stor_control_msg(
  930.                 us, 
  931.                 usb_sndctrlpipe(us->pusb_dev,0),
  932.                 0x01, 
  933.                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
  934.                 0x0000, 
  935.                 0x0002, 
  936.                 (void *) &info->ConfigData, 
  937.                 sizeof(info->ConfigData));
  939. if (result >= 0) {
  940. US_DEBUGP("   ISD200 Config Data was written successfullyn");
  941.         } else {
  942. US_DEBUGP("   Request to write ISD200 Config Data failed!n");
  944. /* STALL must be cleared when they are detected */
  945. if (result == -EPIPE) {
  946. US_DEBUGP("-- Stall on control pipe. Clearingn");
  947. result = usb_stor_clear_halt(us,
  948. usb_sndctrlpipe(us->pusb_dev, 0));
  949. US_DEBUGP("-- usb_stor_clear_halt() returns %dn", result);
  951. }
  952. retStatus = ISD200_ERROR;
  953.         }
  955. US_DEBUGP("Leaving isd200_write_config %08Xn", retStatus);
  956. return retStatus;
  957. }
  960. /**************************************************************************
  961.  * isd200_read_config
  962.  *                                                                         
  963.  * Reads the ISD200 Configuraton data
  964.  *
  965.  * RETURNS:
  966.  *    ISD status code
  967.  */                                                                        
  968. int isd200_read_config( struct us_data *us ) 
  969. {
  970. struct isd200_info *info = (struct isd200_info *)us->extra;
  971. int retStatus = ISD200_GOOD;
  972. int result;
  974. US_DEBUGP("Entering isd200_read_confign");
  976. /* read the configuration information from ISD200.  Use this to */
  977. /* determine what the special ATA CDB bytes are.                */
  979. result = usb_stor_control_msg(
  980.                 us, 
  981.                 usb_rcvctrlpipe(us->pusb_dev,0),
  982.                 0x02, 
  983.                 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
  984.                 0x0000, 
  985.                 0x0002, 
  986.                 (void *) &info->ConfigData, 
  987.                 sizeof(info->ConfigData));
  990. if (result >= 0) {
  991. US_DEBUGP("   Retrieved the following ISD200 Config Data:n");
  992. #ifdef CONFIG_USB_STORAGE_DEBUG
  993. isd200_log_config(info);
  994. #endif
  995.         } else {
  996. US_DEBUGP("   Request to get ISD200 Config Data failed!n");
  998. /* STALL must be cleared when they are detected */
  999. if (result == -EPIPE) {
  1000. US_DEBUGP("-- Stall on control pipe. Clearingn");
  1001. result = usb_stor_clear_halt(us,   
  1002. usb_sndctrlpipe(us->pusb_dev, 0));
  1003. US_DEBUGP("-- usb_stor_clear_halt() returns %dn", result);
  1005. }
  1006. retStatus = ISD200_ERROR;
  1007.         }
  1009. US_DEBUGP("Leaving isd200_read_config %08Xn", retStatus);
  1010. return retStatus;
  1011. }
  1014. /**************************************************************************
  1015.  * isd200_atapi_soft_reset
  1016.  *                                                                         
  1017.  * Perform an Atapi Soft Reset on the device
  1018.  *
  1019.  * RETURNS:
  1020.  *    NT status code
  1021.  */                                                                        
  1022. int isd200_atapi_soft_reset( struct us_data *us ) 
  1023. {
  1024. int retStatus = ISD200_GOOD;
  1025. int transferStatus;
  1027. US_DEBUGP("Entering isd200_atapi_soft_resetn");
  1029. transferStatus = isd200_action( us, ACTION_SOFT_RESET, NULL, 0 );
  1030. if (transferStatus != ISD200_TRANSPORT_GOOD) {
  1031. US_DEBUGP("   Error issuing Atapi Soft Resetn");
  1032. retStatus = ISD200_ERROR;
  1033.         }
  1035. US_DEBUGP("Leaving isd200_atapi_soft_reset %08Xn", retStatus);
  1036. return retStatus;
  1037. }
  1040. /**************************************************************************
  1041.  * isd200_srst
  1042.  *                                                                         
  1043.  * Perform an SRST on the device
  1044.  *
  1045.  * RETURNS:
  1046.  *    ISD status code
  1047.  */                                                                        
  1048. int isd200_srst( struct us_data *us ) 
  1049. {
  1050. int retStatus = ISD200_GOOD;
  1051. int transferStatus;
  1053. US_DEBUGP("Entering isd200_SRSTn");
  1055. transferStatus = isd200_action( us, ACTION_RESET, NULL, 0 );
  1057. /* check to see if this request failed */
  1058. if (transferStatus != ISD200_TRANSPORT_GOOD) {
  1059. US_DEBUGP("   Error issuing SRSTn");
  1060. retStatus = ISD200_ERROR;
  1061.         } else {
  1062. /* delay 10ms to give the drive a chance to see it */
  1063. wait_ms(10);
  1065. transferStatus = isd200_action( us, ACTION_REENABLE, NULL, 0 );
  1066. if (transferStatus != ISD200_TRANSPORT_GOOD) {
  1067. US_DEBUGP("   Error taking drive out of resetn");
  1068. retStatus = ISD200_ERROR;
  1069. } else {
  1070. /* delay 50ms to give the drive a chance to recover after SRST */
  1071. wait_ms(50);
  1072. }
  1073.         }
  1075. US_DEBUGP("Leaving isd200_srst %08Xn", retStatus);
  1076. return retStatus;
  1077. }
  1080. /**************************************************************************
  1081.  * isd200_try_enum
  1082.  *                                                                         
  1083.  * Helper function for isd200_manual_enum(). Does ENUM and READ_STATUS
  1084.  * and tries to analyze the status registers
  1085.  *
  1086.  * RETURNS:
  1087.  *    ISD status code
  1088.  */                                                                        
  1089. static int isd200_try_enum(struct us_data *us, unsigned char master_slave,
  1090.    int detect )
  1091. {
  1092. int status = ISD200_GOOD;
  1093. unsigned char regs[8];
  1094. unsigned long endTime;
  1095. struct isd200_info *info = (struct isd200_info *)us->extra;
  1096. int recheckAsMaster = FALSE;
  1098. if ( detect )
  1099. endTime = jiffies + ISD200_ENUM_DETECT_TIMEOUT * HZ;
  1100. else
  1101. endTime = jiffies + ISD200_ENUM_BSY_TIMEOUT * HZ;
  1103. /* loop until we detect !BSY or timeout */
  1104. while(TRUE) {
  1105. #ifdef CONFIG_USB_STORAGE_DEBUG
  1106. char* mstr = master_slave == ATA_ADDRESS_DEVHEAD_STD ?
  1107. "Master" : "Slave";
  1108. #endif
  1110. status = isd200_action( us, ACTION_ENUM, NULL, master_slave );
  1111. if ( status != ISD200_GOOD )
  1112. break;
  1114. status = isd200_action( us, ACTION_READ_STATUS, 
  1115. regs, sizeof(regs) );
  1116. if ( status != ISD200_GOOD )
  1117. break;
  1119. if (!detect) {
  1120. if (regs[IDE_STATUS_OFFSET] & BUSY_STAT ) {
  1121. US_DEBUGP("   %s status is still BSY, try again...n",mstr);
  1122. } else {
  1123. US_DEBUGP("   %s status !BSY, continue with next operationn",mstr);
  1124. break;
  1125. }
  1126. }
  1127. /* check for BUSY_STAT and */
  1128. /* WRERR_STAT (workaround ATA Zip drive) and */ 
  1129. /* ERR_STAT (workaround for Archos CD-ROM) */
  1130. else if (regs[IDE_STATUS_OFFSET] & 
  1131.  (BUSY_STAT | WRERR_STAT | ERR_STAT )) {
  1132. US_DEBUGP("   Status indicates it is not ready, try again...n");
  1133. }
  1134. /* check for DRDY, ATA devices set DRDY after SRST */
  1135. else if (regs[IDE_STATUS_OFFSET] & READY_STAT) {
  1136. US_DEBUGP("   Identified ATA devicen");
  1137. info->DeviceFlags |= DF_ATA_DEVICE;
  1138. info->DeviceHead = master_slave;
  1139. break;
  1140. } 
  1141. /* check Cylinder High/Low to
  1142.    determine if it is an ATAPI device
  1143. */
  1144. else if ((regs[IDE_HCYL_OFFSET] == 0xEB) &&
  1145.  (regs[IDE_LCYL_OFFSET] == 0x14)) {
  1146. /* It seems that the RICOH 
  1147.    MP6200A CD/RW drive will 
  1148.    report itself okay as a
  1149.    slave when it is really a
  1150.    master. So this check again
  1151.    as a master device just to
  1152.    make sure it doesn't report
  1153.    itself okay as a master also
  1154. */
  1155. if ((master_slave & ATA_ADDRESS_DEVHEAD_SLAVE) &&
  1156.     (recheckAsMaster == FALSE)) {
  1157. US_DEBUGP("   Identified ATAPI device as slave.  Rechecking again as mastern");
  1158. recheckAsMaster = TRUE;
  1159. master_slave = ATA_ADDRESS_DEVHEAD_STD;
  1160. } else {
  1161. US_DEBUGP("   Identified ATAPI devicen");
  1162. info->DeviceHead = master_slave;
  1163.       
  1164. status = isd200_atapi_soft_reset(us);
  1165. break;
  1166. }
  1167. } else {
  1168.   US_DEBUGP("   Not ATA, not ATAPI. Weird.n");
  1169. break;
  1170. }
  1172. /* check for timeout on this request */
  1173. if (time_after_eq(jiffies, endTime)) {
  1174. if (!detect)
  1175. US_DEBUGP("   BSY check timeout, just continue with next operation...n");
  1176. else
  1177. US_DEBUGP("   Device detect timeout!n");
  1178. break;
  1179. }
  1180. }
  1182. return status;
  1183. }
  1185. /**************************************************************************
  1186.  * isd200_manual_enum
  1187.  *                                                                         
  1188.  * Determines if the drive attached is an ATA or ATAPI and if it is a
  1189.  * master or slave.
  1190.  *
  1191.  * RETURNS:
  1192.  *    ISD status code
  1193.  */                                                                        
  1194. int isd200_manual_enum(struct us_data *us)
  1195. {
  1196. struct isd200_info *info = (struct isd200_info *)us->extra;
  1197. int retStatus = ISD200_GOOD;
  1199. US_DEBUGP("Entering isd200_manual_enumn");
  1201. retStatus = isd200_read_config(us);
  1202. if (retStatus == ISD200_GOOD) {
  1203. int isslave;
  1204. /* master or slave? */
  1205. retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, FALSE );
  1206. if (retStatus == ISD200_GOOD)
  1207. retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_SLAVE, FALSE );
  1209. if (retStatus == ISD200_GOOD) {
  1210. retStatus = isd200_srst(us);
  1211. if (retStatus == ISD200_GOOD)
  1212. /* ata or atapi? */
  1213. retStatus = isd200_try_enum( us, ATA_ADDRESS_DEVHEAD_STD, TRUE );
  1214. }
  1216. isslave = (info->DeviceHead & ATA_ADDRESS_DEVHEAD_SLAVE) ? 1 : 0;
  1217. if (!(info->ConfigData.ATAConfig & ATACFG_MASTER)) {
  1218. US_DEBUGP("   Setting Master/Slave selection to %dn", isslave);
  1219. info->ConfigData.ATAConfig &= 0x3f;
  1220. info->ConfigData.ATAConfig |= (isslave<<6);
  1221. retStatus = isd200_write_config(us);
  1222. }
  1223. }
  1225. US_DEBUGP("Leaving isd200_manual_enum %08Xn", retStatus);
  1226. return(retStatus);
  1227. }
  1230. /**************************************************************************
  1231.  * isd200_get_inquiry_data
  1232.  *
  1233.  * Get inquiry data
  1234.  *
  1235.  * RETURNS:
  1236.  *    ISD status code
  1237.  */
  1238. int isd200_get_inquiry_data( struct us_data *us )
  1239. {
  1240. struct isd200_info *info = (struct isd200_info *)us->extra;
  1241. int retStatus = ISD200_GOOD;
  1243. US_DEBUGP("Entering isd200_get_inquiry_datan");
  1245. /* set default to Master */
  1246. info->DeviceHead = ATA_ADDRESS_DEVHEAD_STD;
  1248. /* attempt to manually enumerate this device */
  1249. retStatus = isd200_manual_enum(us);
  1250. if (retStatus == ISD200_GOOD) {
  1251. int transferStatus;
  1253. /* check for an ATA device */
  1254. if (info->DeviceFlags & DF_ATA_DEVICE) {
  1255. /* this must be an ATA device */
  1256. /* perform an ATA Commmand Identify */
  1257. transferStatus = isd200_action( us, ACTION_IDENTIFY,
  1258. &info->drive, 
  1259. sizeof(struct hd_driveid) );
  1260. if (transferStatus != ISD200_TRANSPORT_GOOD) {
  1261. /* Error issuing ATA Command Identify */
  1262. US_DEBUGP("   Error issuing ATA Command Identifyn");
  1263. retStatus = ISD200_ERROR;
  1264. } else {
  1265. /* ATA Command Identify successful */
  1266. int i;
  1267. __u16 *src, *dest;
  1268. ide_fix_driveid(&info->drive);
  1270. US_DEBUGP("   Identify Data Structure:n");
  1271. US_DEBUGP("      config = 0x%xn", info->drive.config);
  1272. US_DEBUGP("      cyls = 0x%xn", info->drive.cyls);
  1273. US_DEBUGP("      heads = 0x%xn", info->drive.heads);
  1274. US_DEBUGP("      track_bytes = 0x%xn", info->drive.track_bytes);
  1275. US_DEBUGP("      sector_bytes = 0x%xn", info->drive.sector_bytes);
  1276. US_DEBUGP("      sectors = 0x%xn", info->drive.sectors);
  1277. US_DEBUGP("      serial_no[0] = 0x%xn", info->drive.serial_no[0]);
  1278. US_DEBUGP("      buf_type = 0x%xn", info->drive.buf_type);
  1279. US_DEBUGP("      buf_size = 0x%xn", info->drive.buf_size);
  1280. US_DEBUGP("      ecc_bytes = 0x%xn", info->drive.ecc_bytes);
  1281. US_DEBUGP("      fw_rev[0] = 0x%xn", info->drive.fw_rev[0]);
  1282. US_DEBUGP("      model[0] = 0x%xn", info->drive.model[0]);
  1283. US_DEBUGP("      max_multsect = 0x%xn", info->drive.max_multsect);
  1284. US_DEBUGP("      dword_io = 0x%xn", info->drive.dword_io);
  1285. US_DEBUGP("      capability = 0x%xn", info->drive.capability);
  1286. US_DEBUGP("      tPIO = 0x%xn", info->drive.tPIO);
  1287. US_DEBUGP("      tDMA = 0x%xn", info->drive.tDMA);
  1288. US_DEBUGP("      field_valid = 0x%xn", info->drive.field_valid);
  1289. US_DEBUGP("      cur_cyls = 0x%xn", info->drive.cur_cyls);
  1290. US_DEBUGP("      cur_heads = 0x%xn", info->drive.cur_heads);
  1291. US_DEBUGP("      cur_sectors = 0x%xn", info->drive.cur_sectors);
  1292. US_DEBUGP("      cur_capacity = 0x%xn", (info->drive.cur_capacity1 << 16) + info->drive.cur_capacity0 );
  1293. US_DEBUGP("      multsect = 0x%xn", info->drive.multsect);
  1294. US_DEBUGP("      lba_capacity = 0x%xn", info->drive.lba_capacity);
  1295. US_DEBUGP("      command_set_1 = 0x%xn", info->drive.command_set_1);
  1296. US_DEBUGP("      command_set_2 = 0x%xn", info->drive.command_set_2);
  1298. memset(&info->InquiryData, 0, sizeof(info->InquiryData));
  1300. /* Standard IDE interface only supports disks */
  1301. info->InquiryData.DeviceType = DIRECT_ACCESS_DEVICE;
  1303. /* Fix-up the return data from an INQUIRY command to show 
  1304.  * ANSI SCSI rev 2 so we don't confuse the SCSI layers above us
  1305.  * in Linux.
  1306.  */
  1307. info->InquiryData.Versions = 0x2;
  1309. /* The length must be at least 36 (5 + 31) */
  1310. info->InquiryData.AdditionalLength = 0x1F;
  1312. if (info->drive.command_set_1 & COMMANDSET_MEDIA_STATUS) {
  1313. /* set the removable bit */
  1314. info->InquiryData.DeviceTypeModifier = DEVICE_REMOVABLE;
  1315. info->DeviceFlags |= DF_REMOVABLE_MEDIA;
  1316. }
  1318. /* Fill in vendor identification fields */
  1319. src = (__u16*)info->drive.model;
  1320. dest = (__u16*)info->InquiryData.VendorId;
  1321. for (i=0;i<4;i++)
  1322. dest[i] = be16_to_cpu(src[i]);
  1324. src = (__u16*)(info->drive.model+8);
  1325. dest = (__u16*)info->InquiryData.ProductId;
  1326. for (i=0;i<8;i++)
  1327. dest[i] = be16_to_cpu(src[i]);
  1329. src = (__u16*)info->drive.fw_rev;
  1330. dest = (__u16*)info->InquiryData.ProductRevisionLevel;
  1331. for (i=0;i<2;i++)
  1332. dest[i] = be16_to_cpu(src[i]);
  1334. /* determine if it supports Media Status Notification */
  1335. if (info->drive.command_set_2 & COMMANDSET_MEDIA_STATUS) {
  1336. US_DEBUGP("   Device supports Media Status Notificationn");
  1338. /* Indicate that it is enabled, even though it is not
  1339.  * This allows the lock/unlock of the media to work
  1340.  * correctly.
  1341.  */
  1342. info->DeviceFlags |= DF_MEDIA_STATUS_ENABLED;
  1343. }
  1344. else
  1345. info->DeviceFlags &= ~DF_MEDIA_STATUS_ENABLED;
  1347. }
  1348. } else {
  1349. /* 
  1350.  * this must be an ATAPI device 
  1351.  * use an ATAPI protocol (Transparent SCSI)
  1352.  */
  1353. us->protocol_name = "Transparent SCSI";
  1354. us->proto_handler = usb_stor_transparent_scsi_command;
  1356. US_DEBUGP("Protocol changed to: %sn", us->protocol_name);
  1357.             
  1358. /* Free driver structure */            
  1359. if (us->extra != NULL) {
  1360. kfree(us->extra);
  1361. us->extra = NULL;
  1362. us->extra_destructor = NULL;
  1363. }
  1364. }
  1365.         }
  1367. US_DEBUGP("Leaving isd200_get_inquiry_data %08Xn", retStatus);
  1369. return(retStatus);
  1370. }
  1373. /**************************************************************************
  1374.  * isd200_data_copy
  1375.  *                                                                         
  1376.  * Copy data into the srb request buffer.  Use scatter gather if required.
  1377.  *
  1378.  * RETURNS:
  1379.  *    void
  1380.  */                                                                        
  1381. void isd200_data_copy(Scsi_Cmnd *srb, char * src, int length)
  1382. {
  1383. unsigned int len = length;
  1384. struct scatterlist *sg;
  1386. if (srb->use_sg) {
  1387. int i;
  1388. unsigned int total = 0;
  1390. /* Add up the sizes of all the sg segments */
  1391. sg = (struct scatterlist *) srb->request_buffer;
  1392. for (i = 0; i < srb->use_sg; i++)
  1393. total += sg[i].length;
  1395. if (length > total)
  1396. len = total;
  1398. total = 0;
  1400. /* Copy data into sg buffer(s) */
  1401. for (i = 0; i < srb->use_sg; i++) {
  1402. if ((len > total) && (len > 0)) {
  1403. /* transfer the lesser of the next buffer or the
  1404.  * remaining data */
  1405. if (len - total >= sg[i].length) {
  1406. memcpy(sg[i].address, src + total, sg[i].length);
  1407. total += sg[i].length;
  1408. } else {
  1409. memcpy(sg[i].address, src + total, len - total);
  1410. total = len;
  1411. }
  1412. } 
  1413. else
  1414. break;
  1415. }
  1416. } else {
  1417. /* Make sure length does not exceed buffer length */
  1418. if (length > srb->request_bufflen)
  1419. len = srb->request_bufflen;
  1421. if (len > 0)
  1422. memcpy(srb->request_buffer, src, len);
  1423. }
  1424. }
  1427. /**************************************************************************
  1428.  * isd200_scsi_to_ata
  1429.  *                                                                         
  1430.  * Translate SCSI commands to ATA commands.
  1431.  *
  1432.  * RETURNS:
  1433.  *    TRUE if the command needs to be sent to the transport layer
  1434.  *    FALSE otherwise
  1435.  */                                                                        
  1436. int isd200_scsi_to_ata(Scsi_Cmnd *srb, struct us_data *us, 
  1437.        union ata_cdb * ataCdb)
  1438. {
  1439. struct isd200_info *info = (struct isd200_info *)us->extra;
  1440. int sendToTransport = TRUE;
  1441. unsigned char sectnum, head;
  1442. unsigned short cylinder;
  1443. unsigned long lba;
  1444. unsigned long blockCount;
  1445. unsigned char senseData[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
  1447. memset(ataCdb, 0, sizeof(union ata_cdb));
  1449. /* SCSI Command */
  1450. switch (srb->cmnd[0]) {
  1451. case INQUIRY:
  1452. US_DEBUGP("   ATA OUT - INQUIRYn");
  1454. if (srb->request_bufflen > sizeof(struct inquiry_data))
  1455. srb->request_bufflen = sizeof(struct inquiry_data);
  1457. /* copy InquiryData */
  1458. isd200_data_copy(srb, (char *) &info->InquiryData, srb->request_bufflen);
  1459. srb->result = GOOD;
  1460. sendToTransport = FALSE;
  1461. break;
  1463. case MODE_SENSE:
  1464. US_DEBUGP("   ATA OUT - SCSIOP_MODE_SENSEn");
  1466. /* Initialize the return buffer */
  1467. isd200_data_copy(srb, (char *) &senseData, 8);
  1469. if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
  1470. {
  1471. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1472. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1473. ataCdb->generic.TransferBlockSize = 1;
  1474. ataCdb->generic.RegisterSelect = REG_COMMAND;
  1475. ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
  1476. srb->request_bufflen = 0;
  1477. } else {
  1478. US_DEBUGP("   Media Status not supported, just report okayn");
  1479. srb->result = GOOD;
  1480. sendToTransport = FALSE;
  1481. }
  1482. break;
  1484. case TEST_UNIT_READY:
  1485. US_DEBUGP("   ATA OUT - SCSIOP_TEST_UNIT_READYn");
  1487. /* Initialize the return buffer */
  1488. isd200_data_copy(srb, (char *) &senseData, 8);
  1490. if (info->DeviceFlags & DF_MEDIA_STATUS_ENABLED)
  1491. {
  1492. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1493. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1494. ataCdb->generic.TransferBlockSize = 1;
  1495. ataCdb->generic.RegisterSelect = REG_COMMAND;
  1496. ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
  1497. srb->request_bufflen = 0;
  1498. } else {
  1499. US_DEBUGP("   Media Status not supported, just report okayn");
  1500. srb->result = GOOD;
  1501. sendToTransport = FALSE;
  1502. }
  1503. break;
  1505. case READ_CAPACITY:
  1506. {
  1507. unsigned long capacity;
  1508. struct read_capacity_data readCapacityData;
  1510. US_DEBUGP("   ATA OUT - SCSIOP_READ_CAPACITYn");
  1512. if (info->drive.capability & CAPABILITY_LBA ) {
  1513. capacity = info->drive.lba_capacity - 1;
  1514. } else {
  1515. capacity = (info->drive.heads *
  1516.     info->drive.cyls *
  1517.     info->drive.sectors) - 1;
  1518. }
  1519. readCapacityData.LogicalBlockAddress = cpu_to_be32(capacity);
  1520. readCapacityData.BytesPerBlock = cpu_to_be32(0x200);
  1522. if (srb->request_bufflen > sizeof(struct read_capacity_data))
  1523. srb->request_bufflen = sizeof(struct read_capacity_data);
  1525. isd200_data_copy(srb, (char *) &readCapacityData, srb->request_bufflen);
  1526. srb->result = GOOD;
  1527. sendToTransport = FALSE;
  1528. }
  1529. break;
  1531. case READ_10:
  1532. US_DEBUGP("   ATA OUT - SCSIOP_READn");
  1534. lba = *(unsigned long *)&srb->cmnd[2]; 
  1535. lba = cpu_to_be32(lba);
  1536. blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
  1538. if (info->drive.capability & CAPABILITY_LBA) {
  1539. sectnum = (unsigned char)(lba);
  1540. cylinder = (unsigned short)(lba>>8);
  1541. head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
  1542. } else {
  1543. sectnum = (unsigned char)((lba % info->drive.sectors) + 1);
  1544. cylinder = (unsigned short)(lba / (info->drive.sectors *
  1545.    info->drive.heads));
  1546. head = (unsigned char)((lba / info->drive.sectors) %
  1547.        info->drive.heads);
  1548. }
  1549. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1550. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1551. ataCdb->generic.TransferBlockSize = 1;
  1552. ataCdb->generic.RegisterSelect =
  1553.   REG_SECTOR_COUNT | REG_SECTOR_NUMBER |
  1554.   REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
  1555.   REG_DEVICE_HEAD  | REG_COMMAND;
  1556. ataCdb->write.SectorCountByte = (unsigned char)blockCount;
  1557. ataCdb->write.SectorNumberByte = sectnum;
  1558. ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
  1559. ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
  1560. ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
  1561. ataCdb->write.CommandByte = WIN_READ;
  1562. break;
  1564. case WRITE_10:
  1565. US_DEBUGP("   ATA OUT - SCSIOP_WRITEn");
  1567. lba = *(unsigned long *)&srb->cmnd[2]; 
  1568. lba = cpu_to_be32(lba);
  1569. blockCount = (unsigned long)srb->cmnd[7]<<8 | (unsigned long)srb->cmnd[8];
  1571. if (info->drive.capability & CAPABILITY_LBA) {
  1572. sectnum = (unsigned char)(lba);
  1573. cylinder = (unsigned short)(lba>>8);
  1574. head = ATA_ADDRESS_DEVHEAD_LBA_MODE | (unsigned char)(lba>>24 & 0x0F);
  1575. } else {
  1576. sectnum = (unsigned char)((lba % info->drive.sectors) + 1);
  1577. cylinder = (unsigned short)(lba / (info->drive.sectors * info->drive.heads));
  1578. head = (unsigned char)((lba / info->drive.sectors) % info->drive.heads);
  1579. }
  1580. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1581. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1582. ataCdb->generic.TransferBlockSize = 1;
  1583. ataCdb->generic.RegisterSelect =
  1584.   REG_SECTOR_COUNT | REG_SECTOR_NUMBER |
  1585.   REG_CYLINDER_LOW | REG_CYLINDER_HIGH |
  1586.   REG_DEVICE_HEAD  | REG_COMMAND;
  1587. ataCdb->write.SectorCountByte = (unsigned char)blockCount;
  1588. ataCdb->write.SectorNumberByte = sectnum;
  1589. ataCdb->write.CylinderHighByte = (unsigned char)(cylinder>>8);
  1590. ataCdb->write.CylinderLowByte = (unsigned char)cylinder;
  1591. ataCdb->write.DeviceHeadByte = (head | ATA_ADDRESS_DEVHEAD_STD);
  1592. ataCdb->write.CommandByte = WIN_WRITE;
  1593. break;
  1595. case ALLOW_MEDIUM_REMOVAL:
  1596. US_DEBUGP("   ATA OUT - SCSIOP_MEDIUM_REMOVALn");
  1598. if (info->DeviceFlags & DF_REMOVABLE_MEDIA) {
  1599. US_DEBUGP("   srb->cmnd[4] = 0x%Xn", srb->cmnd[4]);
  1600.             
  1601. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1602. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1603. ataCdb->generic.TransferBlockSize = 1;
  1604. ataCdb->generic.RegisterSelect = REG_COMMAND;
  1605. ataCdb->write.CommandByte = (srb->cmnd[4] & 0x1) ?
  1606. WIN_DOORLOCK : WIN_DOORUNLOCK;
  1607. srb->request_bufflen = 0;
  1608. } else {
  1609. US_DEBUGP("   Not removeable media, just report okayn");
  1610. srb->result = GOOD;
  1611. sendToTransport = FALSE;
  1612. }
  1613. break;
  1615. case START_STOP:    
  1616. US_DEBUGP("   ATA OUT - SCSIOP_START_STOP_UNITn");
  1617. US_DEBUGP("   srb->cmnd[4] = 0x%Xn", srb->cmnd[4]);
  1619. /* Initialize the return buffer */
  1620. isd200_data_copy(srb, (char *) &senseData, 8);
  1622. if ((srb->cmnd[4] & 0x3) == 0x2) {
  1623. US_DEBUGP("   Media Ejectn");
  1624. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1625. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1626. ataCdb->generic.TransferBlockSize = 0;
  1627. ataCdb->generic.RegisterSelect = REG_COMMAND;
  1628. ataCdb->write.CommandByte = ATA_COMMAND_MEDIA_EJECT;
  1629. } else if ((srb->cmnd[4] & 0x3) == 0x1) {
  1630. US_DEBUGP("   Get Media Statusn");
  1631. ataCdb->generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
  1632. ataCdb->generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;
  1633. ataCdb->generic.TransferBlockSize = 1;
  1634. ataCdb->generic.RegisterSelect = REG_COMMAND;
  1635. ataCdb->write.CommandByte = ATA_COMMAND_GET_MEDIA_STATUS;
  1636. srb->request_bufflen = 0;
  1637. } else {
  1638. US_DEBUGP("   Nothing to do, just report okayn");
  1639. srb->result = GOOD;
  1640. sendToTransport = FALSE;
  1641. }
  1642. break;
  1644. default:
  1645. US_DEBUGP("Unsupported SCSI command - 0x%Xn", srb->cmnd[0]);
  1646. srb->result = DID_ERROR << 16;
  1647. sendToTransport = FALSE;
  1648. break;
  1649. }
  1651. return(sendToTransport);
  1652. }
  1655. /**************************************************************************
  1656.  * isd200_init_info
  1657.  *                                                                         
  1658.  * Allocates (if necessary) and initializes the driver structure.
  1659.  *
  1660.  * RETURNS:
  1661.  *    ISD status code
  1662.  */                                                                        
  1663. int isd200_init_info(struct us_data *us)
  1664. {
  1665. int retStatus = ISD200_GOOD;
  1667. if (!us->extra) {
  1668. us->extra = (void *) kmalloc(sizeof(struct isd200_info), GFP_KERNEL);
  1669. if (!us->extra) {
  1670. US_DEBUGP("ERROR - kmalloc failuren");
  1671. retStatus = ISD200_ERROR;
  1672. }
  1673.         }
  1675. if (retStatus == ISD200_GOOD) {
  1676. memset(us->extra, 0, sizeof(struct isd200_info));
  1677.         }
  1679. return(retStatus);
  1680. }
  1682. /**************************************************************************
  1683.  * Initialization for the ISD200 
  1684.  */
  1686. int isd200_Initialization(struct us_data *us)
  1687. {
  1688. US_DEBUGP("ISD200 Initialization...n");
  1690. /* Initialize ISD200 info struct */
  1692. if (isd200_init_info(us) == ISD200_ERROR) {
  1693. US_DEBUGP("ERROR Initializing ISD200 Info structn");
  1694.         } else {
  1695. /* Get device specific data */
  1697. if (isd200_get_inquiry_data(us) != ISD200_GOOD)
  1698. US_DEBUGP("ISD200 Initialization Failuren");
  1699. else
  1700. US_DEBUGP("ISD200 Initialization completen");
  1701.         }
  1703. return 0;
  1704. }
  1707. /**************************************************************************
  1708.  * Protocol and Transport for the ISD200 ASIC
  1709.  *
  1710.  * This protocol and transport are for ATA devices connected to an ISD200
  1711.  * ASIC.  An ATAPI device that is conected as a slave device will be
  1712.  * detected in the driver initialization function and the protocol will
  1713.  * be changed to an ATAPI protocol (Transparent SCSI).
  1714.  *
  1715.  */
  1717. void isd200_ata_command(Scsi_Cmnd *srb, struct us_data *us)
  1718. {
  1719. int sendToTransport = TRUE;
  1720. union ata_cdb ataCdb;
  1722. /* Make sure driver was initialized */
  1724. if (us->extra == NULL)
  1725. US_DEBUGP("ERROR Driver not initializedn");
  1727. /* Convert command */
  1728. sendToTransport = isd200_scsi_to_ata(srb, us, &ataCdb);
  1730. /* send the command to the transport layer */
  1731. if (sendToTransport)
  1732. isd200_invoke_transport(us, srb, &ataCdb);
  1733. }