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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
hdd_if.c
资源名称：8202s.rar　[点击查看]
上传用户：poi891205
上传日期：2013-07-15
资源大小：9745k
文件大小：11k
源码类别：

DVD

开发平台：

C/C++

hdd_if.c：源码内容
  1. /*=================================================================
  3.   hdd_if.c: Some ATA Control for HDD
  4.   
  6.   2002-04-04 10:00AM Created  by cyue
  7.   2002-04-28 10:00AM modified by Verdure
  8.   2002-06-12 08:42AM Modified by cyue
  9.   
  10. Copyright(c)2000-2002 by Worldplus Technology (ShenZhen) Co., Ltd.
  11. ALL RIGHTS RESERVED
  12. =================================================================*/
  13. #include "misc.h"
  14. #include "set.h"
  15. #include "global.h"
  16. #include "ata.h"
  17. #include "atapi_if.h"
  18. #include "image.h"
  19. #include "fs.h"
  20. #include "func.h"
  21. #include "cderr.h"
  22. #include "avd.h"
  23. #include "hdd_if.h"
  25. #include "hdd_if.h"
  27. #ifdef USE_HDD // cyue: Skip code if not use hdd!!
  29. #define DBG_HDD
  31. #ifndef DBG_HDD
  32. #undef printf
  33. #undef print_block
  34. #define printf(f, a...) {}
  35. #define print_block(x,y) {}
  36. #endif
  39. //extern UINT8 CSSEnable;
  41. #define   POLLING_MODE
  42. #ifdef  POLLING_MODE //for new D version chip
  43. #define DVDDSP_CONFIG_DEF ATAPI_ADV_POLLING
  44. #else
  45. #define DVDDSP_CONFIG_DEF ATAPI_INTR_MODE
  46. #endif
  48. #define SHORT_TIME_OUT (1*90)//1 sec //4 sec
  49. #define NORMAL_TIME_OUT (7*90)//7 sec 
  50. #define LONG_TIME_OUT (8*90)//8 sec
  51. #define MAX_TIME_OUT (10*90)//10 sec
  54. /* Check whether HD present */
  55. UINT8 HDD_DEV_Existence(void)
  56. {
  57. /* read Status register until BSY=0 & DRQ=0 */
  58. if(atapi_chk_time_out(WAIT_DRQ_BSY_ZERO,NORMAL_TIME_OUT))  //wait 8sec
  59. {          
  60. printf("ATA BUS NOT READY!n");
  61. return ATAPI_ERROR;
  62. }
  64. atapi_reg_write(IDE_DEVICE_HEAD, HDD_DEV);
  66. /* read Status register until BSY=0 & DRQ=0 */
  67. if(atapi_chk_time_out(WAIT_DRQ_BSY_ZERO,NORMAL_TIME_OUT))
  68. {                   
  69. printf("HD NOT READY!!n");
  70. return ATAPI_ERROR;
  71. }  
  73. return 0;
  74. }
  77. /* Identify the device before issuing the command to a device */
  78. void HDD_DEV_Identify(void)
  79. {  
  80. while(atapi_reg_read(IDE_STATUS) & (STATUS_BSY | STATUS_DRQ)) ;
  81. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV);
  82. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  83. while(atapi_reg_read(IDE_STATUS) & (STATUS_BSY | STATUS_DRQ)) ;
  84. return;
  85. }
  88. //int ATA_Read(UINT32 lba,UINT32 seccnt)
  89. //UINT8 atapi_do_packet(UINT8 *pck)
  90. UINT8 hdd_do_packet( UINT32 wait_time, UINT8 *pck)
  91. {
  92.     //UINT32 wait_time=0;
  93. //printf(__FUNCTION__":");
  94.     //printf("--sec=%d,lba=%lxnn",*(pck+9),
  95.     //    (*(pck+2)<<24) | (*(pck+3)<<16) | (*(pck+4)<<8) | *(pck+5) );
  97.     if (dev_status_flag&READ_PRESENT_DATA)
  98. wait_time=SHORT_TIME_OUT;
  99.     else
  100. wait_time=NORMAL_TIME_OUT;
  101.     //HDD_DEV_Identify();
  102.     if (atapi_chk_time_out(WAIT_ALT_NO_BUSY,wait_time))
  103.     {                   
  104. //printf(__FUNCTION__" ==> Timout 1n");
  105. cderr_handler(CDERR_ATA_BUSY);
  106. return ATAPI_ERROR;
  107.     }
  109.     atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV|(*(pck+2)&0x0f));
  110.     atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  111.     atapi_reg_write(IDE_SECTOR_CNT,*(pck+9));
  112.     atapi_reg_write(IDE_SECTOR_NUM,*(pck+5));
  113.     atapi_reg_write(IDE_CYLINDER_LO,*(pck+4));
  114.     atapi_reg_write(IDE_CYLINDER_HI,*(pck+3));
  115.     atapi_reg_write(IDE_COMMAND,0x20);
  116.     atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  118. if (atapi_chk_time_out(WAIT_IRQ,MAX_TIME_OUT))
  119. {                   
  120. //printf(__FUNCTION__" ==>< IRQ Timout >n");
  121. cderr_handler(CDERR_ATA_BUSY);
  122. return ATAPI_ERROR;
  123. }
  124. if (atapi_chk_time_out(WAIT_STATUS_NO_BSY,wait_time))
  125. {                   
  126. //printf(__FUNCTION__" ==> Timout 4n");
  127. cderr_handler(CDERR_ATA_BUSY);
  128. return ATAPI_ERROR;
  129. }
  130.     atapi_reg_read(IDE_ALT_STATUS);
  131.     if (atapi_is_error() != 0) 
  132.     {
  133.         //printf("send_data in do_packet errorn");
  134.         return ATAPI_ERROR;
  135.     }
  137.     return ATAPI_OK;
  138. } 
  141. int HDD_PIO_ReadData(UINT8 *buff)
  142. {
  143.     int i;
  144.     while(1)
  145.     {
  146. atapi_reg_read(IDE_ALT_STATUS);
  147.         switch(atapi_reg_read(IDE_STATUS)&(STATUS_BSY|STATUS_DRQ))
  148. {
  149. case STATUS_DRQ: //Need Data Transfer
  150. for(i=0;i<256;i++) // Sector Block Transfer
  151. {
  152. register UINT16 data=atapi_reg_read(IDE_DATA);
  153. *buff++=data&0xFF;
  154. *buff++=data>>8;
  155. }
  156. break;
  158. case 0: // Done
  159. atapi_reg_read(IDE_ALT_STATUS);
  160. atapi_reg_read(IDE_STATUS);
  161. return 0;
  163. case STATUS_BSY: // ATA Device Busy
  164. break;
  166. default:
  167.     break;
  168. }
  169.     }
  170.     return 0;
  171. }
  174. int HDD_PIO_WriteData(UINT8 *buff)
  175. {
  176.     int i;
  177.     while(1)
  178.     {
  179. switch(atapi_reg_read(IDE_STATUS)&(STATUS_BSY|STATUS_DRQ))
  180. {
  181. case STATUS_DRQ: //Need Data Transfer
  182. for(i=0;i<256;i++) // Sector Block Transfer
  183. {
  184. register UINT16 data= *buff+(*(buff+1))*256;
  185. atapi_reg_write(IDE_DATA,data);
  186. buff+=2;
  187. }
  188. break;
  190. case 0: // Done
  191. atapi_reg_read(IDE_ALT_STATUS);
  192. atapi_reg_read(IDE_STATUS);
  193. return 0;
  195. case STATUS_BSY: // ATA Device Busy
  196. break;
  198. default:
  199.     break;
  200. }
  201.     }
  202.     return 0;
  203. }
  206. int HDD_ReadSec(UINT8 *buff,UINT32 lba,int seccnt)
  207. {
  208. //printf(__FUNCTION__":nn");
  210. HDD_DEV_Identify();
  211. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV|(lba>>24));
  212. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  213. atapi_reg_write(IDE_SECTOR_CNT,seccnt);
  214. atapi_reg_write(IDE_SECTOR_NUM,lba&0xFF);
  215. atapi_reg_write(IDE_CYLINDER_LO,(lba>>8)&0xFF);
  216. atapi_reg_write(IDE_CYLINDER_HI,(lba>>16)&0xFF);
  217. atapi_reg_write(IDE_COMMAND,0x20);
  218. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  220. return HDD_PIO_ReadData(buff);
  221. } 
  223. int HDD_WriteSec(UINT8 *buff,UINT32 lba,int seccnt)
  224. {
  225. //printf(__FUNCTION__":nn");
  227. HDD_DEV_Identify();
  228. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV|(lba>>24));
  229. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  230. atapi_reg_write(IDE_SECTOR_CNT,seccnt);
  231. atapi_reg_write(IDE_SECTOR_NUM,lba&0xFF);
  232. atapi_reg_write(IDE_CYLINDER_LO,(lba>>8)&0xFF);
  233. atapi_reg_write(IDE_CYLINDER_HI,(lba>>16)&0xFF);
  234. atapi_reg_write(IDE_COMMAND,0x30);
  235. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  237. return HDD_PIO_WriteData(buff);
  238. } 
  241. /* HD go to Sleep,and must wake it up by HD Reset */
  242. void HDD_Sleep(void)
  243. {
  244. //printf(__FUNCTION__":nn");
  246. HDD_DEV_Identify();
  247. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV);
  248. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  249. atapi_reg_write(IDE_COMMAND,0x99);
  250. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns    
  251. while(atapi_reg_read(IDE_STATUS)&STATUS_BSY) ;
  253. printf("NOW HD SLEEP!!!");
  254. }
  257. UINT32 HDD_GetMaxLBA()
  258. {
  259. //printf(__FUNCTION__":nn");
  261. HDD_DEV_Identify();
  262. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV);
  263. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  264. atapi_reg_write(IDE_COMMAND,0xF8);
  265. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns   
  266. while(atapi_reg_read(IDE_STATUS)&STATUS_BSY);
  268. printf("n--GetLBA: %x--n", atapi_reg_read(IDE_STATUS)); 
  269. return  ( (UINT32)atapi_reg_read(IDE_SECTOR_NUM)
  270. +((UINT32)atapi_reg_read(IDE_CYLINDER_LO)<<8)
  271. +((UINT32)atapi_reg_read(IDE_CYLINDER_HI)<<16)
  272. +(((UINT32)atapi_reg_read(IDE_DEVICE_HEAD)&0x0F)<<24) );
  273. }
  276. int HDD_GetCHS(UINT8* buff)
  277. {
  278. //printf(__FUNCTION__":nn");
  280. HDD_DEV_Identify();
  281. atapi_reg_write(IDE_DEVICE_HEAD,HDD_DEV);
  282. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  283. atapi_reg_write(IDE_COMMAND,0xEC);
  284. atapi_reg_read(IDE_ALT_STATUS);  //delay 400ns
  285.     
  286. return HDD_PIO_ReadData(buff);
  287. }
  290. void  HDD_Reset(void)
  291. {
  292. //printf(__FUNCTION__":nn");
  294. #ifdef DVD728
  295.     regs0->dvddsp_public = PIO_MODE4|ATAPI_ADV_POLLING;
  296. #else
  297. regs0->dvddsp_config = PIO_MODE4|ATAPI_ADV_POLLING;
  298. #endif
  299. atapi_rst(DSP_HOST_RESET|ATA_HW_RESET);
  300. #ifdef DVD728
  301. regs0->dvddsp_public = PIO_MODE4|ATAPI_ADV_POLLING;
  302. #else
  303. regs0->dvddsp_config = PIO_MODE4|ATAPI_ADV_POLLING;
  304. #endif
  305. while(atapi_reg_read(IDE_ALT_STATUS) & (STATUS_BSY|STATUS_ERR)) ;
  306. printf("n--Reset: %x--n", atapi_reg_read(IDE_STATUS));
  307. delay(6000);
  308. }
  311. void print_sector(UINT8 *buff)
  312. {
  313. int i,j;
  314. for(i=0;i<0x20;i++)
  315. {
  316. printf("n  %02x0: ",i);
  317. for(j=0;j<0x10;j++)
  318. {
  319. printf(" %02x",*buff++);
  320. }
  321. }
  322. }
  325. void ata_init(void)
  326. {
  327. #ifdef DVD728
  328. regs0->dvddsp_public = PIO_MODE4|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  329. #else
  330. regs0->dvddsp_config = PIO_MODE4|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  331. #endif
  332.     atapi_rst(DSP_HOST_RESET|ATA_HW_RESET);
  333. #ifdef DVD728
  334.     regs0->dvddsp_public = PIO_MODE4|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  335. #else
  336. regs0->dvddsp_config = PIO_MODE4|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  337. #endif
  338. delay(1);
  340. printf("ATA Test Rdyn");
  341. }
  344. //UINT8 atapi_block_read(UINT32 lba, UINT32 len)
  345. UINT8 hdd_block_read(UINT32 lba, UINT32 len)
  346. {
  347. #if 0 
  348.     if (atapi_is_error() == ATAPI_ERROR)
  349.     {   
  350.         printf("enter ata_block_read errorn");
  351.         cderr_handler(CDERR_DAT_DISCONTINUE);
  352.         return ATAPI_ERROR;
  353.     }
  354.     
  355.     if (is_user_opened())
  356.     {
  357.         printf("USER OPEN!!!n");
  358.         return ATAPI_ERROR;
  359.     }
  360. #endif
  361.     //printf("HDD_block_read:%lx---%lxn",lba,len);
  362.     //regs0->dvddsp_config = ATAPI_DEVICE ;// | ATAPI_FIFO_FLUSH | ATAPI_CSS_ENABLE;
  363.     dev_status_flag|=READ_PRESENT_DATA;
  364.     //ATA_Read(lba, len*4);
  365.     atapi_p_read_12(lba, len);
  367. #ifdef DVD728
  368.     regs0->dvddsp_public = PIO_MODE4|DVDDSP_CONFIG_DEF;
  369. #else
  370.     regs0->dvddsp_config = PIO_MODE4|DVDDSP_CONFIG_DEF;
  371. #endif
  372.     regs0->dvddsp_blocksize = 256;
  373.     regs0->dvddsp_blocklength = len;//*8;
  374.     //regs0->dvddsp_function = (IDE_DATA<<8) | ATAPI_READ | DATA_MODE | HOST_START ;
  376.     if (atapi_reg_read(IDE_STATUS) == 0x50) 
  377.     { //DRQ=0,BSY=0,DRDY=1,DSC=1
  378. printf("skip directly!n");
  379. return ATAPI_ERROR;
  380.     } 
  381.     else 
  382.     {    
  383.         regs0->dvddsp_function = (IDE_DATA<<8) | ATAPI_READ | DATA_MODE | HOST_START ;
  384.     }
  385.     
  386.     while ((regs0->dvddsp_function&HOST_BUSY) != 0)  ; 
  387.     return ATAPI_OK;
  388. }
  391. #if 0
  392. UINT8 atapi_receive_data(UINT8 *p, int n)
  393. {
  394.     UINT16 USER_DATA;
  395.     int i,j;
  397.     /*****
  398.     * Host: read Alternate status register and ignore results. This
  399.     * prevent polling host from reading status before it is valid
  400.     ******/
  401.     atapi_reg_read(IDE_ALT_STATUS);
  402.     j = 0;
  403.     do
  404.     {
  405. /*****
  406. * Host: read Status register until BSY=0 & DRQ=1. Status register
  407. * is read to clear pending interrput
  408. *****/
  409. #ifdef POLLING_MODE
  410. if (atapi_chk_time_out(WAIT_DRQ_OK,LONG_TIME_OUT))
  411. {          
  412. //printf(__FUNCTION__" ==> Timout 1n");
  413. cderr_handler(CDERR_ATA_BUSY);
  414. return ATAPI_ERROR;
  415. }
  416. #else
  417. while ( (atapi_reg_read(IDE_STATUS) & STATUS_BSY) ||!(atapi_reg_read(IDE_STATUS) & STATUS_DRQ) ) 
  418. {
  419. WaitIRQ();
  420. }
  421. #endif
  422. printf("data length:n=%dn",n);
  423. i = 512;
  424. if (i > n)
  425. i = n;
  427. /*****
  428. * DRQ block transfer
  429. *****/
  430. for (; i > 0; i-=2)
  431. {
  432. USER_DATA = atapi_reg_read(IDE_DATA);
  433. *(p+j+1)  = USER_DATA >> 8;
  434. *(p+j)    = USER_DATA & 0xff;
  435. j += 2;
  436. n -= 2;
  437. }
  438.     } while (n != 0);
  440.     /*****
  441.     * Host: wait device to clear BSY=0, it indicates command is complete.
  442.     *****/
  443.     if (atapi_chk_time_out(WAIT_STATUS_NO_BSY,LONG_TIME_OUT))
  444.     {          
  445. //printf(__FUNCTION__" ==> Timout 2n");
  446. //cderr_handler(CDERR_ATA_BUSY);
  447. if (atapi_is_error()==0)
  448. {//printf(__FUNCTION__" ==> !!!!ATAPI ERROR n");}
  449. return ATAPI_ERROR;
  450.     }
  452.     /*****
  453.     * Host: read Alternate status register and ignore results. This 
  454.     * polling host from reading status before it is valid.
  455.     * Note - Device is command complete, it should perform its error routine if
  456.     * an error is reported
  457.     *****/
  458.     atapi_reg_read(IDE_ALT_STATUS);
  460.     return atapi_is_error();
  461. }
  462. #endif
  466. #endif //USE_HDD