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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
isd200.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：57k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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