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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ataDrv.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：90k
源码类别：

VxWorks

开发平台：

C/C++

ataDrv.c：源码内容
  1. /* ataDrv.c - ATA/IDE and ATAPI CDROM (LOCAL and PCMCIA) disk device driver */
  3. /* Copyright 1989-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01y,29apr02,pmr  SPR 76487: set up configType properly in ataDrv().
  10. 01x,15jan02,jkf  SPR#72183, ataDevCreate missing ctrl parameter description.
  11. 01w,10dec01,jkf  avoid 32 access to 16 bit boundary in ataPiBlkRd
  12. 01v,09dec01,jkf  changed copyright to 2002
  13. 01u,08dec01,jkf  fixed the NULL pointer accesses in ataPiPktCmdExec().
  14. 01t,08dec01,jkf  SPR#28746, ataInit() caused extra int on some hardware
  15. 01s,19nov01,jac  fixed mishandling of UNIT_ATTENTION condition for ATAPI
  16.                  devices.
  17. 01r,09nov01,jac  SPR#67795, added support for ATAPI CD-ROMs (according to
  18.                  SFF-8020i) by merging changes from mjc's ATAPI driver
  19.                  extensions.
  20. 01q,24jul00,jkf  SPR#29571, nSectors reset change,fixed typo in 01p.
  21. 01p,12jul00,rcs  Reset nSectors back to nSecs in ataRW on retryRW SPR#29571.
  22. 01o,19sep99,jkf  Removed extra SYS_ATA_INIT_RTN, now check wait in ataRW().
  23. 01n,17jul99,jkf  using words 60-61 to determine LBA instead 
  24.  of CHS calculation, for big drives, 8.4Gb+. SPR#22830.
  25. 01m,04mar99,jkf  Added SYS_ATA_INIT_RTN.  _func_sysAtaInit. SPR#24378.
  26. 01l,09jun98,dat  fixed conflicting prototypes, removed ref to sysMsDelay()
  27. 01k,09jun98,ms   removed IMPORT prototypes conflicting with sysLib.h proto's
  28. 01j,31mar98,map  removed INCLUDE_ATA, redefined sys* prototypes.
  29. 01i,23mar98,map  renamed macros, made endian safe, added docs.
  30. 01h,30oct97,db   added cmd to reinitialize controller with params read. fixed
  31.                  bug reported in SPR #9139. used PCI macros for input/output.
  32. 01g,21apr97,hdn  fixed a semaphore timeout problem(SPR 8394).
  33. 01f,28feb97,dat  fixed SPRs 8084, 3273 from ideDrv.
  34. 01e,06nov96,dgp  doc: final formatting
  35. 01d,01nov96,hdn  added support for PCMCIA.
  36. 01c,25sep96,hdn  added support for ATA-2.
  37. 01b,01mar96,hdn  cleaned up.
  38. 01a,02mar95,hdn  written based on ideDrv.c.
  39. */
  41. /*
  42. DESCRIPTION
  44. This is a driver for ATA/IDE and ATAPI CDROM devices on PCMCIA, ISA, and other
  45. buses. The driver can be customized via various macros to run on a variety of
  46. boards and both big-endian, and little endian CPUs.
  48. USER-CALLABLE ROUTINES
  50. Most of the routines in this driver are accessible only through the I/O
  51. system.  However, two routines must be called directly:  ataDrv() to
  52. initialize the driver and ataDevCreate() to create devices.
  54. Before the driver can be used, it must be initialized by calling ataDrv().
  55. This routine must be called exactly once, before any reads, writes, or
  56. calls to ataDevCreate().  Normally, it is called from usrRoot() in
  57. usrConfig.c.
  59. The routine ataRawio() supports physical I/O access. The first
  60. argument is a drive number, 0 or 1; the second argument is a pointer
  61. to an ATA_RAW structure.
  63. NOTE
  64. Format is not supported, because ATA/IDE disks are already formatted, and bad
  65. sectors are mapped.
  67. During initialization this driver queries each disk to determine 
  68. if the disk supports LBA.  16 bit words 0x60 and 0x61 (returned 
  69. from the ATA IDENTIFY DEVICE command) may report a larger value 
  70. than the product of the CHS fields on newer large disks (8.4Gb+).  
  71. The driver will use strict LBA access commands and LBA geometry for 
  72. drives reporting "total LBA sectors" greater than the product of CHS.
  73. Although everyone should also be using strict LBA on LBA disks, some 
  74. older systems (mostly PC's) do not and use only CHS.  Such system cannot 
  75. view drives larger than 8GB.  VxWorks does not have such limitations.    
  76. However, it may be desirable to force VxWorks ignore the LBA information 
  77. in favor of CHS in order to mount a file system originally formatted on 
  78. a CHS only system.  Setting the boolean ataForceCHSonLBA to TRUE will 
  79. force the use of CHS parameters on all drives and the LBA parameters 
  80. are ignored.  Again, setting this boolean may prevent access to the 
  81. drives full capacity, since some manufacturers have stopped setting 
  82. a drives CHS accurately in favor of LBA.
  84. PARAMETERS
  85. The ataDrv() function requires a configuration flag as a parameter.
  86. The configuration flag is one of the following:
  88. .TS
  89. tab(|);
  90. l l .
  91. Transfer mode 
  93. ATA_PIO_DEF_0    | PIO default mode
  94. ATA_PIO_DEF_1    | PIO default mode, no IORDY
  95. ATA_PIO_0        | PIO mode 0
  96. ATA_PIO_1        | PIO mode 1
  97. ATA_PIO_2        | PIO mode 2
  98. ATA_PIO_3        | PIO mode 3
  99. ATA_PIO_4        | PIO mode 4
  100. ATA_PIO_AUTO     | PIO max supported mode
  101. ATA_DMA_0        | DMA mode 0
  102. ATA_DMA_1        | DMA mode 1
  103. ATA_DMA_2        | DMA mode 2
  104. ATA_DMA_AUTO     | DMA max supported mode
  106. Transfer bits
  108. ATA_BITS_16      | RW bits size, 16 bits
  109. ATA_BITS_32      | RW bits size, 32 bits
  111. Transfer unit
  113. ATA_PIO_SINGLE   | RW PIO single sector
  114. ATA_PIO_MULTI    | RW PIO multi sector
  115. ATA_DMA_SINGLE   | RW DMA single word
  116. ATA_DMA_MULTI    | RW DMA multi word
  118. Geometry parameters
  120. ATA_GEO_FORCE    | set geometry in the table
  121. ATA_GEO_PHYSICAL | set physical geometry
  122. ATA_GEO_CURRENT  | set current geometry
  123. .TE
  125. DMA transfer is not supported in this release.  If ATA_PIO_AUTO or ATA_DMA_AUTO
  126. is specified, the driver automatically chooses the maximum mode supported by the
  127. device.  If ATA_PIO_MULTI or ATA_DMA_MULTI is specified, and the device does
  128. not support it, the driver automatically chooses single sector or word mode.
  129. If ATA_BITS_32 is specified, the driver uses 32-bit transfer mode regardless of
  130. the capability of the drive.  
  132. If ATA_GEO_PHYSICAL is specified, the driver uses the physical geometry 
  133. parameters stored in the drive.  If ATA_GEO_CURRENT is specified,
  134. the driver uses current geometry parameters initialized by BIOS.  
  135. If ATA_GEO_FORCE is specified, the driver uses geometry parameters stored 
  136. in sysLib.c.
  138. The geometry parameters are stored in the structure table
  139. `ataTypes[]' in sysLib.c. That table has two entries, the first for
  140. drive 0, the second for drive 1. The members of the structure
  141. are:
  142. .CS
  143.     int cylinders;              /@ number of cylinders @/
  144.     int heads;                  /@ number of heads @/
  145.     int sectors;                /@ number of sectors per track @/
  146.     int bytes;                  /@ number of bytes per sector @/
  147.     int precomp;                /@ precompensation cylinder @/
  148. .CE
  150. This driver does not access the PCI-chip-set IDE interface, but rather takes
  151. advantage of BIOS or VxWorks initialization.  Thus, the BIOS setting should 
  152. match the modes specified by the configuration flag.
  154. The BSP may provide a sysAtaInit() routine for situations where an ATA
  155. controller RESET (0x1f6 or 0x3f6, bit 2 is set) clears ATA specific
  156. functionality in a chipset that is not re-enabled per the ATA-2 spec.
  157.  
  158. This BSP routine should be declared in sysLib.c or sysAta.c as follows:
  159.  
  160. .CS
  161. void sysAtaInit (BOOL ctrl)
  162.     {
  163.     /@ BSP SPECIFIC CODE HERE @/
  164.     }
  165. .CE
  167. Then the BSP should perform the following operation
  168. before ataDrv() is called, in sysHwInit for example:
  170. .CS
  171.     IMPORT VOIDFUNCPTR _func_sysAtaInit;
  172.     /@ setup during initialization @/
  173.     _func_sysAtaInit = (VOIDFUNCPTR) sysAtaInit;
  174. .CE
  177.  
  178. It should contain chipset specific reset code, such as code which re-enables
  179. PCI write posting for an integrated PCI-IDE device, for example.  This will
  180. be executed during every ataDrv(), ataInit(), and ataReset() or equivalent  
  181. block device routine.  If the sysAtaInit routine is not provided by the
  182. BSP it is ignored by the driver, therefore it is not a required BSP routine.
  184. SEE ALSO:
  185. .pG "I/O System"
  186. */
  188. #include "vxWorks.h"
  189. #include "taskLib.h"
  190. #include "ioLib.h"
  191. #include "memLib.h"
  192. #include "stdlib.h"
  193. #include "errnoLib.h"
  194. #include "stdio.h"
  195. #include "string.h"
  196. #include "private/semLibP.h"
  197. #include "intLib.h"
  198. #include "iv.h"
  199. #include "wdLib.h"
  200. #include "sysLib.h"
  201. #include "sys/fcntlcom.h"
  202. #include "drv/pcmcia/pcmciaLib.h"
  203. #include "logLib.h"
  204. #include "drv/hdisk/ataDrv.h"
  206. #define VXDOS                           "VXDOS"
  207. #define VXEXT                           "VXEXT"
  209. /* imports */
  211. IMPORT ATA_TYPE ataTypes [ATA_MAX_CTRLS][ATA_MAX_DRIVES];
  212. IMPORT ATA_RESOURCE ataResources [ATA_MAX_CTRLS];
  214. /* Byte swapping version of sysInWordString(), big-endian CPUs only */
  216. IMPORT void sysInWordStringRev (int port, short *pData, int count);
  218. /* defines */
  220. /* Read a BYTE from IO port, `ioAdrs' */
  222. #ifndef ATA_IO_BYTE_READ
  223. #define ATA_IO_BYTE_READ(ioAdrs) sysInByte (ioAdrs)
  224. #endif /* ATA_IO_BYTE_READ */
  226. /* Write a BYTE `byte' to IO port, `ioAdrs' */
  228. #ifndef ATA_IO_BYTE_WRITE
  229. #define ATA_IO_BYTE_WRITE(ioAdrs, byte) sysOutByte (ioAdrs, byte)
  230. #endif /* ATA_IO_BYTE_WRITE */
  232. /* Read 16-bit little-endian `nWords' into `pData' from IO port, `ioAdrs' */
  234. #ifndef ATA_IO_NWORD_READ
  235. #define ATA_IO_NWORD_READ(ioAdrs, pData, nWords)                        
  236. sysInWordString (ioAdrs, pData, nWords)
  237. #endif /* ATA_IO_NWORD_READ */
  239. /* Write 16-bit little-endian `nWords' from `pData' into IO port, `ioAdrs' */
  241. #ifndef ATA_IO_NWORD_WRITE
  242. #define ATA_IO_NWORD_WRITE(ioAdrs, pData, nWords)                       
  243. sysOutWordString (ioAdrs, pData, nWords)
  244. #endif /* ATA_IO_NWORD_WRITE */
  245.     
  246. /* Read 32-bit little-endian `nLongs' into `pData' from IO port, `ioAdrs' */
  248. #ifndef ATA_IO_NLONG_READ
  249. #define ATA_IO_NLONG_READ(ioAdrs, pData, nLongs)                        
  250. sysInLongString (ioAdrs, pData, nLongs)
  251. #endif /* ATA_IO_NLONG_READ */
  253. /* Write 32-bit little-endian `nLongs' from `pData' into IO port, `ioAdrs' */
  255. #ifndef ATA_IO_NLONG_WRITE
  256. #define ATA_IO_NLONG_WRITE(ioAdrs, pData, nLongs)                       
  257. sysOutLongString (ioAdrs, pData, nLongs)
  258. #endif /* ATA_IO_NLONG_WRITE */
  260. /* Read 32-bit CPU-endian `nWords' into `pData' from IO port, `ioAdrs' */
  262. #ifndef ATA_IO_NWORD_READ_SWAP
  263. #  if (_BYTE_ORDER == _BIG_ENDIAN)
  264. #  define ATA_IO_NWORD_READ_SWAP(ioAdrs, pData, nWords)                 
  265. sysInWordStringRev (ioAdrs, pData, nWords)
  266. #  else /* (_BYTE_ORDER == _BIG_ENDIAN) */
  267. #  define ATA_IO_NWORD_READ_SWAP(ioAdrs, pData, nWords)                 
  268. ATA_IO_NWORD_READ (ioAdrs, pData, nWords)
  269. #  endif /* (_BYTE_ORDER == _BIG_ENDIAN) */
  270. #endif /* ATA_IO_NLONG_READ_SWAP */
  272. /* Delay to ensure Status Register content is valid */
  274. #define ATA_WAIT_STATUS sysDelay () /* >= 400 ns */
  276. /* definitions relating to ATAPI commands */
  278. #define ATAPI_MAX_CMD_LENGTH 12 /* maximum length in bytes of a ATAPI command */
  280. #ifdef ATA_DEBUG
  282. int ataDebugLevel = 0; /* debug verbosity level */
  283. BOOL ataIntrDebug  = 0; /* interrupt notification On */
  285. char * ataErrStrs [ ] =  /* error reason strings */
  286.     {
  287.     "Unknown Error", /*  0 */
  288.     "Wait for Command Packet request time expire", /*  1 */
  289.     "Error in Command Packet Request", /*  2 */
  290.     "Error in Command Packet Request", /*  3 */
  291.     "Wait for Data Request time expire", /*  4 */
  292.     "Data Request for NON Data command", /*  5 */
  293.     "Error in Data Request", /*  6 */
  294.     "Error in End of data transfer condition", /*  7 */
  295.     "Extra transfer request", /*  8 */
  296.     "Transfer size requested exceeds desired size", /*  9 */
  297.     "Transfer direction miscompare", /* 10 */
  298.     "No Sense", /* 11 */
  299.     "Recovered Error", /* 12 */
  300.     "Not Ready", /* 13 */
  301.     "Medium Error", /* 14 */
  302.     "Hardware Error", /* 15 */
  303.     "Illegal Request", /* 16 */
  304.     "Unit Attention", /* 17 */
  305.     "Data Protected", /* 18 */
  306.     "Aborted Command", /* 19 */
  307.     "Miscompare", /* 20 */
  308.     "", /* 21 */
  309.     "", /* 22 */
  310.     "", /* 23 */
  311.     "", /* 24 */
  312.     "", /* 25 */
  313.     "Overlapped commands are not implemented", /* 26 */
  314.     "DMA transfer is not implemented", /* 27 */
  315.     };
  317. #   define ATA_DEBUG_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6)
  318.         if ((lvl) <= ataDebugLevel)
  319.             logMsg (fmt, (int)(a1), (int)(a2), (int)(a3), (int)(a4), 
  320.                     (int)(a5), (int)(a6));
  321. #   define ATA_INTR_MSG(fmt, a1, a2, a3, a4, a5, a6)
  322.         if (ataIntrDebug)
  323.             logMsg (fmt, (int)(a1), (int)(a2), (int)(a3), (int)(a4), 
  324.                     (int)(a5), (int)(a6));
  325. #else
  326. #   define ATA_DEBUG_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6)
  327. #   define ATA_INTR_MSG(fmt, a1, a2, a3, a4, a5, a6)
  328. #endif
  330. /* typedefs */
  332. typedef struct ATAPI_CMD
  333.     {
  334.     uint8_t cmdPkt [ATAPI_MAX_CMD_LENGTH];
  335.     char * * ppBuf;
  336.     uint32_t bufLength;
  337.     t_data_dir direction;
  338.     uint32_t desiredTransferSize;
  339.     BOOL dma;
  340.     BOOL overlap;
  341.     } ATAPI_CMD;
  344. /* Special BSP INIT After ATA Reset */
  346. #ifndef SYS_ATA_INIT_RTN
  347. #define SYS_ATA_INIT_RTN(ctrl)  if (_func_sysAtaInit != NULL)    
  348.                                     {                            
  349.                                     ((*_func_sysAtaInit)(ctrl)); 
  350.                                     }
  351. #endif
  353. /* globals */
  355. BOOL   ataDrvInstalled = FALSE; /* TRUE if installed */
  356. BOOL   ataForceCHSonLBA = FALSE; /* hack, forces use of CHS params */
  358. ATA_CTRL  ataCtrl [ATA_MAX_CTRLS];
  360. /* BSP specific ATA Init/Reset routine */
  362. VOIDFUNCPTR       _func_sysAtaInit = NULL;
  365. /* locals */
  367. LOCAL int       ataRetry = 3; /* max retry count */
  369. /* Used to hold LBA information, if larger than calculated CHS value */
  371. LOCAL UINT32 ataLbaTotalSecs [ATA_MAX_CTRLS][ATA_MAX_DRIVES];
  374. /* function prototypes */
  376. LOCAL STATUS ataBlkRd (ATA_DEV *pDev, int startBlk, int nBlks, char *p);
  377. LOCAL STATUS ataBlkWrt (ATA_DEV *pDev, int startBlk, int nBlks, char *p);
  378. LOCAL STATUS ataReset (ATA_DEV *pDev);
  379. LOCAL STATUS ataStatus (ATA_DEV *pDev);
  380. LOCAL STATUS ataIoctl (ATA_DEV *pDev, int function, int arg);
  381. LOCAL STATUS ataBlkRW (ATA_DEV *pDev, int startBlk, int nBlks, char *p,
  382.  int direction);
  383. LOCAL void   ataWdog (int ctrl);
  384. LOCAL void   ataIntr (int ctrl);
  385. LOCAL STATUS ataInit (int ctrl, int dev);
  386. LOCAL void   ataWait (int ctrl, int request);
  387. LOCAL STATUS ataCmd (int ctrl, int drive, int cmd, int arg0, int arg1);
  388. LOCAL STATUS ataPread (int ctrl, int drive, void *p);
  389. LOCAL STATUS ataRW (int ctrl, int drive, int cylinder, int head, int sec, 
  390.    void *p, int nSecs, int direction);
  392. LOCAL STATUS ataPiWait     (int ctrl, int request, BOOL reset);
  393. LOCAL STATUS ataPiBlkRd     (ATA_DEV *pDev, int startBlk, int nBlks, char *pBuf);
  394. LOCAL STATUS ataPiIoctl     (ATA_DEV *pDev, int function, int arg);
  395. LOCAL STATUS ataPiReset     (ATA_DEV *pAtapiDev);
  396. LOCAL STATUS ataPiStatusChk (ATA_DEV *pDev);
  397. LOCAL STATUS ataPiInit      (int ctrl, int dev);
  398. LOCAL STATUS ataPiPread     (int ctrl, int drive, void * buffer);
  399. LOCAL STATUS ataDevIdentify (int ctrl, int dev);
  401. /*******************************************************************************
  402. *
  403. * ataStub - block device stub
  404. *
  405. * This routine serves a as stub for a block device structure's routine pointers.
  406. *
  407. * RETURNS: ERROR always.
  408. */
  410. LOCAL STATUS ataStub (void)
  411.     {
  412.     return (ERROR);
  413.     } /* ataStub */
  416. /*******************************************************************************
  417. *
  418. * ataDriveInit - initialize ATA drive
  419. *
  420. * This routine checks the drive presents, identifies its type, initializes the 
  421. * drive controller and driver control structers.
  422. *
  423. * RETURNS: OK if drive was initialized successfuly, or ERROR.
  424. */
  426. STATUS ataDriveInit
  427.     (
  428.     int ctrl,
  429.     int drive
  430.     )
  431.     {
  432.     ATA_CTRL    *pCtrl = &ataCtrl[ctrl];
  433.     ATA_DRIVE   *pDrive = &pCtrl->drive[drive];
  434.     ATA_PARAM   *pParam = &pDrive->param;
  435.     ATA_TYPE    *pType = &ataTypes[ctrl][drive];
  436.     int configType = pCtrl->configType; /* configuration type */
  438.     if (!pCtrl->installed)
  439.         return (ERROR);
  441.     if (pType->cylinders == 0)
  442.         return (ERROR); /* user specified the device as not present */
  444.     semTake (&pCtrl->muteSem, WAIT_FOREVER);
  446.     /* Identify device presence and its type */
  448.     if (ataDevIdentify (ctrl, drive) != OK)
  449.         goto driveInitExit;
  451.     /* Set Reset function according to device type */
  453.     if (pDrive->type == ATA_TYPE_ATA)
  454.         pDrive->Reset = ataInit;
  455.     else if (pDrive->type == ATA_TYPE_ATAPI)
  456.         pDrive->Reset = ataPiInit;
  458.     if (pDrive->type == ATA_TYPE_ATA)
  459.         {
  461.         if (ataPread (ctrl, drive, (char *)pParam) == OK)
  462.             {
  464.     if ((pCtrl->ctrlType == ATA_PCMCIA) ||
  465. ((pCtrl->ctrlType != ATA_PCMCIA) && (drive == 0)))
  466. {
  468.                 if (ataCmd (ctrl, drive, ATA_CMD_DIAGNOSE, 0, 0) != OK)
  469.     {
  470.             semGive (&pCtrl->muteSem);
  472.             return (ERROR);
  473.     }
  474. }
  476.             /* find out geometry */
  478.             if ((configType & ATA_GEO_MASK) == ATA_GEO_FORCE)
  479.                 {
  480.                 (void) ataCmd (ctrl, drive, ATA_CMD_INITP, 0, 0);
  481.                 (void) ataPread (ctrl, drive, (char *)pParam);
  482.                 }
  483.             else if ((configType & ATA_GEO_MASK) == ATA_GEO_PHYSICAL)
  484.                 {
  485.                 pType->cylinders = pParam->cylinders - 1;
  486.                 pType->heads     = pParam->heads;
  487.                 pType->sectors   = pParam->sectors;
  488.                 }
  489.             else if ((configType & ATA_GEO_MASK) == ATA_GEO_CURRENT)
  490.                 {
  492.                 if ((pParam->currentCylinders != 0) &&
  493.                     (pParam->currentHeads != 0) &&
  494.                     (pParam->currentSectors != 0))
  495.                     {
  496.                     pType->cylinders = pParam->currentCylinders - 1;
  497.                     pType->heads     = pParam->currentHeads;
  498.                     pType->sectors   = pParam->currentSectors;
  499.                     }
  500.                 else
  501.                     {
  502.                     pType->cylinders = pParam->cylinders - 1;
  503.                     pType->heads     = pParam->heads;
  504.                     pType->sectors   = pParam->sectors;
  505.                     }
  506.                 }
  508.             /* 
  509.              * Not all modern hard drives report a true capacity value 
  510.              * in their IDENTIFY DEVICE CHS fields.
  511.              * For example, a Western Digital 20 Gb drive reports 
  512.              * its CHS as 16383 cylinders, 16 heads, and 63 spt.
  513.              * This is about 8.4GB, but the LBA sectors is reported
  514.              * as 0x02607780, which is closer to 20Gb, the true capacity
  515.              * of the drive.  The reason for this is PC BIOS can have a 
  516.              * 8.4GB limitation, and drive manufacturers have broken the 
  517.              * ATA specification to be compatable.  Negative competition. 
  518.              * Note that the ATA specifications original limit is 
  519.              * about 136.9 Gb, however when combinined with a PC BIOS 
  520.              * interface, a 8.4 Gb limit is produced.    
  521.              * VxWorks does not have such limitations being a true 32bit OS,
  522.              * but since the drive manufactures are not honoring the CHS
  523.              * values, we have to allow for devices that demand "pure" LBA
  524.              * and present incorrect CHS.
  525.              * If the drive supports Logical Block Addresses (LBA)
  526.              * then we need to check the field located at 16bit words 60 & 61,
  527.              * "Total number of user addressable sectors (LBA mode only)". 
  528.              * If this value is greater than the CHS fields report, 
  529.              * then 60-61 holds the true size of the disk and that 
  530.              * will be reported to the block device interface.
  531.              * Note that the CHS values are still left as the disk reported.
  532.              * This is tracked at WRS as SPR#22830
  533.              */
  535.             if (pParam->capabilities & 0x0200)  /* if (drive supports LBA) */
  536.                 {
  537.                 ataLbaTotalSecs[ctrl][drive] =  (UINT32) 
  538. ((((UINT32) ((pParam->sectors0) & 0x0000ffff)) <<  0) | 
  539.  (((UINT32) ((pParam->sectors1) & 0x0000ffff)) << 16));
  541.                 ATA_DEBUG_MSG (1, "ID_DRIVE reports LBA (60-61) as 0x%08lxn",
  542.                                ataLbaTotalSecs[ctrl][drive], 0, 0, 0, 0, 0);
  543.                 }
  545.             /*
  546.              * reinitialize the controller with parameters read from the
  547.              * controller.
  548.              */
  550.             (void) ataCmd (ctrl, drive, ATA_CMD_INITP, 0, 0);
  552.             /* recalibrate (this command !!! is absent in ATA-4) */
  554.             (void) ataCmd (ctrl, drive, ATA_CMD_RECALIB, 0, 0);
  555.             }
  556.         else
  557.             {
  558.             pDrive->state = ATA_DEV_PREAD_F;
  559.             goto driveInitExit;
  560.             }
  561.         }
  562.     else if (pDrive->type == ATA_TYPE_ATAPI)
  563.         {
  564.         /* Although ATAPI device parameters have been read by ataDevIdentify(), 
  565.          * execute ATAPI Identify Device command to allow ATA commands 
  566.          * acceptance by an ATAPI device after Diagnostic or Reset commands. 
  567.          */
  569.         if (ataPiPread (ctrl, drive, pParam) != OK)
  570.             {
  571.             pDrive->state = ATA_DEV_PREAD_F;
  573.             goto driveInitExit;
  574.             }
  575.         }
  577.     /* find out supported capabilities of the drive */
  579.     pDrive->multiSecs = pParam->multiSecs & 0x00ff;
  580.     pDrive->okMulti   = (pDrive->multiSecs != 0) ? TRUE : FALSE;
  581.     pDrive->okIordy   = (pParam->capabilities & 0x0800) ? TRUE : FALSE;
  582.     pDrive->okLba     = (pParam->capabilities & 0x0200) ? TRUE : FALSE;
  583.     pDrive->okDma     = (pParam->capabilities & 0x0100) ? TRUE : FALSE;
  585.     /* find out supported max PIO mode */
  587.     pDrive->pioMode = (pParam->pioMode >> 8) & 0x03; /* PIO 0,1,2 */
  589.     if (pDrive->pioMode > 2)
  590.         pDrive->pioMode = 0;
  592.     if ((pDrive->okIordy) && (pParam->valid & 0x02)) /* PIO 3,4 */
  593.         {
  595.         if (pParam->advancedPio & 0x01)
  596.             pDrive->pioMode = 3;
  598.         if (pParam->advancedPio & 0x02)
  599.             pDrive->pioMode = 4;
  600.         }
  602.     /* find out supported max DMA mode */
  604.     if ((pDrive->okDma) && (pParam->valid & 0x02))
  605.         {
  606.         pDrive->singleDmaMode = (pParam->dmaMode >> 8) & 0x03;
  608.         if (pDrive->singleDmaMode >= 2)
  609.             pDrive->singleDmaMode = 0;
  611.         pDrive->multiDmaMode  = 0;
  613.         if (pParam->singleDma & 0x04)
  614.             pDrive->singleDmaMode = 2;
  615.         else if (pParam->singleDma & 0x02)
  616.             pDrive->singleDmaMode = 1;
  617.         else if (pParam->singleDma & 0x01)
  618.             pDrive->singleDmaMode = 0;
  620.         if (pParam->multiDma & 0x04)
  621.             pDrive->multiDmaMode = 2;
  622.         else if (pParam->multiDma & 0x02)
  623.             pDrive->multiDmaMode = 1;
  624.         else if (pParam->multiDma & 0x01)
  625.             pDrive->multiDmaMode = 0;
  626.         }
  628.     /* find out transfer mode to use */
  630.     pDrive->rwBits = configType & ATA_BITS_MASK;
  631.     pDrive->rwPio  = configType & ATA_PIO_MASK;
  632.     pDrive->rwDma  = configType & ATA_DMA_MASK;
  633.     pDrive->rwMode = ATA_PIO_DEF_W;
  635.     switch (configType & ATA_MODE_MASK)
  636.         {
  637.         case ATA_PIO_0:
  638.         case ATA_PIO_1:
  639.         case ATA_PIO_2:
  640.         case ATA_PIO_3:
  641.         case ATA_PIO_4:
  642.         case ATA_PIO_DEF_0:
  643.         case ATA_PIO_DEF_1:
  644.             pDrive->rwMode = configType & ATA_MODE_MASK;
  645.             break;
  647.         case ATA_PIO_AUTO:
  648.             pDrive->rwMode = ATA_PIO_W_0 + pDrive->pioMode;
  649.             break;
  651.         case ATA_DMA_0:
  652.         case ATA_DMA_1:
  653.         case ATA_DMA_2:
  655.             if (pDrive->okDma)
  656.                 {
  658.                 if (pDrive->rwDma == ATA_DMA_SINGLE)
  659.                     pDrive->rwMode |= ATA_DMA_SINGLE_0;
  661.                 if (pDrive->rwDma == ATA_DMA_MULTI)
  662.                     pDrive->rwMode |= ATA_DMA_MULTI_0;
  663.                 }
  664.             break;
  666.         case ATA_DMA_AUTO:
  668.             if (pDrive->okDma)
  669.                 {
  671.                 if (pDrive->rwDma == ATA_DMA_SINGLE)
  672.                     pDrive->rwMode = ATA_DMA_SINGLE_0 + 
  673.                                      pDrive->singleDmaMode;
  675.                 if (pDrive->rwDma == ATA_DMA_MULTI)
  676.                     pDrive->rwMode = ATA_DMA_MULTI_0 + 
  677.                                      pDrive->multiDmaMode;
  678.                 }
  679.             break;
  681.         default:
  682.             break;
  684.         }
  686.     /* Set the transfer mode */
  688.     (void) ataCmd (ctrl, drive, ATA_CMD_SET_FEATURE, ATA_SUB_SET_RWMODE,
  689.                    pDrive->rwMode);
  691.     /* Disable reverting to power on defaults */
  693.     (void) ataCmd (ctrl, drive, ATA_CMD_SET_FEATURE, ATA_SUB_DISABLE_REVE, 0);
  695.     /* Set multiple mode (multisector read/write) */
  697.     if ((pDrive->rwPio == ATA_PIO_MULTI) && (pDrive->type == ATA_TYPE_ATA))
  698.         {
  700.         if (pDrive->okMulti)
  701.             (void) ataCmd (ctrl, drive, ATA_CMD_SET_MULTI,
  702.                            pDrive->multiSecs, 0);
  703.         else
  704.             pDrive->rwPio = ATA_PIO_SINGLE;
  705.         }
  707.     pDrive->state = ATA_DEV_OK;
  709. driveInitExit:
  711.     semGive (&pCtrl->muteSem);
  713.     if (pDrive->state != ATA_DEV_OK)
  714.         {
  715.         ATA_DEBUG_MSG (1, "ataDriveInit%d/%d: ERROR: state=%d dev=0x%x "
  716.                        "status=0x%x error=0x%xn", ctrl, drive, pDrive->state, 
  717.                        ATA_IO_BYTE_READ (pCtrl->sdh), 
  718.                        ATA_IO_BYTE_READ (pCtrl->status), 
  719.                        ATA_IO_BYTE_READ (pCtrl->error));
  720.         return (ERROR);
  721.         }
  723.     return (OK);
  724.     } /* ataDriveInit */
  726. /*******************************************************************************
  727. *
  728. * ataDrv - initialize the ATA driver
  729. *
  730. * This routine initializes the ATA/IDE/ATAPI CDROM driver, sets up interrupt
  731. * vectors, and performs hardware initialization of the ATA/IDE chip.
  732. *
  733. * This routine must be called exactly once, before any reads, writes,
  734. * or calls to ataDevCreate().  Normally, it is called by usrRoot()
  735. * in usrConfig.c.
  736. *
  737. * RETURNS: OK, or ERROR if initialization fails.
  738. *
  739. * SEE ALSO: ataDevCreate()
  740. */
  742. STATUS ataDrv
  743.     (
  744.     int  ctrl, /* controller no. */
  745.     int  drives, /* number of drives */
  746.     int  vector, /* interrupt vector */
  747.     int  level, /* interrupt level */
  748.     int  configType, /* configuration type */
  749.     int  semTimeout, /* timeout seconds for sync semaphore */
  750.     int  wdgTimeout /* timeout seconds for watch dog */
  751.     )
  752.     {
  753.     ATA_CTRL        *pCtrl = &ataCtrl[ctrl];
  754.     ATA_RESOURCE    *pAta = &ataResources[ctrl];
  755.     PCCARD_RESOURCE *pResource = &pAta->resource;
  756.     ATA_DRIVE       *pDrive;
  757.     ATA_PARAM       *pParam;
  758.     ATA_TYPE        *pType;
  759.     int             drive;
  760.     int             ix;
  762.     if ((ctrl >= ATA_MAX_CTRLS) || (drives > ATA_MAX_DRIVES))
  763. return (ERROR);
  765.     if (!ataDrvInstalled)
  766. {
  768. for (ix = 0; ix < ATA_MAX_CTRLS; ix++)
  769.             ataCtrl[ix].wdgId = wdCreate ();
  771.      ataDrvInstalled = TRUE;
  772. }
  774.     if (!pCtrl->installed)
  775. {
  777. if (semTimeout == 0)
  778.     pCtrl->semTimeout = ATA_SEM_TIMEOUT_DEF;
  779. else
  780.     pCtrl->semTimeout = semTimeout;
  782. if (wdgTimeout == 0)
  783.     pCtrl->wdgTimeout = ATA_WDG_TIMEOUT_DEF;
  784. else
  785.     pCtrl->wdgTimeout = wdgTimeout;
  787.         semBInit (&pCtrl->syncSem, SEM_Q_FIFO, SEM_EMPTY);
  788.         semMInit (&pCtrl->muteSem, SEM_Q_PRIORITY | SEM_DELETE_SAFE |
  789.           SEM_INVERSION_SAFE);
  791. pCtrl->data = ATA_DATA (pResource->ioStart[0]);
  792. pCtrl->error = ATA_ERROR (pResource->ioStart[0]);
  793. pCtrl->feature = ATA_FEATURE (pResource->ioStart[0]);
  794. pCtrl->seccnt = ATA_SECCNT (pResource->ioStart[0]);
  795. pCtrl->sector = ATA_SECTOR (pResource->ioStart[0]);
  796. pCtrl->cylLo = ATA_CYL_LO (pResource->ioStart[0]);
  797. pCtrl->cylHi = ATA_CYL_HI (pResource->ioStart[0]);
  798. pCtrl->sdh = ATA_SDH (pResource->ioStart[0]);
  799. pCtrl->command = ATA_COMMAND (pResource->ioStart[0]);
  800. pCtrl->status = ATA_STATUS (pResource->ioStart[0]);
  801. pCtrl->aStatus = ATA_A_STATUS (pResource->ioStart[1]);
  802. pCtrl->dControl = ATA_D_CONTROL (pResource->ioStart[1]);
  803. pCtrl->dAddress = ATA_D_ADDRESS (pResource->ioStart[1]);
  805.         (void) intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (vector),
  806.            (VOIDFUNCPTR)ataIntr, ctrl);
  807.         sysIntEnablePIC (level); /* unmask the interrupt level */
  808. pCtrl->intLevel = level;
  809. pCtrl->wdgOkay  = TRUE;
  810. pCtrl->configType = configType;
  812. semTake (&pCtrl->muteSem, WAIT_FOREVER);
  814. pCtrl->installed = TRUE;
  816.         for (drive = 0; drive < drives; drive++)
  817.     {
  818.     pType  = &ataTypes[ctrl][drive];
  819.     pDrive = &pCtrl->drive[drive];
  820.     pParam = &pDrive->param;
  821.             pDrive->state = ATA_DEV_INIT;
  822.             pDrive->type = ATA_TYPE_INIT;
  823.             pDrive->diagCode = 0;
  824.             pDrive->Reset = ataInit;
  826.             ataDriveInit (ctrl, drive);
  827.             }
  829.         ATA_DEBUG_MSG (1, "ataDrv Calling sysAtaInit (if present):n",
  830.                       0, 0, 0, 0, 0, 0);
  831.  
  832. /* Call system INIT routine to allow proper PIO mode setup */
  834.         SYS_ATA_INIT_RTN (ctrl);
  835.  
  836.         ATA_DEBUG_MSG (1, "ataDrv sysAtaInit returned:n",
  837.                       0, 0, 0, 0, 0, 0);
  839. semGive (&pCtrl->muteSem);
  840. }
  842.     return (OK);
  843.     }
  845. /*******************************************************************************
  846. *
  847. * ataDevCreate - create a device for a ATA/IDE disk
  848. *
  849. * This routine creates a device for a specified ATA/IDE or ATAPI CDROM disk.
  850. *
  851. * <ctrl> is a controller number for the ATA controller; the primary controller
  852. * is 0.  The maximum is specified via ATA_MAX_CTRLS.
  853. *
  854. * <drive> is the drive number for the ATA hard drive; the master drive
  855. * is 0.  The maximum is specified via ATA_MAX_DRIVES.
  856. *
  857. * The <nBlocks> parameter specifies the size of the device in blocks.
  858. * If <nBlocks> is zero, the whole disk is used.
  859. *
  860. * The <blkOffset> parameter specifies an offset, in blocks, from the start
  861. * of the device to be used when writing or reading the hard disk.  This
  862. * offset is added to the block numbers passed by the file system during
  863. * disk accesses.  (VxWorks file systems always use block numbers beginning
  864. * at zero for the start of a device.)
  865. *
  866. *
  867. * RETURNS:
  868. * A pointer to a block device structure (BLK_DEV) or NULL if memory cannot
  869. * be allocated for the device structure.
  870. *
  871. * SEE ALSO: dosFsMkfs(), dosFsDevInit(), rt11FsDevInit(), rt11FsMkfs(),
  872. * rawFsDevInit()
  873. */
  875. BLK_DEV *ataDevCreate
  876.     (
  877.     int ctrl,     /* ATA controller number, 0 is the primary controller */
  878.     int drive,    /* ATA drive number, 0 is the master drive */
  879.     int nBlocks,  /* number of blocks on device, 0 = use entire disc */
  880.     int blkOffset /* offset BLK_DEV nBlocks from the start of the drive */
  881.     )
  882.     {
  883.     ATA_CTRL  *pCtrl = &ataCtrl[ctrl];
  884.     ATA_TYPE  *pType = &ataTypes[ctrl][drive];
  885.     ATA_DRIVE *pDrive = &pCtrl->drive[drive];
  886.     ATA_PARAM *pParam = &pDrive->param; /* move * */
  887.     ATA_DEV   *pDev;
  888.     BLK_DEV   *pBlkdev;
  889.     int       maxBlks;
  891.     if ((ctrl >= ATA_MAX_CTRLS) || (drive >= ATA_MAX_DRIVES) ||
  892.         !ataDrvInstalled || !pCtrl->installed)
  893. return (NULL);
  895.     if ((pDev = (ATA_DEV *)malloc(sizeof (ATA_DEV))) == NULL)
  896. return (NULL);
  898.     pBlkdev = &pDev->blkDev;
  900.     if ((pDrive->state == ATA_DEV_OK) || (pDrive->state == ATA_DEV_MED_CH))
  901.         {
  902.         pDrive->state = ATA_DEV_MED_CH;
  904.         if (pDrive->type == ATA_TYPE_ATA)
  905.             {
  907.     /* 
  908.      * if LBA is supported and ataLbaTotalSecs is not zero
  909.      * and ataLbaTotalSecs is greater than the product of
  910.      * CHS, then we should use the LBA value.
  911.      */
  913.             if ((pDrive->okLba == TRUE)                     && 
  914. (ataLbaTotalSecs[ctrl][drive] != 0)         &&
  915. (ataForceCHSonLBA != TRUE)     &&
  916. (ataLbaTotalSecs[ctrl][drive] > 
  917.  (pType->cylinders * pType->heads * pType->sectors)))   
  918.         {
  919. maxBlks = (ataLbaTotalSecs[ctrl][drive]) - blkOffset;
  920. }
  921.     else /* just use CHS */
  922.         {
  923. maxBlks = ((pType->cylinders * pType->heads * pType->sectors) 
  924.    - blkOffset);
  925. }
  927.     if (nBlocks == 0)
  928.         nBlocks = maxBlks;
  929.     
  930.     if (nBlocks > maxBlks)
  931.         nBlocks = maxBlks;
  933.     pBlkdev->bd_nBlocks = nBlocks;
  934.     pBlkdev->bd_bytesPerBlk = pType->bytes;
  935.     pBlkdev->bd_blksPerTrack = pType->sectors;
  936.     pBlkdev->bd_nHeads = pType->heads;
  937.     pBlkdev->bd_removable = TRUE;
  938.     pBlkdev->bd_retry = 1;
  939.     pBlkdev->bd_mode = O_RDWR;
  940.     pBlkdev->bd_readyChanged = TRUE;
  941.     pBlkdev->bd_blkRd = ataBlkRd;
  942.     pBlkdev->bd_blkWrt = ataBlkWrt;
  943.     pBlkdev->bd_ioctl = ataIoctl;
  944.     pBlkdev->bd_reset = ataReset;
  945.     pBlkdev->bd_statusChk = ataStatus;
  946.     pBlkdev->bd_reset = NULL;
  947.     pBlkdev->bd_statusChk = NULL;
  948.     pDev->ctrl = ctrl;
  949.     pDev->drive = drive;
  950.     pDev->blkOffset = blkOffset;
  951.     }
  952.         else if (pDrive->type == ATA_TYPE_ATAPI)
  953.             {
  954.             pBlkdev->bd_nBlocks         = 100;
  955.             pBlkdev->bd_bytesPerBlk     = 2048;
  956.             pBlkdev->bd_blksPerTrack    = pBlkdev->bd_nBlocks;
  957.             pBlkdev->bd_nHeads          = 1;
  959.             if (pParam->config & CONFIG_REMOVABLE)
  960.                 pBlkdev->bd_removable   = TRUE;
  961.             else
  962.                 pBlkdev->bd_removable   = FALSE;
  964.             pBlkdev->bd_retry           = 1;
  965.             pBlkdev->bd_mode            = O_RDONLY;
  966.             pBlkdev->bd_readyChanged    = TRUE;
  967.             pBlkdev->bd_blkRd           = ataPiBlkRd;
  968.             pBlkdev->bd_blkWrt          = ataStub;
  969.             pBlkdev->bd_ioctl           = ataPiIoctl;
  970.             pBlkdev->bd_reset           = ataPiReset;
  971.             pBlkdev->bd_statusChk       = ataPiStatusChk;
  973.     pDev->ctrl         = ctrl;
  974.     pDev->drive         = drive;
  975.     pDev->blkOffset         = blkOffset;
  976.             pDev->nBlocks               = nBlocks;
  978.     }
  980.         ataDriveInit (ctrl, drive);
  982.         pDrive->state = ATA_DEV_OK;
  983. }
  985.     return (&pDev->blkDev);
  986.     }
  988. /*******************************************************************************
  989. *
  990. * ataRawio - do raw I/O access
  991. *
  992. * This routine is called to perform raw I/O access.
  993. *
  994. * <drive> is a drive number for the hard drive: it must be 0 or 1.
  995. *
  996. * The <pAtaRaw> is a pointer to the structure ATA_RAW which is defined in 
  997. * ataDrv.h.
  998. *
  999. * RETURNS:
  1000. * OK, or ERROR if the parameters are not valid.
  1001. *
  1002. */
  1004. STATUS ataRawio
  1005.     (
  1006.     int      ctrl,
  1007.     int      drive,
  1008.     ATA_RAW  *pAtaRaw
  1009.     )
  1010.     {
  1011.     ATA_CTRL  *pCtrl = &ataCtrl[ctrl];
  1012.     ATA_DRIVE *pDrive = &pCtrl->drive[drive];
  1013.     ATA_TYPE  *pType = &ataTypes[ctrl][drive];
  1014.     ATA_DEV   ataDev;
  1015.     BLK_DEV   *pBlkdev = &ataDev.blkDev;
  1016.     UINT      startBlk;
  1018.     if ((ctrl >= ATA_MAX_CTRLS) || (drive >= ATA_MAX_DRIVES) ||
  1019.         !ataDrvInstalled || !pCtrl->installed)
  1020. return (ERROR);
  1022.     if ((pAtaRaw->cylinder >= pType->cylinders) ||
  1023.         (pAtaRaw->head >= pType->heads) ||
  1024.         (pAtaRaw->sector >  pType->sectors) ||
  1025.         (pAtaRaw->sector == 0))
  1026. return (ERROR);
  1028.     /*
  1029.      * if LBA is supported and ataLbaTotalSecs is not zero
  1030.      * and ataLbaTotalSecs is greater than the product of
  1031.      * CHS, then we should use the LBA value.
  1032.      */
  1034.     if ((pDrive->okLba == TRUE)                     && 
  1035.     (ataLbaTotalSecs[ctrl][drive] != 0)         &&
  1036. (ataForceCHSonLBA != TRUE)     &&
  1037. (ataLbaTotalSecs[ctrl][drive] > 
  1038. (pType->cylinders * pType->heads * pType->sectors)))   
  1039. {
  1040. pBlkdev->bd_nBlocks = ataLbaTotalSecs[ctrl][drive];
  1041. }
  1042.     else /* just use CHS value */
  1043. {
  1044.         pBlkdev->bd_nBlocks = pType->cylinders * pType->heads * 
  1045.   pType->sectors;
  1046. }
  1048.     pBlkdev->bd_bytesPerBlk = pType->bytes;
  1049.     pBlkdev->bd_blksPerTrack = pType->sectors;
  1050.     pBlkdev->bd_nHeads = pType->heads;
  1051.     pBlkdev->bd_removable = FALSE;
  1052.     pBlkdev->bd_retry = 1;
  1053.     pBlkdev->bd_mode = O_RDWR;
  1054.     pBlkdev->bd_readyChanged = TRUE;
  1055.     pBlkdev->bd_blkRd = ataBlkRd;
  1056.     pBlkdev->bd_blkWrt = ataBlkWrt;
  1057.     pBlkdev->bd_ioctl = ataIoctl;
  1058.     pBlkdev->bd_reset = ataReset;
  1059.     pBlkdev->bd_statusChk = ataStatus;
  1061.     ataDev.ctrl = ctrl;
  1062.     ataDev.drive = drive;
  1063.     ataDev.blkOffset = 0;
  1065.     startBlk = pAtaRaw->cylinder * (pType->sectors * pType->heads) +
  1066.        pAtaRaw->head * pType->sectors + pAtaRaw->sector - 1;
  1068.     return (ataBlkRW (&ataDev, startBlk, pAtaRaw->nSecs, pAtaRaw->pBuf,
  1069.      pAtaRaw->direction));
  1070.     }
  1072. /*******************************************************************************
  1073. *
  1074. * ataBlkRd - read one or more blocks from a ATA/IDE disk
  1075. *
  1076. * This routine reads one or more blocks from the specified device,
  1077. * starting with the specified block number.
  1078. *
  1079. * If any block offset was specified during ataDevCreate(), it is added
  1080. * to <startBlk> before the transfer takes place.
  1081. *
  1082. * RETURNS: OK, ERROR if the read command didn't succeed.
  1083. */
  1085. LOCAL STATUS ataBlkRd
  1086.     (
  1087.     ATA_DEV *pDev,
  1088.     int     startBlk,
  1089.     int     nBlks,
  1090.     char    *pBuf
  1091.     )
  1092.     {
  1093.     return (ataBlkRW (pDev, startBlk, nBlks, pBuf, O_RDONLY));
  1094.     }
  1096. /*******************************************************************************
  1097. *
  1098. * ataBlkWrt - write one or more blocks to a ATA/IDE disk
  1099. *
  1100. * This routine writes one or more blocks to the specified device,
  1101. * starting with the specified block number.
  1102. *
  1103. * If any block offset was specified during ataDevCreate(), it is added
  1104. * to <startBlk> before the transfer takes place.
  1105. *
  1106. * RETURNS: OK, ERROR if the write command didn't succeed.
  1107. */
  1109. LOCAL STATUS ataBlkWrt
  1110.     (
  1111.     ATA_DEV *pDev,
  1112.     int     startBlk,
  1113.     int     nBlks,
  1114.     char    *pBuf
  1115.     )
  1116.     {
  1117.     return (ataBlkRW (pDev, startBlk, nBlks, pBuf, O_WRONLY));
  1118.     }
  1120. /*******************************************************************************
  1121. *
  1122. * ataReset - reset a ATA/IDE disk controller
  1123. *
  1124. * This routine resets a ATA/IDE disk controller.
  1125. *
  1126. * RETURNS: OK, always.
  1127. */
  1129. LOCAL STATUS ataReset
  1130.     (
  1131.     ATA_DEV  *pDev
  1132.     )
  1133.     {
  1134.     ATA_CTRL *pCtrl = &ataCtrl[pDev->ctrl];
  1135.     
  1136.     if (!pCtrl->installed)
  1137. return (ERROR);
  1139.     semTake (&pCtrl->muteSem, WAIT_FOREVER);
  1141.     (void) ataInit (pDev->ctrl, 0);
  1143.     semGive (&pCtrl->muteSem);
  1145.     return (OK);
  1146.     }
  1148. /*******************************************************************************
  1149. *
  1150. * ataStatus - check status of a ATA/IDE disk controller
  1151. *
  1152. * This routine check status of a ATA/IDE disk controller.
  1153. *
  1154. * RETURNS: OK, ERROR if the card is removed.
  1155. */
  1157. LOCAL STATUS ataStatus
  1158.     (
  1159.     ATA_DEV  *pDev
  1160.     )
  1161.     {
  1162.     ATA_CTRL *pCtrl = &ataCtrl[pDev->ctrl];
  1163.     BLK_DEV  *pBlkdev = &pDev->blkDev;
  1164.     
  1165.     if (!pCtrl->installed)
  1166. return (ERROR);
  1168.     if (pCtrl->changed)
  1169. {
  1170. pBlkdev->bd_readyChanged = TRUE;
  1171. pCtrl->changed  = FALSE;
  1172. }
  1174.     return (OK);
  1175.     }
  1177. /*******************************************************************************
  1178. *
  1179. * ataIoctl - do device specific control function
  1180. *
  1181. * This routine is called when the file system cannot handle an ioctl()
  1182. * function.
  1183. *
  1184. * RETURNS:  OK or ERROR.
  1185. */
  1187. LOCAL STATUS ataIoctl
  1188.     (
  1189.     ATA_DEV  *pDev,
  1190.     int      function,
  1191.     int      arg
  1192.     )
  1193.     {
  1194.     ATA_CTRL *pCtrl = &ataCtrl[pDev->ctrl];
  1195.     FAST int status = ERROR;
  1197.     if (!pCtrl->installed)
  1198.         return (ERROR);
  1200.     semTake (&pCtrl->muteSem, WAIT_FOREVER);
  1202.     switch (function)
  1203. {
  1204. case FIODISKFORMAT:
  1205.     (void) errnoSet (S_ioLib_UNKNOWN_REQUEST);
  1206.     break;
  1208. default:
  1209.     (void) errnoSet (S_ioLib_UNKNOWN_REQUEST);
  1210. }
  1212.     semGive (&pCtrl->muteSem);
  1214.     return (status);
  1215.     }
  1217. /*******************************************************************************
  1218. *
  1219. * ataBlkRW - read or write sectors to a ATA/IDE disk.
  1220. *
  1221. * Read or write sectors to a ATA/IDE disk.
  1222. *
  1223. * RETURNS: OK, ERROR if the command didn't succeed.
  1224. */
  1226. LOCAL STATUS ataBlkRW
  1227.     (
  1228.     ATA_DEV *pDev,
  1229.     int     startBlk,
  1230.     int     nBlks,
  1231.     char    *pBuf,
  1232.     int     direction
  1233.     )
  1234.     {
  1235.     ATA_CTRL  *pCtrl = &ataCtrl[pDev->ctrl];
  1236.     ATA_DRIVE *pDrive = &pCtrl->drive[pDev->drive];
  1237.     BLK_DEV   *pBlkdev = &pDev->blkDev;
  1238.     ATA_TYPE  *pType = &ataTypes[pDev->ctrl][pDev->drive];
  1239.     int       status = ERROR;
  1240.     int       retryRW0 = 0;
  1241.     int       retryRW1 = 0;
  1242.     int       retrySeek = 0;
  1243.     int       cylinder;
  1244.     int       head;
  1245.     int       sector;
  1246.     int       nSecs;
  1247.     int       ix;
  1249.     /* sanity check */
  1251.     if (!pCtrl->installed)
  1252.         return (ERROR);
  1254.     nSecs = pBlkdev->bd_nBlocks;
  1256.     if ((startBlk + nBlks) > nSecs)
  1257. {
  1258. ATA_DEBUG_MSG (1, "startBlk=%d nBlks=%d: 0 - %dn", startBlk, nBlks, 
  1259.                        nSecs, 0, 0, 0);
  1261. return (ERROR);
  1262. }
  1264.     startBlk += pDev->blkOffset;
  1266.     semTake (&pCtrl->muteSem, WAIT_FOREVER);
  1268.     for (ix = 0; ix < nBlks; ix += nSecs)
  1269. {
  1271. if (pDrive->okLba)
  1272.     {
  1273.     head     = (startBlk & 0x0f000000) >> 24;
  1274.     cylinder = (startBlk & 0x00ffff00) >> 8;
  1275.     sector   = (startBlk & 0x000000ff);
  1276.     }
  1277. else
  1278.     {
  1279.     cylinder = startBlk / (pType->sectors * pType->heads);
  1280.     sector   = startBlk % (pType->sectors * pType->heads);
  1281.     head     = sector / pType->sectors;
  1282.     sector   = sector % pType->sectors + 1;
  1283.     }
  1284. nSecs    = min (nBlks - ix, ATA_MAX_RW_SECTORS);
  1286. retryRW1 = 0;
  1287. retryRW0 = 0;
  1289. while (ataRW(pDev->ctrl, pDev->drive, cylinder, head, sector, 
  1290.        pBuf, nSecs, direction) != OK)
  1291.     {
  1293.     if (++retryRW0 > ataRetry)
  1294. {
  1295.         (void)ataCmd (pDev->ctrl, pDev->drive, ATA_CMD_RECALIB, 0, 0);
  1297.         if (++retryRW1 > ataRetry)
  1298.     goto done;
  1300.         retrySeek = 0;
  1302.         while (ataCmd (pDev->ctrl, pDev->drive, ATA_CMD_SEEK, cylinder,
  1303.        head) != OK)
  1305.             if (++retrySeek > ataRetry)
  1306.         goto done;
  1308.         retryRW0 = 0;
  1309. }
  1310.     }
  1312.         startBlk += nSecs;
  1313.         pBuf += pBlkdev->bd_bytesPerBlk * nSecs;
  1314. }
  1316.     status = OK;
  1318. done:
  1320.     if (status == ERROR)
  1321.         (void)errnoSet (S_ioLib_DEVICE_ERROR);
  1323.     semGive (&pCtrl->muteSem);
  1325.     return (status);
  1326.     }
  1328. /*******************************************************************************
  1329. *
  1330. * ataIntr - ATA/IDE controller interrupt handler.
  1331. *
  1332. * RETURNS: N/A
  1333. */
  1335. LOCAL void ataIntr
  1336.     (
  1337.     int ctrl
  1338.     )
  1339.     {
  1340.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1342.     pCtrl->intCount++;
  1343.     pCtrl->intStatus = ATA_IO_BYTE_READ (pCtrl->status);
  1344.     semGive (&pCtrl->syncSem);
  1345.     }
  1347. /*******************************************************************************
  1348. *
  1349. * ataWdog - ATA/IDE controller watchdog handler.
  1350. *
  1351. * RETURNS: N/A
  1352. */
  1354. LOCAL void ataWdog
  1355.     (
  1356.     int ctrl
  1357.     )
  1358.     {
  1359.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1361.     pCtrl->wdgOkay = FALSE;
  1362.     }
  1364. /*******************************************************************************
  1365. *
  1366. * ataWait - wait the ATA/ATAPI drive ready
  1367. *
  1368. * Wait the drive ready
  1369. *
  1370. * RETURNS: OK, ERROR if the drive didn't become ready in certain period of time.
  1371. */
  1373. LOCAL void ataWait
  1374.     (
  1375.     int ctrl,
  1376.     int request
  1377.     )
  1378.     {
  1379.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1381.     ATA_DEBUG_MSG (3, "ataWait: ctrl=%d  request=0x%xn", ctrl, request,
  1382.                   0, 0, 0, 0);
  1384.     switch (request)
  1385. {
  1386. case ATA_STAT_READY:
  1387.     wdStart (pCtrl->wdgId, (sysClkRateGet() * pCtrl->wdgTimeout), 
  1388.      (FUNCPTR)ataWdog, ctrl);
  1390.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY) && 
  1391.    (pCtrl->wdgOkay))
  1392.         ;
  1394.             while (((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_READY) == 0)
  1395.                    && (pCtrl->wdgOkay))
  1396.         ;
  1398.     wdCancel (pCtrl->wdgId);
  1400.             if (!pCtrl->wdgOkay)
  1401.         {
  1402.         pCtrl->wdgOkay = TRUE;
  1403.         (void) ataInit (ctrl, 0);
  1404.         }
  1406.     break;
  1408. case ATA_STAT_BUSY:
  1410.             while (ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY)
  1411. ;
  1413.     break;
  1415. case ATA_STAT_DRQ:
  1417.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_DRQ) == 0)
  1418.         ;
  1420.     break;
  1422. case ATA_STAT_SEEKCMPLT:
  1424.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_SEEKCMPLT) == 0)
  1425.         ;
  1427.     break;
  1428. }
  1430.     ATA_DEBUG_MSG (3, "ataWait end:n", 0, 0, 0, 0, 0, 0);
  1431.     }
  1433. /*******************************************************************************
  1434. *
  1435. * ataPiWait - wait the ATAPI drive ready
  1436. *
  1437. * Wait the drive ready
  1438. *
  1439. * RETURNS: OK, ERROR if the drive didn't become ready in certain period of time.
  1440. */
  1442. LOCAL STATUS ataPiWait
  1443.     (
  1444.     int  ctrl,
  1445.     int  request,
  1446.     BOOL reset
  1447.     )
  1448.     {
  1449.     ATA_CTRL    *pCtrl = &ataCtrl[ctrl]; 
  1450.     ATA_DRIVE   *pDrive;
  1451.     int drive;
  1453.     ATA_DEBUG_MSG (3, "ataPiWait: ctrl=%d  request=0x%xn", ctrl, request,
  1454.                    0, 0, 0, 0);
  1456.     drive = (ATA_IO_BYTE_READ (pCtrl->sdh) >> 4) & 1;
  1458.     pDrive = &pCtrl->drive[drive];
  1460.     switch (request)
  1461. {
  1462. case ATA_STAT_READY:
  1463.     wdStart (pCtrl->wdgId, (sysClkRateGet() * pCtrl->wdgTimeout), 
  1464.      (FUNCPTR)ataWdog, ctrl);
  1466.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY) && 
  1467.    (pCtrl->wdgOkay))
  1468.         ;
  1470.             while (((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_READY) == 0)
  1471.                    && (pCtrl->wdgOkay))
  1472.         ;
  1474.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_DRQ) &&
  1475.    (pCtrl->wdgOkay))
  1476.                 ;
  1478.     wdCancel (pCtrl->wdgId);
  1480.             if (!pCtrl->wdgOkay)
  1481.         {
  1482.         pCtrl->wdgOkay = TRUE;
  1484.                 if (reset == TRUE)
  1485.             (void) pDrive->Reset (ctrl, drive);
  1487.                 return (ERROR);
  1488.         }
  1490.     break;
  1492. case ATA_STAT_ACCESS:
  1493.     wdStart (pCtrl->wdgId, (sysClkRateGet() * pCtrl->wdgTimeout), 
  1494.      (FUNCPTR)ataWdog, ctrl);
  1496.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY) && 
  1497.    (pCtrl->wdgOkay))
  1498.         ;
  1500.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_DRQ) &&
  1501.    (pCtrl->wdgOkay))
  1502.                 ;
  1504.     wdCancel (pCtrl->wdgId);
  1506.             if (!pCtrl->wdgOkay)
  1507.         {
  1508.         pCtrl->wdgOkay = TRUE;
  1510.                 if (reset == TRUE)
  1511.             (void) pDrive->Reset (ctrl, drive);
  1513.                 return (ERROR);
  1514.         }
  1516.     break;
  1518. case ATA_STAT_BUSY:
  1520.             while (ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY)
  1521. ;
  1523.     break;
  1525. case ATA_STAT_DRQ:
  1527.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_DRQ) == 0)
  1528.         ;
  1530.     break;
  1532. case ATA_STAT_SEEKCMPLT:
  1534.             while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_SEEKCMPLT) 
  1535.                    == 0)
  1536.         ;
  1538.     break;
  1539. }
  1541.     ATA_DEBUG_MSG (3, "ataPiWait end:n", 0, 0, 0, 0, 0, 0);
  1543.     return (OK);
  1544.     } /* ataPiWait */
  1547. /*******************************************************************************
  1548. *
  1549. * ataInit - init a ATA/IDE disk controller
  1550. *
  1551. * This routine initializes a ATA/IDE disk controller.
  1552. *
  1553. * RETURNS: OK, ERROR if the command didn't succeed.
  1554. */
  1556. LOCAL STATUS ataInit
  1557.     (
  1558.     int ctrl,
  1559.     int dev
  1560.     )
  1561.     {
  1562.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1563.     int      ix;
  1565.     ATA_DEBUG_MSG (2, "ataInit: ctrl=%dn", ctrl, 0, 0, 0, 0, 0);
  1567.     ATA_IO_BYTE_WRITE (pCtrl->dControl,
  1568.                        ATA_CTL_4BIT | ATA_CTL_RST);
  1570.     for (ix = 0; ix < 100; ix++)
  1571.         sysDelay ();
  1573.     ATA_IO_BYTE_WRITE (pCtrl->dControl, ATA_CTL_4BIT);
  1575.     for (ix = 0; ix < 100; ix++)
  1576.         sysDelay ();
  1578.     pCtrl->wdgOkay = TRUE;
  1580.     /* start the ata  watchdog */
  1582.     wdStart (pCtrl->wdgId, (sysClkRateGet() * pCtrl->wdgTimeout),
  1583.      (FUNCPTR)ataWdog, ctrl);
  1585.     while ((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_BUSY) &&
  1586.            (pCtrl->wdgOkay))
  1587. ;
  1589.     ATA_IO_BYTE_WRITE (pCtrl->dControl, ATA_CTL_4BIT);
  1591.     for (ix = 0; ix < 100; ix++) 
  1592.         sysDelay ();
  1594.     while (((ATA_IO_BYTE_READ (pCtrl->aStatus) & ATA_STAT_READY) == 0) &&
  1595.    (pCtrl->wdgOkay))
  1596. ;
  1598.     wdCancel (pCtrl->wdgId);
  1600.     if (!pCtrl->wdgOkay)
  1601.         {
  1602. ATA_DEBUG_MSG (1, "ataInit error:n", 0, 0, 0, 0, 0, 0);
  1604.         pCtrl->wdgOkay = TRUE;
  1606.         return (ERROR);
  1607.         }
  1609.     ATA_DEBUG_MSG (3, "ataInit Calling sysAtaInit (if present):n",
  1610.                    0, 0, 0, 0, 0, 0);
  1612.     /* Call out to bsp specific setup routine */
  1614.     SYS_ATA_INIT_RTN (ctrl);
  1615.     ATA_DEBUG_MSG (3, "ataInit sysAtaInit returnedn", 0, 0, 0, 0, 0, 0);
  1617.     /*
  1618.      * The following allows recovery after an interrupt
  1619.      * caused by drive software reset
  1620.      */
  1622.     semBInit(&pCtrl->syncSem, SEM_Q_FIFO, SEM_EMPTY);
  1624.     ATA_DEBUG_MSG (2, "ataInit endn", 0, 0, 0, 0, 0, 0);
  1626.     return (OK);
  1627.     }
  1629. /*******************************************************************************
  1630. *
  1631. * ataCmd - issue non data command
  1632. *
  1633. * Issue a non data command.  Non data commands have the same protocol.
  1634. *
  1635. * RETURNS: OK, ERROR if the command didn't succeed.
  1636. */
  1638. LOCAL STATUS ataCmd
  1639.     (
  1640.     int ctrl,
  1641.     int drive,
  1642.     int cmd,
  1643.     int arg0,
  1644.     int arg1
  1645.     )
  1646.     {
  1647.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1648.     ATA_TYPE *pType = &ataTypes[ctrl][drive];
  1649.     BOOL     retry = TRUE;
  1650.     int      retryCount = 0;
  1651.     int      semStatus;
  1653.     ATA_DEBUG_MSG (2, "ataCmd%d/%d: cmd=0x%xn", ctrl, drive, cmd, arg0, arg1, 0);
  1655.     while (retry)
  1656. {
  1657.         ataWait (ctrl, ATA_STAT_READY);
  1659. switch (cmd)
  1660.     {
  1661.     case ATA_CMD_DIAGNOSE:
  1662.          ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4));
  1663. break;
  1665.     case ATA_CMD_INITP:
  1666. ATA_IO_BYTE_WRITE (pCtrl->cylLo, pType->cylinders);
  1667. ATA_IO_BYTE_WRITE (pCtrl->cylHi, pType->cylinders >> 8);
  1668. ATA_IO_BYTE_WRITE (pCtrl->seccnt, pType->sectors);
  1669. ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4) | 
  1670.     ((pType->heads - 1) & 0x0f));
  1671. break;
  1673.     case ATA_CMD_RECALIB:
  1674. ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4));
  1675. break;
  1677.     case ATA_CMD_SEEK:
  1678. ATA_IO_BYTE_WRITE (pCtrl->cylLo, arg0);
  1679. ATA_IO_BYTE_WRITE (pCtrl->cylHi, arg0>>8);
  1680. ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4) |
  1681.     (arg1 & 0xf));
  1682. break;
  1684.     case ATA_CMD_SET_FEATURE:
  1685.          ATA_IO_BYTE_WRITE (pCtrl->seccnt, arg1);
  1686.          ATA_IO_BYTE_WRITE (pCtrl->feature, arg0);
  1687.          ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4));
  1688. break;
  1690.     case ATA_CMD_SET_MULTI:
  1691.          ATA_IO_BYTE_WRITE (pCtrl->seccnt, arg0);
  1692.          ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4));
  1693. break;
  1695.     }
  1697.         ATA_IO_BYTE_WRITE (pCtrl->command, cmd);
  1698.         semStatus = semTake (&pCtrl->syncSem, 
  1699.      sysClkRateGet() * pCtrl->semTimeout);
  1701.         if ((pCtrl->intStatus & ATA_STAT_ERR) || (semStatus == ERROR))
  1702.     {
  1704.             ATA_DEBUG_MSG (1, "ataCmd err: status=0x%x semStatus=%d err=0x%xn",
  1705.                            pCtrl->intStatus, semStatus,
  1706.                            ATA_IO_BYTE_READ (pCtrl->error), 0, 0, 0);
  1708.     if (++retryCount > ataRetry)
  1709.         return (ERROR);
  1710.     }
  1711. else
  1712.     retry = FALSE;
  1713. }
  1715. switch (cmd)
  1716.     {
  1717.     case ATA_CMD_SEEK:
  1718. ataWait (ctrl, ATA_STAT_SEEKCMPLT);
  1719. break;
  1721.     }
  1723.     ATA_DEBUG_MSG (2, "ataCmd end - ctrl %d, drive %d: Okn", ctrl, drive, 0, 0, 0, 0);
  1725.     return (OK);
  1726.     }
  1728. /*******************************************************************************
  1729. *
  1730. * ataPread - Read drive parameters
  1731. *
  1732. * Read drive parameters.
  1733. *
  1734. * RETURNS: OK, ERROR if the command didn't succeed.
  1735. */
  1737. LOCAL STATUS ataPread
  1738.     (
  1739.     int      ctrl,
  1740.     int      drive,
  1741.     void     *buffer
  1742.     )
  1743.     {
  1744.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1745.     BOOL     retry = TRUE;
  1746.     int      retryCount = 0;
  1747.     int      semStatus;
  1749.     ATA_DEBUG_MSG (2, "ataPread: ctrl=%d drive=%dn", ctrl, drive, 0, 0, 0, 0);
  1751.     while (retry)
  1752. {
  1753.         ataWait (ctrl, ATA_STAT_READY);
  1755.         ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (drive << 4));
  1756.         ATA_IO_BYTE_WRITE (pCtrl->command, ATA_CMD_READP);
  1757.         semStatus = semTake (&pCtrl->syncSem, 
  1758.      sysClkRateGet() * pCtrl->semTimeout);
  1760.         if ((pCtrl->intStatus & ATA_STAT_ERR) || (semStatus == ERROR))
  1761.     {
  1763.             ATA_DEBUG_MSG (1, "ataPread%d/%d - err: status=0x%x intStatus=0x%x "
  1765.                           "error=0x%x semStatus=%dn", ctrl, drive, 
  1766.                           ATA_IO_BYTE_READ (pCtrl->aStatus), pCtrl->intStatus, 
  1767.                           ATA_IO_BYTE_READ (pCtrl->error), semStatus);
  1769.     if (++retryCount > ataRetry)
  1770.         return (ERROR);
  1771.     }
  1772.         else
  1773.     retry = FALSE;
  1774.         }
  1776.     ataWait (ctrl, ATA_STAT_DRQ);
  1778.     ATA_IO_NWORD_READ_SWAP (pCtrl->data, (short *)buffer, 256);
  1780.     ATA_DEBUG_MSG (2, "ataPread end:n", 0, 0, 0, 0, 0, 0);
  1783.     return (OK);
  1784.     }
  1786. /*******************************************************************************
  1787. *
  1788. * ataRW - read/write a number of sectors on the current track
  1789. *
  1790. * Read/write a number of sectors on the current track
  1791. *
  1792. * RETURNS: OK, ERROR if the command didn't succeed.
  1793. */
  1795. LOCAL STATUS ataRW
  1796.     (
  1797.     int ctrl,
  1798.     int drive,
  1799.     int cylinder,
  1800.     int head,
  1801.     int sector,
  1802.     void *buffer,
  1803.     int nSecs,
  1804.     int direction
  1805.     )
  1806.     {
  1807.     ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  1808.     ATA_DRIVE *pDrive = &pCtrl->drive[drive];
  1809.     ATA_TYPE *pType = &ataTypes[ctrl][drive];
  1810.     int retryCount = 0;
  1811.     int block = 1;
  1812.     int nSectors;
  1813.     int nWords;
  1814.     int semStatus;
  1815.     short *pBuf;
  1817.     ATA_DEBUG_MSG (2, "ataRW: ctrl=%d drive=%d c=%d h=%d s=%d buf=0x%x ",
  1818.                    ctrl, drive, cylinder, head, sector, (int)buffer);
  1819.     ATA_DEBUG_MSG (2, "n=%d dir=%dn", nSecs, direction, 0, 0, 0, 0);
  1821. retryRW:
  1823.     ataWait (ctrl, ATA_STAT_READY);
  1825.     pBuf = (short *)buffer;
  1826.     nSectors = nSecs;
  1828.     ATA_IO_BYTE_WRITE (pCtrl->feature, pType->precomp);
  1829.     ATA_IO_BYTE_WRITE (pCtrl->seccnt, nSecs);
  1830.     ATA_IO_BYTE_WRITE (pCtrl->sector, sector);
  1831.     ATA_IO_BYTE_WRITE (pCtrl->cylLo, cylinder);
  1832.     ATA_IO_BYTE_WRITE (pCtrl->cylHi, cylinder>>8);
  1834.     if (pDrive->okLba)
  1835.         ATA_IO_BYTE_WRITE (pCtrl->sdh,
  1836.                            ATA_SDH_LBA | (drive << 4) | (head & 0xf));
  1837.     else
  1838.         ATA_IO_BYTE_WRITE (pCtrl->sdh,
  1839.                            ATA_SDH_IBM | (drive << 4) | (head & 0xf));
  1841.     if (pDrive->rwPio == ATA_PIO_MULTI)
  1842. block = pDrive->multiSecs;
  1844.     nWords = (pType->bytes * block) >> 1;
  1846.     if (direction == O_WRONLY)
  1847. {
  1849.         if (pDrive->rwPio == ATA_PIO_MULTI)
  1850.     ATA_IO_BYTE_WRITE (pCtrl->command, ATA_CMD_WRITE_MULTI);
  1851. else
  1852.     ATA_IO_BYTE_WRITE (pCtrl->command, ATA_CMD_WRITE);
  1854. while (nSectors > 0)
  1855.     {
  1857.     if ((pDrive->rwPio == ATA_PIO_MULTI) && (nSectors < block))
  1858. {
  1859. block = nSectors;
  1860. nWords = (pType->bytes * block) >> 1;
  1861. }
  1863.             ataWait (ctrl, ATA_STAT_BUSY);
  1864.             ataWait (ctrl, ATA_STAT_DRQ);
  1866.     if (pDrive->rwBits == ATA_BITS_16)
  1867.         ATA_IO_NWORD_WRITE (pCtrl->data, pBuf, nWords);
  1868.     else
  1869.         ATA_IO_NLONG_WRITE (pCtrl->data, (long *)pBuf, nWords >> 1);
  1871.             semStatus = semTake (&pCtrl->syncSem, 
  1872.  sysClkRateGet() * pCtrl->semTimeout);
  1874.          if ((pCtrl->intStatus & ATA_STAT_ERR) || (semStatus == ERROR))
  1875.         goto errorRW;
  1877.     pBuf     += nWords;
  1878.     nSectors -= block;
  1879.             }
  1880. }
  1881.     else
  1882. {
  1884.         if (pDrive->rwPio == ATA_PIO_MULTI)
  1885.     ATA_IO_BYTE_WRITE (pCtrl->command, ATA_CMD_READ_MULTI);
  1886. else
  1887.     ATA_IO_BYTE_WRITE (pCtrl->command, ATA_CMD_READ);
  1889. while (nSectors > 0)
  1890.     {
  1892.     if ((pDrive->rwPio == ATA_PIO_MULTI) && (nSectors < block))
  1893. {
  1894. block = nSectors;
  1895. nWords = (pType->bytes * block) >> 1;
  1896. }
  1898.             semStatus = semTake (&pCtrl->syncSem, 
  1899.  sysClkRateGet() * pCtrl->semTimeout);
  1901.          if ((pCtrl->intStatus & ATA_STAT_ERR) || (semStatus == ERROR))
  1902.         goto errorRW;
  1904.             ataWait (ctrl, ATA_STAT_BUSY); /* wait for slow disk */
  1905.             ataWait (ctrl, ATA_STAT_DRQ);
  1907.     if (pDrive->rwBits == ATA_BITS_16)
  1908.         ATA_IO_NWORD_READ (pCtrl->data, pBuf, nWords);
  1909.     else
  1910.         ATA_IO_NLONG_READ (pCtrl->data, (long *)pBuf, nWords >> 1);
  1912.     pBuf     += nWords;
  1913.     nSectors -= block;
  1914.     }
  1915. }
  1917.     ATA_DEBUG_MSG (2, "ataRW: endn", 0, 0, 0, 0, 0, 0);
  1919.     return (OK);
  1921. errorRW:
  1923.     ATA_DEBUG_MSG (1, "ataRW err: stat=0x%x 0x%x semStatus=%d error=0x%xn",
  1924.            pCtrl->intStatus, ATA_IO_BYTE_READ (pCtrl->aStatus), 
  1925.                    semStatus, ATA_IO_BYTE_READ (pCtrl->error), 0, 0);
  1927.     if (++retryCount < ataRetry)
  1928. goto retryRW;
  1930.     return (ERROR);
  1931.     }
  1933. /******************************* ATAPI Devices *********************************/
  1935. /*******************************************************************************
  1936. *
  1937. * ataDevIdentify - identify device
  1938. *
  1939. * This routine checks whether the device is connected to the controller, and if
  1940. * so determines its type.  The routine set `type' field in the corresponding 
  1941. * ATA_DRIVE structure.
  1942. * If device identification failed, the routine set `state' field in the 
  1943. * corresponding ATA_DRIVE structure to ATA_DEV_NONE.
  1944. *
  1945. * RETURNS: TRUE if a device is present, FALSE otherwise
  1946. */
  1948. LOCAL STATUS ataDevIdentify
  1949.     (
  1950.     int ctrl,
  1951.     int dev
  1952.     )
  1953.     {
  1954.     ATA_CTRL    *pCtrl = &ataCtrl[ctrl];
  1955.     ATA_DRIVE   *pDrive = &pCtrl->drive [dev];
  1956.     ATA_PARAM   *pParam = &pDrive->param;
  1958.     pDrive->type = ATA_TYPE_NONE;
  1960.     /* Select device */ 
  1962.     ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (dev << 4));
  1963.  
  1964.     /* Wait for device selection */
  1965.  
  1966.     ATA_WAIT_STATUS;
  1967.  
  1968.     /* Clear semaphore: Selection of nonexistent device may rise an interrupt */
  1970.     semTake (&pCtrl->syncSem, NO_WAIT);
  1972.     ATA_IO_BYTE_WRITE (pCtrl->seccnt, 0xaa);
  1973.     ATA_IO_BYTE_WRITE (pCtrl->sector, 0x55);
  1974.  
  1975.     if (ATA_IO_BYTE_READ (pCtrl->seccnt) == 0xaa)
  1976.         {
  1978.         if (ataPiPread (ctrl, dev, pParam) == OK)
  1979.             {
  1980.             pDrive->type = ATA_TYPE_ATAPI;
  1981.             }
  1982.         else 
  1984.             if ( ((ATA_IO_BYTE_READ (ATAPI_STATUS) & (ATA_STAT_BUSY | 
  1985.    ATA_STAT_WRTFLT | ATA_STAT_DRQ | ATA_STAT_ERR)) == 
  1986.                    ATA_STAT_ERR) &&
  1987.                   (ATA_IO_BYTE_READ (ATAPI_ERROR) == ERR_ABRT) )
  1988.                 {
  1990.                 if (ataPiWait (ctrl, ATA_STAT_READY, FALSE) == OK)
  1991.                     pDrive->type = ATA_TYPE_ATA;
  1992.                 }
  1993.         }
  1994.  
  1995.     if (pDrive->type != ATA_TYPE_NONE)
  1996.         return (OK);
  1998.     ATA_DEBUG_MSG (1, "ataDevIdentify%d/%d: ERROR: status=0x%x dev=0x%x "
  1999.                    "error=0x%xn", ctrl, dev, ATA_IO_BYTE_READ (pCtrl->status),
  2000.                    ATA_IO_BYTE_READ (pCtrl->sdh), 
  2001.                    ATA_IO_BYTE_READ (pCtrl->error), 0);
  2003.     /* Select present device */
  2005.     ATA_IO_BYTE_WRITE (pCtrl->sdh, ATA_SDH_IBM | (((~dev) & 0x1) << 4)); /* define macro for 0x1 */
  2007.     pDrive->state = ATA_DEV_NONE;
  2009.     return (ERROR);
  2010.     } /* ataDevIdentify */
  2012. /*******************************************************************************
  2013. *
  2014. * ataPiInit - init a ATAPI CD-ROM disk controller
  2015. *
  2016. * This routine resets a ATAPI CD-ROM disk controller.
  2017. *
  2018. * RETURNS: OK, ERROR if the command didn't succeed.
  2019. */
  2021. LOCAL STATUS ataPiInit 
  2022.     (
  2023.     int ctrl,
  2024.     int drive
  2025.     )
  2026.     {
  2027.     ATA_CTRL    *pCtrl = &ataCtrl[ctrl];
  2028.     int retryCount = 0;
  2029.     int i;
  2031.     ATA_DEBUG_MSG (2, "ataPiInit%d/%d: n", ctrl, drive, 0, 0, 0, 0);
  2033.     while (TRUE) /* Forever */
  2034.         {
  2035.         ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (drive << 4));
  2037.         ATA_WAIT_STATUS;
  2039.         ATA_IO_BYTE_WRITE (ATAPI_COMMAND, ATA_PI_CMD_SRST);
  2041.         for (i = 0; i < 5000; i++) /* 2 ms */
  2042.             {
  2043.             ATA_WAIT_STATUS;
  2044.             }
  2046.         ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (drive << 4));
  2048.         ATA_WAIT_STATUS;
  2050.         pCtrl->wdgOkay = TRUE;
  2052.         wdStart (pCtrl->wdgId, (sysClkRateGet() * pCtrl->wdgTimeout), 
  2053.                  (FUNCPTR)ataWdog, ctrl);
  2055.         while ( (ATA_IO_BYTE_READ (ATAPI_STATUS) & (ATA_STAT_BUSY | 
  2056.                  ATA_STAT_READY | ATA_STAT_WRTFLT | ATA_STAT_DRQ | 
  2057.                  ATA_STAT_ECCCOR | ATA_STAT_ERR)) && (pCtrl->wdgOkay) )
  2058.     ;
  2060.         wdCancel (pCtrl->wdgId);
  2062.         if (pCtrl->wdgOkay)
  2063.             break;
  2065.         pCtrl->wdgOkay = TRUE;
  2067.         ATA_DEBUG_MSG (1, "ataPiInit%d/%d: ERROR: status=0x%x error=0x%xn", 
  2068.                        ctrl, drive, ATA_IO_BYTE_READ(ATAPI_STATUS), 
  2069.                        ATA_IO_BYTE_READ(ATAPI_ERROR), 0, 0);
  2071. if (++retryCount == ataRetry)
  2072.     return (ERROR);
  2073.         }
  2075.     /* The following allow to recover after accidental interrupt */
  2077.     if (semTake (&pCtrl->syncSem, NO_WAIT) == OK)
  2078.         {
  2079.         ATA_DEBUG_MSG (2, "ataPiInit%d/%d: WARNING: interrupt cleared: "
  2080.                        "status=0x%x dev=0x%x error=0x%xn", ctrl, drive, 
  2081.                        ATA_IO_BYTE_READ(ATAPI_STATUS), 
  2082.                        ATA_IO_BYTE_READ(ATAPI_D_SELECT), 
  2083.                        ATA_IO_BYTE_READ(ATAPI_ERROR), 0);
  2084.         }
  2085.     else
  2086.         {
  2087.         ATA_DEBUG_MSG (2, "ataPiInit%d/%d: Ok: status=0x%x dev=0x%x error=0x%x"
  2088.                        "n", ctrl, drive, ATA_IO_BYTE_READ(ATAPI_STATUS), 
  2089.                        ATA_IO_BYTE_READ(ATAPI_D_SELECT), 
  2090.                        ATA_IO_BYTE_READ(ATAPI_ERROR), 0);
  2091.         }
  2093.     return (OK);
  2094.     } /* ataPiInit */
  2096. /*******************************************************************************
  2097. *
  2098. * ataPiPread - Read ATAPI drive parameters
  2099. *
  2100. * This routine reads drive parameters.
  2101. *
  2102. * RETURNS: OK, ERROR if the command didn't succeed.
  2103. */
  2105. LOCAL STATUS ataPiPread
  2106.     (
  2107.     int ctrl,
  2108.     int drive,
  2109.     void        *buffer
  2110.     )
  2111.     {
  2112.     ATA_CTRL    *pCtrl = &ataCtrl[ctrl];
  2113.     int status;
  2114.     int error;
  2115.     int semStatus;
  2117.     ATA_DEBUG_MSG (2, "ataPiPread%d/%d: n", ctrl, drive, 0, 0, 0, 0);
  2119.     ataPiWait (ctrl, ATA_STAT_ACCESS, TRUE);
  2121.     /* Select device */
  2123.     ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (drive << 4));
  2125.     ATA_WAIT_STATUS;
  2127.     if (ataPiWait (ctrl, ATA_STAT_ACCESS, TRUE) != OK)
  2128.         {
  2129.         ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (drive << 4));;
  2130.         ATA_WAIT_STATUS;
  2131.         }
  2133.     /* ATAPI Identify Device Command */
  2135.     ATA_IO_BYTE_WRITE (ATAPI_COMMAND, ATA_PI_CMD_IDENTD);
  2137.     ATA_WAIT_STATUS;
  2139.     /*
  2140.      * Poll Status Register instead of wait for interrupt to avoid needless 
  2141.      * delay.
  2142.      */
  2144.     ataPiWait (ctrl, ATA_STAT_BUSY, FALSE);
  2146.     semStatus = semTake (&pCtrl->syncSem, 1);
  2148.     status = ATA_IO_BYTE_READ (ATAPI_STATUS);
  2150.     if ( (status & ATA_STAT_ERR) || !(status & ATA_STAT_DRQ) || 
  2151.          (semStatus != OK) )
  2152.         {
  2153.         error = ATA_IO_BYTE_READ (ATAPI_ERROR);
  2155.         ATA_DEBUG_MSG (1, "ataPiPread%d/%d: ERROR: status=0x%x intStatus=0x%x "
  2156.                       "error=0x%x semStatus=%dn", ctrl, drive, status, 
  2157.                        pCtrl->intStatus, error, semStatus);
  2159.         return (ERROR);
  2160.         }
  2162.     /* Receive parameter information from the drive */
  2164.     ATA_IO_NWORD_READ_SWAP (ATAPI_DATA, (short *)buffer, 
  2165.                             sizeof(ATA_PARAM)/sizeof(short));
  2167.     /* To prevent from reading status before it is valid */
  2169.     ATA_IO_BYTE_READ (pCtrl->aStatus);
  2171.     /* Wait for device to be ready !!! */
  2173.     ataPiWait (ctrl, ATA_STAT_READY, TRUE);
  2175.     ATA_DEBUG_MSG (2, "ataPiPread%d/%d:Ok: status=0x%x devReg=0x%xn", 
  2176.                   ctrl, drive, ATA_IO_BYTE_READ (pCtrl->status), 
  2177.                   ATA_IO_BYTE_READ (pCtrl->sdh), 0, 0);
  2179.     return (OK);
  2180.     } /* ataPiPread */
  2182. /*******************************************************************************
  2183. *
  2184. * atapiDMAInit - initialize the DMA engine
  2185. *
  2186. * This routine initializes the DMA engine.
  2187. *
  2188. * RETURN: OK, or ERROR
  2189. */
  2191. LOCAL STATUS atapiDMAInit (void)
  2192.     {
  2193.     printErr("ATAPI (DMA Init.) ERROR: DMA transfer is not emplemented.n");
  2194.     return ERROR;
  2195.     }
  2197. /*******************************************************************************
  2198. *
  2199. * atapiDMATransfer - transfer a single data packet via DMA
  2200. *
  2201. * This routine transfers a single data packet via DMA.
  2202. *
  2203. * RETURN: OK, or ERROR
  2204. *
  2205. * SEE ALSO: ataPiPIOTransfer()
  2206. */
  2208. LOCAL STATUS atapiDMATransfer 
  2209.     (
  2210.     ATA_DEV *pAtapiDev
  2211.     )
  2212.     {
  2213.     pAtapiDev->errNum = 27;
  2214.     return ERROR;
  2215.     }
  2217. /*******************************************************************************
  2218. *
  2219. * ataPiOverlapTransferLoop - loop for DRQ Interrupts with Overlapping
  2220. *
  2221. * This routine loops for Data Request Interrupts until all data packets are 
  2222. * transferred.  It is invoked when ataPiPktCmd() executes an Overlapped command.  
  2223. * When Device executes an Overlapped command, it releases the ATA bus until the
  2224. * device is ready to transfer a data or to present the completion status.
  2225. *
  2226. * RETURN: OK, or ERROR
  2227. *
  2228. * SEE ALSO: ataPiNonOverTransferLoop()
  2229. */
  2231. LOCAL STATUS ataPiOverlapTransferLoop
  2232.     (
  2233.     ATA_DEV *pAtapiDev,
  2234.     FUNCPTR pTransferProc
  2235.     )
  2236.     {
  2237.     pAtapiDev->errNum = 26;
  2238.     return ERROR;
  2239.     }
  2241. /*******************************************************************************
  2242. *
  2243. * ataPiPIOTransfer - transfer a single data packet via PIO
  2244. *
  2245. * This routine transfers a single data packet via PIO.
  2246. *
  2247. * RETURN: OK, or ERROR
  2248. *
  2249. * SEE ALSO: atapiDMATransfer()
  2250. */
  2252. LOCAL STATUS ataPiPIOTransfer
  2253.     (
  2254.     ATA_DEV     *pAtapiDev
  2255.     )
  2256.     {
  2257.     ATA_CTRL    *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  2258.     uint32_t desiredSize;
  2259.     uint32_t remainderSize;
  2260.     short bucket;
  2262.     /* Read Byte Count */
  2264.     pAtapiDev->transSize = ((uint16_t)ATA_IO_BYTE_READ (ATAPI_BCOUNT_HI)) << 8;
  2265.     pAtapiDev->transSize += ATA_IO_BYTE_READ (ATAPI_BCOUNT_LO);
  2267.     /*
  2268.      * From ATA Packet Interface for CD-ROMs SFF-8020i:
  2269.      * If the Device requests more data be transfered than required by the 
  2270.      * command protocol, the Host shall pad when sending data to the Device, 
  2271.      * and dump extra data into a bit bucket when reading data from the Device.
  2272.      *
  2273.      * Why device will request more data than required? It is not clear.
  2274.      * (May be some devices can't transfer part of the internal buffer?) !!!
  2275.      */
  2277.     if ( (pAtapiDev->pBufEnd == NULL) && (pAtapiDev->transSize != 0) )
  2278.         {
  2279.         pAtapiDev->errNum = 8;
  2280.         return ERROR;
  2281.         }
  2282.     desiredSize = pAtapiDev->pBufEnd - pAtapiDev->pBuf;
  2284.     if (desiredSize <= pAtapiDev->transSize)
  2285.         {
  2286.         remainderSize = pAtapiDev->transSize - desiredSize;
  2287.         pAtapiDev->pBufEnd = NULL;
  2288.         }
  2289.     else
  2290.         {
  2291.         desiredSize = pAtapiDev->transSize;
  2292.         remainderSize = 0;
  2293.         }
  2295.     /* Transfer Data Bytes */
  2297.     switch (pAtapiDev->direction)
  2298.         {
  2299.         case OUT_DATA:
  2301.             if((pAtapiDev->intReason & INTR_IO) != 0) /* IO cleared */
  2302.                     goto errorPIOTransfer;
  2304.             ATA_IO_NWORD_WRITE (ATAPI_DATA, (short *)pAtapiDev->pBuf, 
  2305.                                 desiredSize / 2);
  2307.             while (remainderSize)
  2308.                 {
  2309.                 bucket = 0;
  2310.                 ATA_IO_NWORD_WRITE (ATAPI_DATA, &bucket, 1);
  2311.                 remainderSize -= 2;
  2312.                 }
  2314.             break;
  2316.         case IN_DATA:
  2318.             if((pAtapiDev->intReason & INTR_IO) == 0) /* IO set */
  2319.                     goto errorPIOTransfer;
  2320.             ATA_IO_NWORD_READ (ATAPI_DATA, (short *)pAtapiDev->pBuf, 
  2321.                                desiredSize / 2);
  2323.             while (remainderSize)
  2324.                 {
  2325.                 ATA_IO_NWORD_READ (ATAPI_DATA, &bucket, 1);
  2326.                 remainderSize -= 2;
  2327.                 }
  2329.             break;
  2331.         default:
  2333.             goto errorPIOTransfer;
  2335.         }
  2337.     pAtapiDev->pBuf += pAtapiDev->transSize;
  2339.     return OK;
  2341. errorPIOTransfer:
  2343.     pAtapiDev->errNum = 10;
  2345.     return ERROR;
  2346.     }
  2348. /*******************************************************************************
  2349. *
  2350. * ataPiNonOverTransferLoop - loop for DRQ Interrupts without Overlapping
  2351. *
  2352. * This routine loops for Data Request Interrupts until all data packets are 
  2353. * transferred.  It is invoked when ataPiPktCmd() executes a NON Overlapped command.
  2354. *
  2355. * RETURN: OK, or ERROR 
  2356. *
  2357. * SEE ALSO: ataPiOverlapTransferLoop()
  2358. */
  2360. LOCAL STATUS ataPiNonOverTransferLoop
  2361.     (
  2362.     ATA_DEV  *pAtapiDev,
  2363.     FUNCPTR  pTransferProc
  2364.     )
  2365.     {
  2366.     ATA_CTRL *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  2367.     int      semStatus;
  2369.     while ( TRUE )
  2370.         {
  2371.         /* Wait for INTRQ */
  2373.         semStatus = semTake (&pCtrl->syncSem, sysClkRateGet() * 
  2374.                                               pCtrl->semTimeout);
  2375.         if ((semStatus == ERROR))
  2376.             {
  2377.             pAtapiDev->errNum = 4;
  2378.             return ERROR;
  2379.             }
  2381.         /* Note: ideIntr() reads Status to negate INTRQ */
  2383.         pAtapiDev->status = pCtrl->intStatus;
  2384.         pAtapiDev->intReason = ATA_IO_BYTE_READ (ATAPI_INTREASON);
  2386.         if ( (pAtapiDev->status & ATA_STAT_DRQ) == 0)
  2387.             break; /* Command terminated */
  2389.         if (pAtapiDev->direction == NON_DATA)     /* non data command */
  2390.             {
  2391.             pAtapiDev->errNum = 5;
  2393.             return ERROR;
  2394.             }
  2396.         if ( ((pAtapiDev->intReason & INTR_COD) != 0) ||/* CoD cleared */
  2397.              ((pAtapiDev->status & ATA_STAT_BUSY) != 0) /* BUSY cleared */
  2398.            )
  2399.             {
  2400.             pAtapiDev->errNum = 6;
  2402.             return ERROR;
  2403.             }
  2405.         /* Transfer single data packet */
  2407.         if (pTransferProc(pAtapiDev) != OK)
  2408.             return ERROR;
  2410.         pAtapiDev->transCount++;
  2411.         } /* while ( TRUE ) */
  2413.     if ( ((pAtapiDev->intReason & INTR_COD) == 0)    || /* CoD set */
  2414.          ((pAtapiDev->intReason & INTR_IO) == 0)     || /* IO set */
  2415.          ((pAtapiDev->status & ATA_STAT_READY) == 0) || /* DRDY set */
  2416.          ((pAtapiDev->status & ATA_STAT_BUSY) != 0) /* BUSY cleared */
  2417.        )
  2418.         {
  2419.         pAtapiDev->errNum = 7;
  2421.         return ERROR;
  2422.         }
  2424.     return OK;
  2425.     }
  2427. /*******************************************************************************
  2428. *
  2429. * ataPiPktCmdExec - execute an ATAPI command without error processing
  2430. *
  2431. * This routine executes a single ATAPI command without checking of completion
  2432. * status, and attempts to recover.
  2433. * An invoking routine is responsible for error processing.
  2434. *
  2435. * RETURN: OK, or ERROR if an error is encountered during data transfer.
  2436. *
  2437. * ERRNO:
  2438. *  S_ioLib_DEVICE_ERROR
  2439. */
  2441. LOCAL STATUS ataPiPktCmdExec
  2442.     (
  2443.     ATA_DEV   *pAtapiDev,
  2444.     ATAPI_CMD *pComPack
  2445.     )
  2446.     {
  2447.     int       device = pAtapiDev->drive;
  2448.     ATA_CTRL  *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  2449.     ATA_DRIVE *pDrive = &pCtrl->drive[device];
  2450.     ATA_PARAM *pParam = &pDrive->param;
  2451.     int       semStatus;
  2452.     FUNCPTR   pTransferProc = (FUNCPTR)ataPiPIOTransfer;
  2453.     FUNCPTR   pTransferLoopProc = (FUNCPTR)ataPiNonOverTransferLoop;
  2454.     UCHAR     featers = 0; /* Features Register */
  2455.     uint32_t  desiredTransferSize = pComPack->desiredTransferSize;
  2457.     ATA_DEBUG_MSG (2, "ataPiPktCmdExec%d/%d: com=0x%xn", pAtapiDev->ctrl, 
  2458.                    device, pComPack->cmdPkt[0], 0, 0, 0);
  2460.     /* Initialize transfer control structure */
  2462.     if (NULL != pComPack->ppBuf)
  2463.          {
  2464.          pAtapiDev->pBuf   = *(pComPack->ppBuf);
  2465.  pAtapiDev->pBufEnd   = *(pComPack->ppBuf) + pComPack->bufLength;
  2466.          }
  2467.     else
  2468.          {
  2469.          pAtapiDev->pBuf   = NULL;
  2470.          pAtapiDev->pBufEnd   = NULL;
  2471.          }
  2473.     pAtapiDev->direction  = pComPack->direction;
  2474.     pAtapiDev->transCount = 0;
  2475.     pAtapiDev->errNum   = 0;
  2476.     pAtapiDev->intReason  = 0;
  2477.     pAtapiDev->status   = 0;
  2478.     pAtapiDev->transSize  = 0;
  2480.     if (pComPack->dma)
  2481.         if (pParam->capabilities & CAPABIL_DMA)
  2482.             if (atapiDMAInit() == OK) /* Initialize the DMA engine */
  2483.                 {
  2484.                 featers |= FEAT_DMA;
  2485.                 pTransferProc = (FUNCPTR)atapiDMATransfer;
  2486.                 }
  2488.     if (pComPack->overlap)
  2489.         if (pParam->capabilities & CAPABIL_OVERLAP)
  2490.             {
  2491.             featers |= FEAT_OVERLAP;
  2492.             pTransferLoopProc = (FUNCPTR)ataPiOverlapTransferLoop;
  2493.             }
  2495.     ataPiWait (pAtapiDev->ctrl, ATA_STAT_ACCESS, TRUE);
  2497.     /* Select device */
  2499.     ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (device << 4));
  2501.     ATA_WAIT_STATUS;
  2503.     if (ataPiWait (pAtapiDev->ctrl, ATA_STAT_ACCESS, TRUE) != OK)
  2504.         {
  2505.         ATA_IO_BYTE_WRITE (ATAPI_D_SELECT, DSEL_FILLER | (device << 4));;
  2506.         ATA_WAIT_STATUS;
  2507.         }
  2509.     /***** Issue `ATAPI Packet Command' *****/
  2511.     /* Initialize Task File */
  2513.     ATA_IO_BYTE_WRITE (ATAPI_FEATURE, featers);
  2514.     ATA_IO_BYTE_WRITE (ATAPI_BCOUNT_LO, (uint8_t)desiredTransferSize);
  2515.     ATA_IO_BYTE_WRITE (ATAPI_BCOUNT_HI, (uint8_t)(desiredTransferSize >> 8));
  2517.     /* Wait for BSY=0 & DRQ=0 */
  2519.     while ( (ATA_IO_BYTE_READ (ATAPI_STATUS) & (ATA_STAT_BUSY | ATA_STAT_DRQ)) 
  2520.             != 0 )
  2521.         ;
  2523.     /* Issue Packet Command */
  2525.     ATA_IO_BYTE_WRITE (ATAPI_COMMAND, ATA_PI_CMD_PKTCMD);
  2527.     /***** Transfer the Command Packet In to Host *****/
  2529.     /* Wait for DRQ or INTRQ */
  2531.     switch (pParam->config & CONFIG_PKT_TYPE) /* CMD DRQ Type */
  2532.         {
  2533.         case CONFIG_PKT_TYPE_INTER: /* Interrupt DRQ */
  2534.             /* Wait for INTRQ */
  2536.             semStatus = semTake (&pCtrl->syncSem, sysClkRateGet() * 
  2537.                                                   pCtrl->semTimeout);
  2538.             if ((semStatus == ERROR))
  2539.                 {
  2540.                 pAtapiDev->errNum = 1;
  2542.                 goto errPktCmdExec;
  2543.                 }
  2545.             /* Note: ideIntr() read Status to negate INTRQ */
  2547.             pAtapiDev->status = pCtrl->intStatus;
  2549.             if ( ((pAtapiDev->status & ATA_STAT_DRQ) == 0) || /* DRQ set */
  2550.                  ((pAtapiDev->status & ATA_STAT_BUSY) != 0)   /* BUSY cleared */
  2551.                 )
  2552.                 {
  2553.                 pAtapiDev->errNum = 2;
  2555.                 goto errPktCmdExec;
  2556.                 }
  2557.             break;
  2559.         case CONFIG_PKT_TYPE_MICRO: /* Microprocessor DRQ */
  2560.         case CONFIG_PKT_TYPE_ACCEL: /* Accelerated DRQ */
  2562.             while ( ((pAtapiDev->status = ATA_IO_BYTE_READ (ATAPI_STATUS)) & 
  2563.                      (ATA_STAT_DRQ | ATA_STAT_BUSY)) != ATA_STAT_DRQ )
  2564.                 ;  /* DRQ set, BUSY cleared */
  2566.         }
  2567.  
  2568.     pAtapiDev->intReason = ATA_IO_BYTE_READ (ATAPI_INTREASON);
  2570.     if ( ((pAtapiDev->intReason & INTR_COD) == 0) || /* CoD set */
  2571.          ((pAtapiDev->intReason & INTR_IO) != 0)     /* IO cleared */
  2572.         )
  2573.         {
  2574.         pAtapiDev->errNum = 3;
  2576.         goto errPktCmdExec;
  2577.         }
  2579.     /* Write Command Packet Bytes (6 words of Command) */
  2581.     ATA_IO_NWORD_WRITE (ATAPI_DATA, (short *)pComPack->cmdPkt, 6);
  2583.     /***** Transfer the Data *****/
  2585.     if (pTransferLoopProc(pAtapiDev, pTransferProc) == OK)
  2586.         {
  2587.         ATA_DEBUG_MSG (2, "ataPiPktCmdExec%d/%d: Ok: bufStart=%p buf=%p n=%d "
  2588.                        "com=0x%xn", pAtapiDev->ctrl, device, 
  2589.                        *(pComPack->ppBuf), pAtapiDev->pBuf, 
  2590.                        pAtapiDev->transCount, pComPack->cmdPkt[0]);
  2593.         if (NULL != pComPack->ppBuf)
  2594.             {
  2595.             if (pAtapiDev->pBufEnd == NULL)
  2596.                 *(pComPack->ppBuf) += pComPack->bufLength;
  2597.             else
  2598.                 *(pComPack->ppBuf) = pAtapiDev->pBuf;
  2599.             }
  2600.         return (OK);
  2601.         }
  2603. errPktCmdExec:
  2605.     ATA_DEBUG_MSG (1, "ataPiPktCmdExec%d/%d: ERROR: %s: status=0x%x "
  2606.                    "dev=0x%x error=0x%xn", pAtapiDev->ctrl, device, 
  2607.                    ataErrStrs[pAtapiDev->errNum], pAtapiDev->status, 
  2608.                    ATA_IO_BYTE_READ(ATAPI_D_SELECT), 
  2609.                    ATA_IO_BYTE_READ(ATAPI_ERROR));
  2610.     ATA_DEBUG_MSG (1, "bufStart=%p buf=%p n=%d com=0x%x intReason=0x%x "
  2611.                    "byteCount=0x%xn", *(pComPack->ppBuf), pAtapiDev->pBuf, 
  2612.                    pAtapiDev->transCount, pComPack->cmdPkt[0], 
  2613.                    pAtapiDev->intReason, pAtapiDev->transSize);
  2615.     return (ERROR);
  2616.     } /* ataPiPktCmdExec */
  2618. /*******************************************************************************
  2619. *
  2620. * ataPiReqSense - issue a REQUEST_SENSE command to a device and read the results
  2621. *
  2622. * This routine issues a REQUEST_SENSE command to a specified ATAPI device and
  2623. * read the results.
  2624. *
  2625. * RETURNS: OK, or ERROR if the command fails.
  2626. */
  2628. LOCAL STATUS ataPiReqSense
  2629.     (
  2630.     ATA_DEV     *pAtapiDev
  2631.     )
  2632.     {
  2633. #ifdef ATA_DEBUG
  2634.     ATA_CTRL    *pCtrl    = &ataCtrl[pAtapiDev->ctrl];
  2635. #endif
  2636.     ATAPI_CMD atapiCmd;
  2637.     char reqSenseData [18];
  2638.     char        *pBuf = (char *)reqSenseData;
  2639.     int  i;
  2640.     int senseKey;
  2641.     int senseCode;
  2643.     ATA_DEBUG_MSG (2, "ataPiReqSense%d/%d: n", pAtapiDev->ctrl, 
  2644.                    pAtapiDev->drive, 0, 0, 0, 0);
  2646.     /* build a REQUEST SENSE command and execute it */
  2648.     atapiCmd.cmdPkt[0] = CDROM_CMD_REQUEST_SENSE;
  2650.     for (i = 1; i < 4; i++)
  2651.         atapiCmd.cmdPkt[i] = 0;
  2653.     atapiCmd.cmdPkt[4] = 18;
  2655.     for (i = 5; i < 12; i++)
  2656.         atapiCmd.cmdPkt[i] = 0;
  2658.     atapiCmd.ppBuf  = &pBuf;
  2659.     atapiCmd.bufLength  = 18;
  2660.     atapiCmd.direction  = IN_DATA;
  2661.     atapiCmd.desiredTransferSize = 18;
  2662.     atapiCmd.dma  = FALSE;
  2663.     atapiCmd.overlap  = FALSE;
  2665.     if (ataPiPktCmdExec (pAtapiDev, &atapiCmd) != OK)
  2666.         return (ERROR);
  2668.     /* REQUEST SENSE command status != GOOD indicates fatal error */
  2670.     if ( (pAtapiDev->status & ATA_STAT_ERR) != 0 )
  2671.         {
  2672.         ATA_DEBUG_MSG (1, "ataPiReqSense%d/%d: ERROR: status=0x%x dev=0x%x "
  2673.                        "error=0x%xn", pAtapiDev->ctrl, pAtapiDev->drive, 
  2674.                        pAtapiDev->status, ATA_IO_BYTE_READ(ATAPI_D_SELECT), 
  2675.                        ATA_IO_BYTE_READ(ATAPI_ERROR), 0);
  2677.         return (ERROR);
  2678.         }
  2680.     bzero (pBuf, 18 - (pBuf - reqSenseData));
  2682.     senseKey  = reqSenseData[2] & 0x0f;
  2683.     senseCode = reqSenseData[12];
  2685.     ATA_DEBUG_MSG (1, "ataPiReqSense%d/%d: Ok: senseKey=0x%x addSenseCode=0x%x"
  2686.                    "n", pAtapiDev->ctrl, pAtapiDev->drive, 
  2687.                    (reqSenseData[2] & 0x0f), reqSenseData[12], 0, 0);
  2689.     return (OK);
  2690.     } /* ataPiReqSense */
  2692. /*******************************************************************************
  2693. *
  2694. * ataPiPktCmd - execute an ATAPI command with error processing
  2695. *
  2696. * This routine executes a single ATAPI command, checks the command completion 
  2697. * status and tries to recover if an error encountered during command execution 
  2698. * at any stage.
  2699. *
  2700. * RETURN: OK, or ERROR if not successful for any reason.
  2701. *
  2702. * ERRNO:
  2703. *  S_ioLib_DEVICE_ERROR
  2704. */
  2706. LOCAL STATUS ataPiPktCmd
  2707.     (
  2708.     ATA_DEV     *pAtapiDev,
  2709.     ATAPI_CMD   *pComPack
  2710.     )
  2711.     {
  2712.     int device    = pAtapiDev->drive;
  2713.     ATA_CTRL    *pCtrl    = &ataCtrl[pAtapiDev->ctrl];
  2714.     ATA_DRIVE   *pDrive    = &pCtrl->drive[device];
  2715.     UCHAR error    = 0; /* Error Register */
  2716.     int retryCount = 0;
  2718.     if (pComPack->bufLength != 0)
  2719.         {
  2721.         if (pComPack->desiredTransferSize == 0)
  2722.             return (ERROR);
  2724.         if (pComPack->desiredTransferSize > 65534)
  2725.             pComPack->desiredTransferSize = 0xfffe;
  2726. /* ATA-4 Rev.18: 0xffff is interpreted by device
  2727.                                  * as though it where 0xfffe */
  2728.         else
  2730.             if (pComPack->desiredTransferSize < pComPack->bufLength)
  2731.                 pComPack->desiredTransferSize &= 0xfffffffe;
  2732. /* ATA-4 Rev.18: shall be even */
  2733.         }
  2734.     else
  2735.         {
  2736.         pComPack->dma = FALSE;
  2737.         pComPack->desiredTransferSize = 0;
  2738.         }
  2740.     semTake (&pCtrl->muteSem, WAIT_FOREVER);
  2742. retryPktCmd:
  2744.     error = 0;
  2746.     if (ataPiPktCmdExec (pAtapiDev, pComPack) == OK)
  2747.         {
  2749.         /* Check the Completion Status */
  2751.         if ( (pAtapiDev->status & ATA_STAT_ERR) == 0 )
  2752.             goto okPktCmd;
  2754.         /* If Error, Read Error Register */
  2756.         error = ATA_IO_BYTE_READ (ATAPI_ERROR);
  2758.         switch (error & ERR_SENSE_KEY)
  2759.             {
  2760.             case SENSE_NO_SENSE:
  2761.                 pAtapiDev->errNum = 11;
  2762.                 break;
  2764.             case SENSE_RECOVERED_ERROR:
  2766.                 if (pAtapiDev->pBuf < pAtapiDev->pBufEnd)
  2767.                     { /* not medium access commands */
  2768.                     pAtapiDev->errNum = 12;
  2769.                     break;
  2770.                     }
  2771.                 else
  2772.     /*
  2773.                      * Mode parameters can specify transfer disabling on 
  2774.                      * recovered error !!!) 
  2775.                      */
  2777.                     goto okPktCmd;
  2779.             case SENSE_NOT_READY:
  2780.                 pAtapiDev->errNum = 13;
  2781.                 break;
  2783.             case SENSE_MEDIUM_ERROR:
  2784.                 pAtapiDev->errNum = 14;
  2785.                 break;
  2787.             case SENSE_HARDWARE_ERROR:
  2788.                 pAtapiDev->errNum = 15;
  2789.                 break;
  2791.             case SENSE_ILLEGAL_REQUEST:
  2792.                 pAtapiDev->errNum = 16;
  2793.                 break;
  2795.             case SENSE_UNIT_ATTENTION:
  2796.                 /*
  2797.                  * Medium may have changed, or Power on or Reset occured, or
  2798.                  * Mode parameter changed
  2799.                  */
  2801.                 pAtapiDev->errNum = 17;
  2802.                 break;
  2804.             case SENSE_DATA_PROTECT:
  2805.                 pAtapiDev->errNum = 18;
  2806.                 break;
  2808.             case SENSE_ABBORTED_COMMAND:
  2809.                 pAtapiDev->errNum = 19;
  2810.                 break;
  2812.             case SENSE_MISCOMPARE:
  2813.                 pAtapiDev->errNum = 20;
  2814.                 break;
  2816.             default:
  2817.                 pAtapiDev->errNum = 0;
  2818.                 break;
  2820.             }
  2822.         ATA_DEBUG_MSG (1, "ataPiPktCmd%d/%d: ERROR: %s: status=0x%x dev=0x%x "
  2823.                        "error=0x%xn", pAtapiDev->ctrl, device, 
  2824.                        ataErrStrs[pAtapiDev->errNum], pAtapiDev->status, 
  2825.                        ATA_IO_BYTE_READ(ATAPI_D_SELECT), error);
  2826.         }
  2828.     /*
  2829.      * Execute a request sense command to try to find out more about what 
  2830.      * went wrong (and clear a unit attention)? 
  2831.      */
  2833.     if (error != 0)
  2834.         {
  2835.         /* Test for transition from NOT READY to READY */
  2837.         if ((error & ERR_SENSE_KEY) == SENSE_UNIT_ATTENTION)
  2838.             {
  2839.             pDrive->state = ATA_DEV_MED_CH;
  2840.             pAtapiDev->blkDev.bd_readyChanged = TRUE;
  2841.             }
  2843.         else if ( ataPiReqSense(pAtapiDev) == OK )
  2844.     {
  2846.     if (++retryCount < ataRetry)
  2847. {
  2848.                 pDrive->state = ATA_DEV_OK;
  2849.                 pAtapiDev->blkDev.bd_readyChanged = FALSE;
  2850.                 pAtapiDev->errNum = 0;
  2851. error = 0;
  2853. goto retryPktCmd;
  2854. }
  2855.             }
  2856.         }
  2857.     else
  2858.         error = -1;
  2860.     if ( (error & ERR_SENSE_KEY) != SENSE_UNIT_ATTENTION )
  2861.         {
  2862.         ataPiInit (pAtapiDev->ctrl, device);
  2864.         if (++retryCount < ataRetry)
  2865.             goto retryPktCmd;
  2867.         }
  2869.     semGive (&pCtrl->muteSem);
  2871.     (void)errnoSet (S_ioLib_DEVICE_ERROR);
  2873.     return error;
  2875. okPktCmd:
  2877.     semGive (&pCtrl->muteSem);
  2879.     return (SENSE_NO_SENSE); 
  2880.     } /* ataPiPktCmd */
  2882. /*******************************************************************************
  2883. *
  2884. * ataPiTestUnitRdy - issue a TEST UNIT READY command to a ATAPI device
  2885. *
  2886. * This routine issues a TEST UNIT READY command to a specified ATAPI device.
  2887. *
  2888. * RETURNS: OK, or ERROR if the command fails.
  2889. */
  2890.  
  2891. LOCAL STATUS ataPiTestUnitRdy
  2892.     (
  2893.     ATA_DEV     *pAtapiDev
  2894.     )
  2895.     {
  2896.     ATAPI_CMD atapiCmd;
  2897.     int  i;
  2898.     int error;
  2900.     ATA_DEBUG_MSG (2, "ataPiTestUnitRdy%d/%d: n", pAtapiDev->ctrl, 
  2901.                    pAtapiDev->drive, 0, 0, 0, 0);
  2903.     /* build a TEST UNIT READY command and execute it */
  2905.     atapiCmd.cmdPkt[0] = CDROM_CMD_TEST_UNIT_READY;
  2907.     for (i = 1; i < 12; i++)
  2908.         atapiCmd.cmdPkt[i] = 0;
  2910.     atapiCmd.ppBuf  = NULL;
  2911.     atapiCmd.bufLength  = 0;
  2912.     atapiCmd.direction  = NON_DATA;
  2913.     atapiCmd.desiredTransferSize = 0;
  2914.     atapiCmd.dma  = FALSE;
  2915.     atapiCmd.overlap  = FALSE;
  2917.     i = 0;
  2919.     do  {
  2920.         error = ataPiPktCmd (pAtapiDev, &atapiCmd) & ERR_SENSE_KEY;
  2922.         if ( ((error != SENSE_NO_SENSE) && (error != SENSE_UNIT_ATTENTION)) ||
  2923.              (++i > 5) ) /* drive may queue unit attention conditions */
  2924.             {
  2925.             return (ERROR); /* problem with the device is detected */
  2926.             }
  2928.         } while (error != SENSE_NO_SENSE);
  2930.     ATA_DEBUG_MSG (2, "ataPiTestUnitRdy%d/%d: Okn", pAtapiDev->ctrl, 
  2931.                    pAtapiDev->drive, 0, 0, 0, 0);
  2933.     return (OK);
  2934.     } /* ataPiTestUnitRdy */
  2936. /*******************************************************************************
  2937. *
  2938. * ataPiReadCapacity - issue a READ_CAPACITY command to a ATAPI device
  2939. *
  2940. * This routine issues a READ_CAPACITY command to a specified ATAPI device.
  2941. *
  2942. * RETURN: OK, or ERROR if the command fails.
  2943. */
  2945. LOCAL STATUS ataPiReadCapacity
  2946.     (
  2947.     ATA_DEV     *pAtapiDev
  2948.     )
  2949.     {
  2950.     BLK_DEV     *pBlkDev = &pAtapiDev->blkDev;
  2951.     ATAPI_CMD atapiCmd;
  2952.     UINT8 resultBuf[8];
  2953.     char        *pBuf = (char *)resultBuf;
  2954.     int i;
  2956.     ATA_DEBUG_MSG (2, "ataPiReadCapacity%d/%d: n", pAtapiDev->ctrl, 
  2957.                    pAtapiDev->drive, 0, 0, 0, 0);
  2959.     /* build a READ CD-ROM CAPACITY command and execute it */
  2961.     atapiCmd.cmdPkt[0] = CDROM_CMD_READ_CDROM_CAP;
  2963.     for (i = 1; i < 12; i++)
  2964.         atapiCmd.cmdPkt[i] = 0;
  2966.     atapiCmd.ppBuf  = &pBuf;
  2967.     atapiCmd.bufLength  = 8;
  2968.     atapiCmd.direction  = IN_DATA;
  2969.     atapiCmd.desiredTransferSize = 8;
  2970.     atapiCmd.dma  = FALSE;
  2971.     atapiCmd.overlap  = FALSE;
  2973.     if (ataPiPktCmd (pAtapiDev, &atapiCmd) != SENSE_NO_SENSE)
  2974.         return (ERROR);
  2976.     pBlkDev->bd_nBlocks = 0;
  2977.     pBlkDev->bd_bytesPerBlk = 0;
  2979.     for (i = 0; i < 4; i++)
  2980.         pBlkDev->bd_nBlocks += ((ULONG)resultBuf[i]) << (8 * (3 - i));
  2982.     pBlkDev->bd_nBlocks++;                 /* ULONG blocks on device */
  2983.     pBlkDev->bd_blksPerTrack = pBlkDev->bd_nBlocks; 
  2984.                                            /* ULONG blocks per track */
  2985.     for (i = 4; i < 8; i++)
  2986.         pBlkDev->bd_bytesPerBlk += ((ULONG)resultBuf[i]) << (8 * (7 - i));
  2987.                                            /* ULONG bytes per block */
  2989.     ATA_DEBUG_MSG (2, "ataPiReadCapacity%d/%d: Ok: nBlocks=%d bytesPerBlk=%dn",
  2990.                    pAtapiDev->ctrl, pAtapiDev->drive, pBlkDev->bd_nBlocks, 
  2991.                    pBlkDev->bd_bytesPerBlk, 0, 0);
  2993.     return (OK);
  2994.     } /* ataPiReadCapacity */
  2996. /*******************************************************************************
  2997. *
  2998. * ataPiBlkRd - read one or more blocks from a ATAPI CD-ROM disk
  2999. *
  3000. * This routine reads one or more blocks from the specified device,
  3001. * starting with the specified block number.
  3002. *
  3003. * RETURNS: OK, ERROR if the read command didn't succeed.
  3004. */
  3006. LOCAL STATUS ataPiBlkRd
  3007.     (
  3008.     ATA_DEV     *pAtapiDev,
  3009.     int         startBlk,
  3010.     int         nBlks,
  3011.     char        *pBuf
  3012.     )
  3013.     {
  3014.     ATA_CTRL    *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  3015.     ATA_DRIVE   *pDrive = &pCtrl->drive[pAtapiDev->drive];
  3016.     ATAPI_CMD atapiCmd;
  3017.     int i;
  3019.     char *pUpdatedBuf = pBuf;
  3021.     ATA_DEBUG_MSG (2, "ataPiBlkRd%d/%d: state=0x%x startBlk=%d nBlks=%d pBuf=%p"
  3022.                    "n", pAtapiDev->ctrl, pAtapiDev->drive, pDrive->state, 
  3023.                    startBlk, nBlks, pBuf);
  3025.     if (!pCtrl->installed)
  3026.         return (ERROR);
  3028.     if (pDrive->state != ATA_DEV_OK)
  3029.         return (ERROR);
  3031.     /* Sanity check */
  3033.     if ( (startBlk >= pAtapiDev->blkDev.bd_nBlocks) || 
  3034.          ((startBlk + nBlks) >= pAtapiDev->blkDev.bd_nBlocks) )
  3035.         {
  3036.         ATA_DEBUG_MSG (1, "ataPiBlkRd%d/%d ERROR: block numbers must be in "
  3037.                        "range 0 - %dn", pAtapiDev->ctrl, pAtapiDev->drive, 
  3038.                        (pAtapiDev->blkDev.bd_nBlocks - 1), 0, 0, 0);
  3040.         return ERROR;
  3041.         }
  3043.     /* Fill Command Packet */
  3045.     atapiCmd.cmdPkt[0] = CDROM_CMD_READ_12;
  3046.     atapiCmd.cmdPkt[1] = 0; /* Reserved */
  3048.     /* clear bytes 2 - 9 */
  3050.     *(u_char *)(&atapiCmd.cmdPkt[2]) = 0; 
  3051.     *(u_char *)(&atapiCmd.cmdPkt[3]) = 0;
  3052.     *(u_char *)(&atapiCmd.cmdPkt[4]) = 0;
  3053.     *(u_char *)(&atapiCmd.cmdPkt[5]) = 0;
  3054.     *(u_char *)(&atapiCmd.cmdPkt[6]) = 0; 
  3055.     *(u_char *)(&atapiCmd.cmdPkt[7]) = 0; 
  3056.     *(u_char *)(&atapiCmd.cmdPkt[8]) = 0; 
  3057.     *(u_char *)(&atapiCmd.cmdPkt[9]) = 0; 
  3059.     for (i = 2; i < 6; i++)
  3060.         atapiCmd.cmdPkt[i] += (UINT8)( startBlk >> (8 * (5 - i)) );
  3062.     for (i = 6; i < 10; i++)
  3063.         atapiCmd.cmdPkt[i] += (UINT8)( nBlks >> (8 * (9 - i)) );
  3065.     atapiCmd.cmdPkt[10] = 0; /* Reserved */
  3066.     atapiCmd.cmdPkt[11] = 0; /* Reserved */
  3068.     i = nBlks * pAtapiDev->blkDev.bd_bytesPerBlk;
  3070.     atapiCmd.ppBuf  = &pUpdatedBuf;
  3071.     atapiCmd.bufLength  = i;
  3072.     atapiCmd.direction  = IN_DATA;
  3073.     atapiCmd.desiredTransferSize = i;
  3074.     atapiCmd.dma  = FALSE;
  3075.     atapiCmd.overlap  = FALSE;
  3077.     /* Execute Packet Command */
  3079.     if (ataPiPktCmd (pAtapiDev, &atapiCmd) != SENSE_NO_SENSE)
  3080.         return (ERROR);
  3082.     ATA_DEBUG_MSG (2, "ataPiBlkRd%d/%d: Okn", pAtapiDev->ctrl, 
  3083.                    pAtapiDev->drive, 0, 0, 0, 0);
  3085.     return (OK);
  3086.     } /* ataPiBlkRd */
  3088. /*******************************************************************************
  3089. *
  3090. * ataPiReset - reset a ATAPI CD-ROM disk controller
  3091. *
  3092. * This routine resets a ATAPI CD-ROM disk controller.
  3093. *
  3094. * RETURNS: OK, or ERROR.
  3095. */
  3097. LOCAL STATUS ataPiReset
  3098.     (
  3099.     ATA_DEV   *pAtapiDev
  3100.     )
  3101.     {
  3102.     ATA_CTRL  *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  3103.     ATA_DRIVE *pDrive = &pCtrl->drive[pAtapiDev->drive];
  3105.     ATA_DEBUG_MSG (2, "ataPiReset%d/%d: state=0x%xn", pAtapiDev->ctrl, 
  3106.                    pAtapiDev->drive, pDrive->state, 0, 0, 0);
  3109.     if (!pCtrl->installed)
  3110.         return (ERROR);
  3112.     if (pDrive->state != ATA_DEV_MED_CH)
  3113.         { /* power on, entire drive changed, or failure recovering */
  3114.         semTake (&pCtrl->muteSem, WAIT_FOREVER);
  3116.         if (pDrive->state != ATA_DEV_INIT)
  3117.             { /* higher level tried to recover after failure */
  3119.             if (pDrive->Reset (pAtapiDev->ctrl, pAtapiDev->drive) != OK)
  3120.                 {
  3121.                 semGive (&pCtrl->muteSem);
  3122.                 return (ERROR);
  3123.                 }
  3124.            }
  3126.         if (ataDriveInit (pAtapiDev->ctrl, pAtapiDev->drive) != OK)
  3127.             {
  3128.             semGive (&pCtrl->muteSem);
  3129.             return (ERROR);
  3130.             }
  3132.         semGive (&pCtrl->muteSem);
  3133.         }
  3135.     /* Identify medium */
  3137.     if (ataPiTestUnitRdy (pAtapiDev) != OK)
  3138.         return (ERROR);
  3140.     if (ataPiReadCapacity (pAtapiDev) != OK)
  3141.         {
  3142.         pAtapiDev->blkDev.bd_readyChanged = TRUE;
  3143.         return (ERROR);
  3144.         }
  3145.     else
  3146.         pDrive->state = ATA_DEV_OK;
  3148.     ATA_DEBUG_MSG (2, "ataPiReset%d/%d: Okn", pAtapiDev->ctrl, 
  3149.                    pAtapiDev->drive, 0, 0, 0, 0);
  3151.     return (OK);
  3152.     } /* ataPiReset */
  3154. /*******************************************************************************
  3155. *
  3156. * ataPiIoctl - do device specific control function
  3157. *
  3158. * This routine is called when the file system cannot handle an ioctl()
  3159. * function.
  3160. *
  3161. * RETURNS:  OK or ERROR.
  3162. */
  3164. LOCAL STATUS ataPiIoctl
  3165.     (
  3166.     ATA_DEV     *pAtapiDev,
  3167.     int         function,
  3168.     int         arg
  3169.     )
  3170.     {
  3171.     ATA_CTRL    *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  3172.     ATA_DRIVE   *pDrive = &pCtrl->drive[pAtapiDev->drive];
  3173.     int status = ERROR;
  3175.     ATA_DEBUG_MSG (2, "ataPiIoctl%d/%d: state=0x%x func=%d arg=%dn", 
  3176.                    pAtapiDev->ctrl, pAtapiDev->drive, pDrive->state, function, 
  3177.                    arg, 0);
  3179.     if (!pCtrl->installed)
  3180.         return (ERROR);
  3182.     if (pDrive->state != ATA_DEV_OK)
  3183.         return (ERROR);
  3185.     ATA_DEBUG_MSG (2, "ataPiIoctl%d/%d: Okn", pAtapiDev->ctrl, 
  3186.                    pAtapiDev->drive, 0, 0, 0, 0);
  3188.     return status;
  3189.     } /* ataPiIoctl */
  3191. /*******************************************************************************
  3192. *
  3193. * ataPiStatusChk - check device status
  3194. *
  3195. * This routine issues a TEST UNIT READY command to a ATAPI device to detect a
  3196. * medium change.  It called by filesystems before doing open()'s or creat()'s.
  3197. *
  3198. * RETURNS: OK or ERROR.
  3199. */
  3201. LOCAL STATUS ataPiStatusChk
  3202.     (
  3203.     ATA_DEV   *pAtapiDev /* pointer to device descriptor */
  3204.     )
  3205.     {
  3206.     ATA_CTRL  *pCtrl = &ataCtrl[pAtapiDev->ctrl];
  3207.     ATA_DRIVE *pDrive = &pCtrl->drive[pAtapiDev->drive];
  3209.     ATA_DEBUG_MSG (2, "ataPiStatusChk%d/%d: state=%d readyChanged=%dn", 
  3210.                    pAtapiDev->ctrl, pAtapiDev->drive, pDrive->state, 
  3211.                    pAtapiDev->blkDev.bd_readyChanged, 0, 0);
  3213.     if (!pCtrl->installed)
  3214.         return (ERROR);
  3216.     if ( (pDrive->state != ATA_DEV_MED_CH) && (pDrive->state != ATA_DEV_OK)  )
  3217.         return (ERROR);
  3219.     if (ataPiTestUnitRdy (pAtapiDev) != OK)
  3220.         return (ERROR);
  3222.     /* Device OK, medium may be changed, check Medium Change */
  3224.     if (pDrive->state == ATA_DEV_MED_CH || pAtapiDev->blkDev.bd_readyChanged )
  3225.         {
  3227.         if (ataPiReadCapacity (pAtapiDev) != OK)
  3228.             {
  3229.             pAtapiDev->blkDev.bd_readyChanged = TRUE;
  3230.             return (ERROR);
  3231.             }
  3232.         else
  3233.             pDrive->state = ATA_DEV_OK;
  3234.         }
  3236.     ATA_DEBUG_MSG (2, "ataPiStatusChk%d/%d: Ok: state=%d readyChanged=%dn", 
  3237.                    pAtapiDev->ctrl, pAtapiDev->drive, pDrive->state, 
  3238.                    pAtapiDev->blkDev.bd_readyChanged, 0, 0);
  3240.     return (OK); /* open or create operations can continue */
  3241.     } /* ataPiStatusChk */
  3247. #ifdef ATA_DEBUG
  3249. /* DEBUG functions */
  3251. STATUS ataIntCheck (ATA_DEV * pAtapiDev)
  3252. {
  3253. ATA_CTRL *  pCtrl   = &ataCtrl[pAtapiDev->ctrl];
  3254. int         semStatus;
  3256. semStatus = semTake (&pCtrl->syncSem, 1);
  3257. if (semStatus == ERROR)
  3258.     return ERROR;
  3260. return OK;
  3261. }
  3263. void ataSemGive (ATA_DEV * pAtapiDev)
  3264. {
  3265. ATA_CTRL *  pCtrl   = &ataCtrl[pAtapiDev->ctrl];
  3267. semGive (&pCtrl->syncSem);
  3268. }
  3270. void ataTimeoutSet (int ctrl, int val)
  3271. {
  3272. ATA_CTRL *pCtrl = &ataCtrl[ctrl];
  3274. pCtrl->semTimeout = val;
  3275. pCtrl->wdgTimeout = val;
  3276. }
  3277. #endif