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

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

DVD

开发平台：

C/C++

atapi_if720.c：源码内容
  1. /*=================================================================
  3. atapi_if.c: ATAPI INTERFACE
  5. 2000-01-01         Created  by 
  6. 2002-06-12 08:42AM Modified by cyue
  7. 2004-04-16         Modified by Terry
  9. Copyright(c)2000-2002 by Sunplus Technology (HsingChu) Co., Ltd.
  10.                    ALL RIGHTS RESERVED
  11. =================================================================*/
  14. //#define NPRINTF
  15. //#define NEPRINTF
  17. #include "config.h"
  18. #include "misc.h"
  19. #include "global.h"
  20. #include "ata.h"
  21. #include "image.h"
  22. #include "fs.h"
  23. #include "func.h"
  24. #include "cderr.h"
  25. #include "avd.h"
  26. #include "drv.h"
  28. #include "atapi_if.h"
  29. #include "pu8560.h"
  33. extern UINT8   bReadSubChannel; //Jeff 20020927
  34. extern UINT16  iBlockLen;
  35.  
  36. //#define UDETEST
  38. #ifndef DVDRELEASE
  39. //#define DBG_ATAPI
  40. #endif
  42. #ifndef DBG_ATAPI
  43. #undef  printf
  44. #undef  print_block
  45. #define printf(f, a...) do {} while (0)
  46. #define print_block(x,y) do {} while (0)
  47. #endif
  50. #define POLLING_MODE //if test interrupt mode, mark this define
  52. #ifdef DVD728
  54. #ifdef DVD_SERVO
  55. #define DVDDSP_CONFIG_DEF   ATA_INTR_MODE //ATAPI_INTR_MODE
  56. #else
  57. #define DVDDSP_CONFIG_DEF   ATA_POLLING_MODE //ATAPI_INTR_MODE
  58. #endif
  60. #define WaitIRQ()   while ((regs0->dvddsp_function & DEVICE_INT) == 0) ;//for test DRQ mode
  61. #else
  62. #define POLLING_MODE //if test interrupt mode, mark this define
  63. #define DVDDSP_CONFIG_DEF   ATAPI_ADV_POLLING
  64. #endif
  67. #define SHORT_TIME_OUT      400//4 sec
  68. #define NORMAL_TIME_OUT     700//7 sec 
  69. #define LONG_TIME_OUT       800//8 sec
  70. #define MAX_TIME_OUT       1000//10 sec
  72. /*
  73. * variable
  74. */
  75. /*UINT8 pc[12];
  76. UINT8 pc_rdata[32];*/
  77. UINT16  request_sense_flag;
  78. UINT8 DiscType = CDDVD;// 0: DISC_VCD, 1: DISC_DVD
  79. UINT8 CSSEnable = 0;
  82. /*
  83. * external function
  84. */
  85. UINT32 udf_find_anchor(void);
  86. void disp_fan_in(void);
  87. void flush_atapi(void);;
  88. void cppm_init( UINT32 );
  91. // for compatible issue
  92. int atapi_read_error(void)      {return 0;}
  93. int atapi_standby_mode(void)    {return 0;}
  95. #ifndef DVD_SERVO
  96. void SetIDETimeOut(UINT32 time) {}
  97. #endif
  99. #ifndef ROM_ATA_SHARE_BUS           
  100. UINT16
  101. atapi_reg_read(UINT8 addr)
  102. {   
  103.     UINT32 i=0;
  104.     
  105.     regs0->dvddsp_function = (addr<<8) | ATAPI_READ | REG_MODE | HOST_START;    
  106.     while ((regs0->dvddsp_function & HOST_BUSY) != 0)
  107.     {
  108.         i++;        
  109.         if(i>0xfffffff0)
  110.         {
  111.             printf(__FUNCTION__" ==> always busyn");
  112.             break;
  113.         }
  114.     }
  116.     //NowPrint("@");
  117.     if (addr == IDE_DATA)
  118.         return regs0->dvddsp_blocklength;
  119.     
  120.     return (UINT16) (regs0->dvddsp_function & 0xFF);
  121. }
  123. void
  124. atapi_reg_write(UINT8 addr, UINT16 data)
  125. {   
  126.     UINT32 i=0;
  127.     if (addr == IDE_DATA) {
  128.         regs0->dvddsp_blocklength = data;
  129.         regs0->dvddsp_function = (addr<<8) | ATAPI_WRITE | REG_MODE | HOST_START;
  130.     } else {
  131.         regs0->dvddsp_function = (data & 0x00FF) | 
  132.             (addr<<8) | ATAPI_WRITE | REG_MODE | HOST_START;
  133.     }
  135.     while ((regs0->dvddsp_function & HOST_BUSY) != 0) 
  136.     {
  137.         i++;        
  138.         if(i>0xfffffff0)
  139.         {
  140.             printf(__FUNCTION__" ==> always busyn");
  141.             break;
  142.         }
  143.     }
  144. }
  145. #endif
  147. #ifdef DVD728
  148. void read_device_signature(UINT8 dev)
  149. {
  150.     unsigned cylinder_hi;
  151.     unsigned sector_cnt;
  153.     printf("device %x sign.n", dev);
  155.     atapi_reg_write(IDE_DEVICE_HEAD, (dev) ? 0x10 : 0x00);
  156.     printf("tdevice%x's diag. code = %xn", dev, atapi_reg_read(IDE_ERROR));
  158.     sector_cnt = atapi_reg_read(IDE_SECTOR_CNT);
  159.     if (sector_cnt)
  160.     {
  161.         cylinder_hi = atapi_reg_read(IDE_CYLINDER_HI);
  162.         if (cylinder_hi == 0xeb) printf("implement PACKET commandn");
  163.         else if (cylinder_hi == 0x00) printf("NOT implement PACKET commandn");
  164.     }
  165.     else
  166.     {
  167.         printf("device%x occurs UNKNOWN read_device_signature %02xn", dev, sector_cnt);
  168.     }
  169. }
  170. #endif
  172. // ATAPI Procedure
  173. // return 1: ERR, 0: OK
  174. //inline UINT8 
  175. UINT8 
  176. atapi_is_error(void)
  177. {
  178. //  return (atapi_reg_read(IDE_STATUS) & STATUS_ERR);
  180.     if ((atapi_reg_read(IDE_STATUS) & STATUS_ERR) != 0) {
  181.         printf("atapi status error      n");
  182.         return ATAPI_ERROR;
  183.     }
  185.     return ATAPI_OK;
  186. }
  188. #ifdef DVD728
  189. UINT8
  190. atapi_rst(UINT8 mode)
  191. {
  192.     UINT16  old_config,i;
  193.     UINT16  status=0;
  195.     printf(__FUNCTION__": mode:%xnn",mode);
  196.     if (mode & DSP_HOST_RESET) {
  197.         if (mode & ATA_HW_RESET)
  198.             old_config = 0x0000;
  199.         else
  200.             old_config = regs0->dvddsp_public;
  202.         regs0->dvddsp_public =  old_config|ATAPI_DEVICE|ATAPI_HOST_RESET;
  203.         delay(1);   // assert RESET - at least 25us
  204.         regs0->dvddsp_public = old_config;
  205.         delay(5);   // negate_wait 2 ms
  207.         if(mode & ATA_HW_RESET)
  208.         {
  209.             regs0->dvddsp_ata_pio_cycle = 0x7764;       // set ATAPI_PIO_CYCLE, PIO-MODE4
  210.             regs0->dvddsp_ata_udma_cycle = 0x4924;      // set ATAPI_UDMA_CYCLE
  211.             regs0->dvddsp_ata_config = 0x0000 | ATA_INTR_MODE;
  213.             // setup UDE configuration (useless now)
  214.             regs0->dvddsp_ude_config = 0x0000;
  216.             regs0->dvddsp_public = ATAPI_DEVICE|ATAPI_DEV_HRESET;
  217.             delay(1);
  218.             regs0->dvddsp_public = ATAPI_DEVICE;
  219.             delay(5);
  221. #ifdef ROM_ATA_SHARE_BUS    
  222.                         #define RST_GPIO   4        
  223.             //atapi hw reset
  224.             
  225.             regs0->gpio_master[RST_GPIO/16] |= (0x1)<<(RST_GPIO%16);
  226.             regs0->gpio_oe[RST_GPIO/16]     |= (0x1)<<(RST_GPIO%16);// -> 0         
  227.             regs0->gpio_out[RST_GPIO/16]    &= ~((0x1)<<(RST_GPIO%16));// -> 0         
  228.                 
  229.                 printf("<o0 >n");
  230.                 
  231.                 delay(1);
  232.                 regs0->gpio_out[RST_GPIO/16]    |= ((0x1)<<(RST_GPIO%16));// -> 1                           
  233.                 printf("<o1 >n");
  234.                 delay(5);
  235.                 //while(1);
  236. #endif       
  237.             // select device
  238.             atapi_reg_write(IDE_DEVICE_HEAD, (DEV) ? 0x10: 0x00);
  239.             do {
  240.                 status = atapi_reg_read(IDE_STATUS);
  241.             } while (status & STATUS_BSY);
  242.             
  243.             atapi_reg_write(IDE_DEVICE_CTRL, 0x00);
  245.           
  246.             // read read_device_signature
  247.             //read_device_signature(1);
  248.             //read_device_signature(0);
  249.         }
  250.     }
  251.     if(mode&ATA_SW_RESET)
  252.     { 
  253.         atapi_reg_write(IDE_DEVICE_CTRL, 0x04);
  254.         delay(5);
  255.         atapi_reg_write(IDE_DEVICE_CTRL, 0x00);
  256.         
  257.         delay(3);
  258.         atapi_reg_write(IDE_DEVICE_HEAD, (DEV) ? 0x10: 0x00);
  259.         do {
  260.             status = atapi_reg_read(IDE_STATUS);
  261.         } while (status & STATUS_BSY);
  263.         regs0->dvddsp_ata_config = 0x0000 | ATA_INTR_MODE;
  264.         atapi_reg_write(IDE_DEVICE_CTRL, 0x00);
  265.         // set UDE config
  266.         regs0->dvddsp_ude_config = 0x0000;
  267.         
  268.         // read read_device_signature
  269.         //read_device_signature(1);
  270.         //read_device_signature(0);
  271.         
  272.         // set ATAPI_PIO_CYCLE, PIO-MODE4
  273.         regs0->dvddsp_ata_pio_cycle = 0x7764;
  274.         
  275.         // set ATAPI_UDMA_CYCLE
  276.         regs0->dvddsp_ata_udma_cycle = 0x4924;
  277. #if 0
  278.         if(atapi_chk_time_out(WAIT_STATUS_NO_BSY,LONG_TIME_OUT))
  279.         {           
  280.             printf(__FUNCTION__" ==> Timout 1n");          
  281.             return ATAPI_ERROR;
  282.         }
  283. #endif
  284.     }
  286.     if(mode&ATA_WAIT_RDY)
  287.     {//terry,2002/5/31 09:56PM, FUSS request: open must be avaible
  288.         //dev_status_flag|=ATAPI_RETRY_READY;
  289.         for(i=0;i<100;i++)
  290.         {    
  291.             if(atapi_p_test_unit_ready()==0)
  292.             {
  293.                 //dev_status_flag&=~ATAPI_RETRY_READY;
  294.                 return 0;//test unit ready
  295.             }    
  296.             delay(100);         
  297.         }
  298.         //dev_status_flag&=~ATAPI_RETRY_READY;
  299.         printf("!!!!!!STILL Not Readyn");
  300.         return ATAPI_ERROR;
  301.     }
  303.     return 0;
  304. }
  305. #else
  306. UINT8
  307. atapi_rst(UINT8 mode)
  308. {
  309.     UINT16 old_config,i;    
  310.     
  311.     printf(__FUNCTION__": reset mode:%xnn",mode);
  312.       
  313.     if(mode&DSP_HOST_RESET)
  314.     {
  315.         if(mode&ATA_HW_RESET)
  316.             old_config=0;
  317.         else
  318.             old_config=regs0->dvddsp_config ;       
  319.         
  320.         regs0->dvddsp_config =  old_config|ATAPI_HOST_RESET;
  321.     
  322.         delay(1);
  323.         regs0->dvddsp_config = old_config;
  324.         delay(1);
  325.        
  326.         if(mode&ATA_HW_RESET)
  327.         {
  328.             
  329.             regs0->dvddsp_config = ATAPI_DEV_HRESET;
  330.             delay(100);
  331.             regs0->dvddsp_config = 0;
  332.             delay(1);
  333.         }
  334.     }
  335.     
  336.     
  337.     if(mode&ATA_SW_RESET)
  338.     { 
  339.         atapi_reg_write(IDE_DEVICE_HEAD, (DEV) ? 0x10: 0x00);
  340.         atapi_reg_write(IDE_FEATURE, 0x00);
  341.         atapi_reg_write(IDE_SECTOR_CNT, 0x00);
  342.         atapi_reg_write(IDE_SECTOR_NUM, 0x00);
  343.         atapi_reg_write(IDE_CYLINDER_LO, 0x00);
  344.         atapi_reg_write(IDE_CYLINDER_HI, 0x00);
  345.         atapi_reg_write(IDE_COMMAND, 0x08);/*Drive reset*/  
  346.         
  347.         delay(3);        
  348.         if(atapi_chk_time_out(WAIT_STATUS_NO_BSY,LONG_TIME_OUT))
  349.         {           
  350.             printf(__FUNCTION__" ==> Timout 1n");          
  351.             return ATAPI_ERROR;
  352.         }
  353.     }
  354.     
  355.     if(mode&ATA_WAIT_RDY)
  356.     {//terry,2002/5/31 09:56PM, FUSS request: open must be avaible
  357.         //dev_status_flag|=ATAPI_RETRY_READY;
  358.         for(i=0;i<100;i++)
  359.         {    
  360.             
  361.             
  362.             
  363.             //polling();
  364.             //if(sys_cmd==(CMD_FUNC|CMD_FUNC_OPEN))
  365.                 // break;
  366.             
  367.             if(atapi_p_test_unit_ready()==0)
  368.             {
  369.                 //dev_status_flag&=~ATAPI_RETRY_READY;
  370.                 return 0;//test unit ready
  371.             }    
  372.                 
  373.                 
  374.             delay(100);         
  375.         }
  376.         
  377.         //dev_status_flag&=~ATAPI_RETRY_READY;
  378.         printf("!!!!!!STILL Not Readyn");
  379.         return ATAPI_ERROR;
  380.     }
  381.     
  382.     return 0;
  383. }
  384. #endif
  386. UINT8 
  387. atapi_write_block(UINT8 *p)
  388. {
  389. //  UINT32 i=0;
  390.     
  391.     //atapi_device_sel();
  392.     /*****
  393.     * Write any required command parameter to the Features, Sector
  394.     * Count, Sector Number, Cylinder High, Cylinder Low, and Device/
  395.     * Head registers
  396.     * 1. Features reg. (09h):
  397.     *   Normal: 0x00
  398.     *   NOP:    0x00, return command aborted and aborted
  399.     *       any outstanding queued commands.
  400.     *   Set Features: 0x03, set transfer mode.
  401.     * 2. Sector Count reg. (0Ah):
  402.     *   Set Features:   0x00, PIO default mode
  403.     *           0x22, Multiword DMA mode, Mode 2
  404.     * 3. Cylinder Low reg. (0Ch)
  405.     * 4. Cylinder High reg. (0Dh)
  406.     * 5. Device/Head reg. (0Eh) with appropriate DEV
  407.     *****/
  408.     atapi_reg_write(IDE_FEATURE, *p);
  409.     atapi_reg_write(IDE_SECTOR_CNT, *(p+1));
  410.     atapi_reg_write(IDE_SECTOR_NUM, *(p+2));
  411.     atapi_reg_write(IDE_CYLINDER_LO, 0xFE);
  412.     atapi_reg_write(IDE_CYLINDER_HI, 0xFF);
  413.     atapi_reg_write(IDE_DEVICE_HEAD, (DEV) ? 0x10: 0x00);
  415.     /*****
  416.     * Write command code to the command register (The host shall
  417.     * wair at least 400ns before reading the Status register to
  418.     * ensure the content is valid
  419.     * 1. NOP:           0x00
  420.     * 2. ATAPI PACKET COMMAND:  0xa0
  421.     * 3. IDENTIFY PACKET DEVICE:    0xa1
  422.     * 4. CHECK POWER MODE:  0xE5 
  423.     * 5. SLEEP:         0xE6
  424.     *****/
  425.     atapi_reg_write(IDE_COMMAND, *(p+3));
  427.     /*****
  428.      * The host shall wait at least 400ns before reading the Status
  429.      * register to ensure the content is valid.
  430.      *****/
  431.     //delay(1);
  433.   /*** Host: Read Status register until BSY=0 ***/
  434.     
  435.     
  436.     if(atapi_chk_time_out(WAIT_ALT_NO_BUSY,LONG_TIME_OUT))
  437.       {          
  438.                 
  439.             printf(__FUNCTION__" ==> Timout 1n");
  440.             
  441.             return ATAPI_ERROR;
  442.             
  443.             
  444.      }
  445.     
  446.     
  447.     
  448.     return atapi_is_error();
  449. }
  451. UINT8   
  452. atapi_send_data(UINT8 *p, int n)
  453. {
  454.     int i=0;
  455. //  UINT32 j;
  456.     
  457.     /*** Host: Read Status register until BSY=0 & DRQ=1 ***/
  458.     
  459.     
  460.     
  461.          if(atapi_chk_time_out(WAIT_DRQ_OK,LONG_TIME_OUT))
  462.          {          
  463.                 
  464.             printf(__FUNCTION__" ==> Timout 1n");
  465.             
  466.             
  467.             return ATAPI_ERROR;
  468.             
  469.             
  470.          }
  471.     
  472.     
  473.     
  475.     for (i=0; i<n; i+=2)
  476.     {
  477.         atapi_reg_write(IDE_DATA,
  478.         ( ((UINT16)(*(p+i+1))) << 8) | (UINT16)(*(p+i)) );
  479.     }
  481.     /*****
  482.     * Host: wait device to clear BSY=0, it indicates command is complete.
  483.     *****/
  484.     
  485.     
  486.     
  487.          if(atapi_chk_time_out(WAIT_STATUS_NO_BSY,LONG_TIME_OUT))
  488.         {          
  489.                 
  490.             printf(__FUNCTION__" ==> Timout 2n");
  491.             
  492.             atapi_is_error();
  493.             return ATAPI_ERROR;
  494.             
  495.             
  496.         }
  497.     
  498.     
  499.     /*****
  500.     * Host: read Alternate status register and ignore results. This prevent
  501.     *   polling host from reading status before it is valid.
  502.     * Note - Device is command complete, it should perform its error routine if
  503.     *   an error is reported
  504.     *****/
  505.     atapi_reg_read(IDE_ALT_STATUS);
  507.     return atapi_is_error();
  508. }
  510. UINT8   
  511. atapi_receive_data(UINT8 *p, int n)
  512. {
  513.     UINT16 USER_DATA;
  514.     int i, j,status;
  515. //  UINT32 k;
  516.         
  517. #ifdef USE_HDD
  518.     //Verdure add, cyue:2002-06-12 04:45PM modified
  519.     if (hd_play) return atapi_is_error();
  520. #endif
  521.         
  522.     /*****
  523.      * Host: read Alternate status register and ignore results. This
  524.      * prevent polling host from reading status before it is valid
  525.      *****
  526.      */
  527.     atapi_reg_read(IDE_ALT_STATUS);
  529.    j = 0;
  530.    do {
  531.         /*****
  532.         * Host: read Status register until BSY=0 & DRQ=1. Status register
  533.         * is read to clear pending interrput
  534.         *****/
  535.         
  536.         #ifdef POLLING_MODE
  537.             if(atapi_chk_time_out(WAIT_DRQ_OK,LONG_TIME_OUT))
  538.         {          
  539.                 
  540.             printf(__FUNCTION__" ==> Timout 1n");
  541.             cderr_handler(CDERR_ATA_BUSY);
  542.             return ATAPI_ERROR;
  543.             
  544.          }
  545.         #else
  546.     
  547.         while ( (atapi_reg_read(IDE_STATUS) & STATUS_BSY) ||
  548.              !(atapi_reg_read(IDE_STATUS) & STATUS_DRQ) ) 
  549.         
  550.         {
  551.         
  552.             WaitIRQ();
  553.         }   
  554.             
  555.         #endif
  556.                
  557.           status=atapi_reg_read(IDE_STATUS);      
  558.           if((status==0x51)||(status==0x50))//BSY=0, DRQ=0, DSC=1
  559.         {          
  560.                 
  561.             printf(__FUNCTION__" ==> skip directlyn");
  562.             
  563.             return ATAPI_ERROR;
  564.             
  565.          }        
  566.         
  567.                 
  568.                 
  569.      
  570.      
  571.         i = atapi_reg_read(IDE_CYLINDER_HI);
  572.         i = atapi_reg_read(IDE_CYLINDER_LO) + i * 256;
  573.       //printf("data length: %dn", i);
  574.       if (i > n)
  575.          i = n;
  576.      
  577.       /*****
  578.       * DRQ block transfer
  579.       *****/
  580.         for (; i > 0; i-=2)
  581.         {
  582.             USER_DATA   = atapi_reg_read(IDE_DATA);
  583.             *(p+j+1)    = USER_DATA >> 8;
  584.             *(p+j)  = USER_DATA & 0xff;
  585.          j += 2;
  586.          n -= 2;
  587.         }
  588. //ycwen 2004/08/10
  589. #ifdef NO_DVD_SERVO
  590. return ATAPI_ERROR;
  591. #endif
  593.    } while (n != 0);
  595.     /*****
  596.     * Host: wait device to clear BSY=0, it indicates command is complete.
  597.     *****/
  598.     
  599.     
  600.     if(atapi_chk_time_out(WAIT_STATUS_NO_BSY,LONG_TIME_OUT))
  601.     {          
  602.                 
  603.             printf(__FUNCTION__" ==> Timout 2n");
  604.             
  605.             //cderr_handler(CDERR_ATA_BUSY);
  606.             if(atapi_is_error()==0)
  607.             printf(__FUNCTION__" ==> !!!!ATAPI ERROR n");
  608.             
  609.             return ATAPI_ERROR;
  610.             
  611.             
  612.     }
  613.     
  614.     
  615.     
  616.     
  617.     
  618.     
  620.     /*****
  621.     * Host: read Alternate status register and ignore results. This 
  622.     *   polling host from reading status before it is valid.
  623.     * Note - Device is command complete, it should perform its error routine if
  624.     *   an error is reported
  625.     *****/
  626.     atapi_reg_read(IDE_ALT_STATUS);
  628.     return atapi_is_error();
  629. }
  631. // ATA command
  632. // packet size 12
  636. #ifdef  POLLING_MODE
  637. //terry,2002/8/22 08:29PM
  638. const UINT8 block_data[7] = {0, 0, 0, 0xFE, 0xFF, 0, 0xA0 };
  639. #else
  640. const UINT8 block_data[7] = {0, 0, 0, 0x00, 0x08, 0, 0xA0 };
  641. #endif
  643. UINT8 
  644. atapi_do_packet(UINT8 *pck)
  645. {
  646.     int i;
  647.     UINT32 wait_time;
  648.     
  649. #ifdef USE_HDD
  650.     //Verdure add, cyue:2002-06-12 04:45PM modified
  651.     if (hd_play)
  652.     {
  653.              hdd_do_packet(wait_time,pck);
  654.              return 0;
  655.     }
  656. #endif
  657.     
  659.     if(dev_status_flag&READ_PRESENT_DATA)
  660.         wait_time=SHORT_TIME_OUT;
  661.     else
  662.         wait_time=NORMAL_TIME_OUT;
  663.         
  664.     if(atapi_chk_time_out(WAIT_ALT_NO_BUSY,wait_time))
  665.     {          
  666.         printf(__FUNCTION__" ==> Timout 1n");          
  667.         cderr_handler(CDERR_ATA_BUSY);
  668.         return ATAPI_ERROR;
  669.     }
  670.      
  671.     for (i = 0; i <= 6; i++)    
  672.         atapi_reg_write(i + 0x11, block_data[i]);
  673.         
  675.     if(atapi_chk_time_out(WAIT_ALT_NO_BUSY,wait_time))
  676.     {                       
  677.             printf(__FUNCTION__" ==> Timout 2n");          
  678.             cderr_handler(CDERR_ATA_BUSY);
  679.             return ATAPI_ERROR;
  680.     }
  681.     
  682.     i = atapi_reg_read(IDE_ALT_STATUS); 
  683.     if ((i & STATUS_ERR) != 0) 
  684.     {
  685.         printf("write_block in do_packet error:%xn",i);
  686.         return ATAPI_ERROR;
  687.     }
  689.     if(atapi_chk_time_out(WAIT_DRQ_OK,wait_time))
  690.     {                   
  691.             printf(__FUNCTION__" ==> Timout 3n");      
  692.             cderr_handler(CDERR_ATA_BUSY);
  693.             return ATAPI_ERROR;
  694.     }
  695.     
  697.     for (i=0; i<12; i+=2)
  698.     {
  699.         atapi_reg_write(IDE_DATA,
  700.         ( ((UINT16)(*(pck+i+1))) << 8) | (UINT16)(*(pck+i)) );
  701.     }
  702.     
  703. #ifdef WAIT_ATA_ITRQ    
  704.     if(atapi_chk_time_out(WAIT_IRQ,MAX_TIME_OUT))
  705.     {          
  706.                 
  707.             printf(__FUNCTION__" ==>< IRQ Timout >n");
  708.             cderr_handler(CDERR_ATA_BUSY);
  709.             return ATAPI_ERROR;
  710.             
  711.     }
  712. #endif  
  713.     
  714.                  //Actually, when timeout loader is still busy,  
  715.                  //So I think output next command to loader, it will let loader hang up
  716.                  //Normal method, it should do software reset to reset loader and return ATAPI ERROR
  717.                  //But some loader will support software reset function
  718.                  
  719.                
  720.         #ifdef POLLING_MODE
  721.         if(atapi_chk_time_out(WAIT_STATUS_NO_BSY,wait_time))
  722.         {          
  723.                 
  724.             printf(__FUNCTION__" ==> Timout 4n");
  725.             
  726.             cderr_handler(CDERR_ATA_BUSY);
  727.             return ATAPI_ERROR;
  728.             
  729.             
  730.         }
  731.         #else
  732.         WaitIRQ();
  733.         while (atapi_reg_read(IDE_STATUS) & STATUS_BSY) 
  734.         {
  735.          ;
  736.         }
  737.         
  738.         
  739.         #endif
  740.     
  741.     
  742.     atapi_reg_read(IDE_ALT_STATUS);
  744.     if (atapi_is_error() != 0) {
  745.         printf("send_data in do_packet errorn");       
  746.          print_block(pck, 12);
  747.      //  atapi_p_request_sense(pc_rdata);//kenny mark it
  748.         return ATAPI_ERROR;
  749.     }
  751.          
  752.     return ATAPI_OK;
  753. }
  755. /*****************************************************/
  756. /*                          */
  757. /*                          */
  758. /*                          */
  759. /******************************************************/
  760. extern void polling();
  762. BYTE atapi_chk_time_out(BYTE wait_state,int w_time)
  763. {
  764.    int res=1,i=0;
  765.    UINT16 timenow,diff=0,old_t,status;
  766.    
  767.   if(dev_status_flag&ATAPI_WAIT_TIME_OUT)
  768.   {
  769.      printf("<bug:reentry>");
  770.      return 0;
  771.   }  
  772.   dev_status_flag|=ATAPI_WAIT_TIME_OUT;
  773.   old_t=regs0->rtc_15_0;   
  774.   while(diff<w_time)
  775.   {
  776.     
  777.     timenow = regs0->rtc_15_0;  
  778.     diff        = timenow-old_t;     
  779.     
  780.     if(wait_state == WAIT_IRQ)
  781.     {
  782.       #ifdef DVD728
  783.         if(regs0->dvddsp_ata_config & ATAPI_DEVICE_INT)
  784.       #else
  785.         if(regs0->dvddsp_config & ATAPI_DEVICE_INT)
  786.       #endif
  787.            res=0;       
  788.     }else if(wait_state== WAIT_STATUS_NO_BSY)
  789.     {//wait BUSY bit of STATUS register is 0         
  790.          res=(atapi_reg_read(IDE_STATUS) & STATUS_BSY);             
  791.     }else if(wait_state== WAIT_ALT_NO_BUSY)
  792.     {//wait BUSY bit of ALT STATUS register is 0
  793.         res=(atapi_reg_read(IDE_ALT_STATUS) & STATUS_BSY);
  794.              
  795.     }else if(wait_state== WAIT_DRQ_OK)
  796.     {//wait DRQ=1 or BUSY bit=0
  797.        status = atapi_reg_read(IDE_STATUS);
  798.        if( !(status & STATUS_BSY)|| (status & STATUS_DRQ) )
  799.                 res=0;           
  800.        
  801. //       printf("<w:%x>",status);           
  802.     }else if(wait_state== WAIT_DRQ_HIGH)
  803.     {//wait DRQ=1
  804.         if( (atapi_reg_read(IDE_STATUS) & STATUS_DRQ) )
  805.               res=0;
  806.     }else if(wait_state== WAIT_DRQ_BSY_ZERO)
  807.     {//wait DRQ=0 and BUSY=0
  808.         res=(atapi_reg_read(IDE_STATUS) & (STATUS_BSY | STATUS_DRQ));           
  809.     }
  810.             
  811.     if(res)
  812.     {//terry,2-5-15 15:56,reduce sensetive ability.
  813.      //terry,2002/6/4 05:38PM,avoiding many confuse on read navigation data
  814.        if( (dev_status_flag&READ_PRESENT_DATA)||(cd_type_loaded==CDROM) )
  815.        {
  816.           if( (system_state==SYSTEM_BROWSE)&&(i>200) )
  817.           {
  818.              polling();           
  819.              cderr_update_show_time();                         
  820.           }else
  821.              disp_fan_in();
  822.           
  823.           i++;  
  824.        }else if(system_state==SYSTEM_IDLE)
  825.             polling();       
  826.             
  827.        delay_1us(500);               
  828.     }else
  829.        break;
  830.     
  831.   }//while
  832.     
  833.     
  834.   dev_status_flag&=~ATAPI_WAIT_TIME_OUT;
  835.   
  836.    return res;  
  837. }   
  839. UINT8 
  840. atapi_do_set_features(void)
  841. {
  842.     UINT8 block_cmd[4];
  844.     // enable PIO mode 4
  845.     block_cmd[0] = 0x03;
  846.     block_cmd[1] = 0x0C;
  847.     block_cmd[2] = 0x00;
  848.     block_cmd[3] = 0xEF;
  849.     atapi_write_block(block_cmd);
  851.     if (atapi_is_error() == 1) {
  852.         printf("do_set_features errorn");
  853.         return 1;
  854.     }
  856.     return 0;
  857. }
  859. // Packet command
  860. // read 18 bytes
  861. UINT8 
  862. atapi_p_request_sense(UINT8 *block_info)
  863. {
  864.     int sense_key;
  865.     UINT8 pc[12];
  867.     
  868. #ifdef USE_HDD
  869.     //Verdure add, cyue:2002-06-12 04:45PM modified
  870.     if (hd_play) return 0;
  871. #endif
  873.     request_sense_flag=0;
  874.     
  875.     memset(pc, 0, 12);
  876.     pc[0] = 0x03;
  877.     pc[4] = 0x12;
  878.     
  879.     
  880.     
  881.     if (atapi_do_packet(pc) == 1) {
  882.         printf("p_request_sense do_packet errorn");
  883.         cderr_handler(CDERR_ATA_NOT_READY);
  884.         
  885.         return 1;
  886.     }
  888.     memset(block_info, 0xFF, 18);
  889.     if (atapi_receive_data(block_info, 18) == 1) {
  890.         printf("p_request_sense receive data errorn");
  891.         return 1;
  892.     }
  894.     sense_key=block_info[2]&0xf;
  895.     if (block_info[2] == 00) {
  896.         printf("no sensen");
  897.     } else {        
  898.         printf("Sense key: 0x%02xn",sense_key);
  899.         printf("ASC: 0x%02xn", block_info[12]);
  900.         printf("ASCQ:0x%02xn", block_info[13]);
  901.         
  902.         
  903.         if(sense_key==2)
  904.         {
  905.             if(block_info[12]==0x04)
  906.                request_sense_flag|=ATAPI_NOT_READY;
  907.             else if((block_info[12]==0x3A)&&(block_info[13]==0x00))
  908.                request_sense_flag|=ATAPI_NO_MEDIA;
  909.             else if((block_info[12]==0x06)&&(block_info[13]==0x00))
  910.                request_sense_flag|=ATAPI_MEDIA_UPSIDE_DOWN;
  911.         }else if(sense_key==5)
  912.         {
  913.             if(block_info[12]==0x30)
  914.                request_sense_flag|=ATAPI_UNKNOWN_MEDIA;
  915.             else if(block_info[12]==0x64)
  916.                request_sense_flag|=ATAPI_ILLEGAL_MODE;
  917.         }
  918.     }
  920.     //printf("sense info:n");
  921.     //print_block(block_info, 18);
  923.     return 0;
  924. }
  925.     
  926. UINT8
  927. atapi_p_test_unit_ready(void)
  928. {
  929.     UINT8 pc[12];
  930.     UINT8 pc_rdata[32];
  931.     int ret;
  932.     memset(pc, 0, 12);
  933.     //printf("!");
  934.     
  935.     ret=atapi_do_packet(pc);//ret==0, unit is ready
  936.     
  937.     if(ret==1)
  938.     {
  939.      atapi_p_request_sense(pc_rdata);//kenny
  940.      
  941.      if(request_sense_flag&ATAPI_NO_MEDIA)
  942.      ret=ATAPI_NO_MEDIA;
  943.     else if(request_sense_flag&ATAPI_NOT_READY)
  944.       ret=ATAPI_NOT_READY;
  945.     
  946.     else if(request_sense_flag&ATAPI_MEDIA_UPSIDE_DOWN)
  947.       ret=ATAPI_MEDIA_UPSIDE_DOWN; 
  948.     else if(request_sense_flag&ATAPI_UNKNOWN_MEDIA)
  949.       ret=ATAPI_UNKNOWN_MEDIA; 
  950.     else
  951.       ret=0xff; 
  952.      
  953.     }
  954.     
  955.     return ret;
  956. }
  958. UINT8 
  959. atapi_p_start_stop_unit(UINT8 start)
  960. {
  961.     UINT8 pc[12];
  962.     UINT8 pc_rdata[32];
  964.     flush_atapi();
  965.     
  966.     if (atapi_is_error() == ATAPI_ERROR) {
  967.         printf("enter atapi_p_start_stop_unit errorn");
  968.         atapi_p_request_sense(pc_rdata);
  969.         
  970.     }   
  971.     
  972.     memset(pc, 0, 12);
  973.     pc[0] = 0x1B;
  974.     pc[1] = 0x01;
  975.     pc[4] = start;
  976.     if (atapi_do_packet(pc) == 1) {
  977.         printf("p_start_stop_unit errorn");
  978.          atapi_p_request_sense(pc_rdata);//kenny
  979.         return 1;
  980.     }
  982.     return 0;
  983. }
  986. UINT8 
  987. atapi_p_mechanism_status(void)
  988. {
  989.     UINT8 pc[12];
  990.     UINT8 pc_rdata[32];
  992.     flush_atapi();//alan 2002/5/30 06:29PM added to solve standby wake up fail when power on/off
  993.     memset(pc, 0, 12);
  994.     pc[0] = 0xBD;
  995.     pc[9] = 0x08;
  996.     if (atapi_do_packet(pc) == ATAPI_ERROR) {
  997.         printf("p_mechanism_status do_packet errorn");
  998.          atapi_p_request_sense(pc_rdata);//kenny
  999.         return ATAPI_ERROR;
  1000.     }
  1002.     memset(pc_rdata, 0, 8);
  1003.     if (atapi_receive_data(pc_rdata, 8) == ATAPI_ERROR) {
  1004.         printf("p_mechanism_status receive data errorn");
  1005.         return ATAPI_ERROR;
  1006.     }
  1008.    //printf("%dn", pc_rdata[1] >> 5);
  1009.     if (((pc_rdata[1] >> 4) & 1) == 0) {
  1010. //      printf("door closen");
  1011.       return ATAPI_DOOR_CLOSE;
  1012.     }
  1014. //   printf("door openn");
  1015.     return ATAPI_DOOR_OPEN;
  1016. }
  1021. UINT8 
  1022. atapi_p_read_12(UINT32 lba, UINT32 len)
  1023. {
  1024.     BYTE ret;
  1025.     UINT8 pc[12];
  1026.     UINT8 pc_rdata[32];
  1028.     memset(pc, 0, 12);
  1029.     pc[0] = 0xA8;
  1031.     pc[2] = (lba >> 24) & 0x000000ff;   /* LBA (MSB) */
  1032.     pc[3] = (lba >> 16) & 0x000000ff;
  1033.     pc[4] = (lba >> 8) & 0x000000ff;
  1034.     pc[5] =  lba & 0x000000ff;              /* LBA (LSB) */
  1036.     pc[6] = (len >> 24) & 0x000000ff;   // transfer length(MSB)
  1037.     pc[7] = (len >> 16) & 0x000000ff;        
  1038.     pc[8] = (len >> 8) & 0x000000ff;          
  1039.     pc[9] =  len & 0x000000ff;  
  1040.     
  1041.     ret=atapi_do_packet(pc);
  1042.     
  1043.     if(dev_status_flag&READ_PRESENT_DATA)
  1044.          dev_status_flag&=~READ_PRESENT_DATA;
  1046.     if (ret == 1) {
  1047.         printf("!!!!!!!!p_read_12 errorn");
  1048.         
  1049.             atapi_p_request_sense(pc_rdata);
  1050.             printf("!!!!!!!!Request outn");
  1051.           
  1052.           if(request_sense_flag&ATAPI_NOT_READY)
  1053.           {
  1054.             printf("!!!!!!!!p_read_12 error, unit not readyn");
  1055.             
  1056.                     cderr_handler(CDERR_ATA_NOT_READY);
  1057.                  
  1058.                     if(atapi_do_packet(pc) == 1) 
  1059.                     {
  1060.                     printf("p_read_12 again errorn");  
  1061.                      atapi_p_request_sense(pc_rdata);//kenny
  1062.                 
  1063.                 }
  1064.             
  1065.                         
  1066.             
  1067.           }//not ready  
  1068.           else if(request_sense_flag&ATAPI_ILLEGAL_MODE)
  1069.           {
  1070.             
  1071.             return ATAPI_ILLEGAL;
  1072.             
  1073.         
  1074.         
  1075.           }     
  1076.           
  1077.         return 1;
  1078.     }
  1080.     return 0;
  1081. }
  1085. // generic packet command
  1086. void 
  1087. init_cdrom_command(struct cdrom_generic_command *cgc, void *buffer, int len)
  1088. {
  1089.     memset(cgc, 0, sizeof(*cgc));
  1090.     memset(buffer, 0, len);
  1091.     cgc->buffer = (char *) buffer;
  1092.     cgc->buflen = len;
  1093. }
  1095. // only support 3 commands now
  1096. // return 0: ok, -1: error
  1097. int 
  1098. generic_packet(struct cdrom_generic_command *cgc)
  1099. {
  1100.     UINT8 pc_rdata[32];
  1101.     
  1102.     //atapi_p_test_unit_ready();
  1103.     
  1104.     #if 0 //mark it to reduce code
  1105.     if (0)
  1106.     {
  1107.         //printf("generic_packet startn");
  1108.         print_block(cgc->cmd, 12); //printf("n");
  1109.     }
  1110.     
  1111.     switch (cgc->cmd[0]) {
  1112.         case GPCMD_READ_DVD_STRUCTURE:
  1113.         case GPCMD_REPORT_KEY:
  1114.             if (atapi_do_packet(cgc->cmd)) {
  1115.                 printf("----------------generic packet errorn");
  1116.                  atapi_p_request_sense(pc_rdata);//kenny
  1117.                 return -1;
  1118.             }
  1119.             atapi_receive_data(cgc->buffer, cgc->buflen);
  1120.             break;
  1121.         case GPCMD_SEND_KEY:
  1122.             if (atapi_do_packet(cgc->cmd)) {
  1123.                 printf("----------------generic packet errorn");
  1124.                  atapi_p_request_sense(pc_rdata);//kenny
  1125.                 return -1;
  1126.             }
  1127.             atapi_send_data(cgc->buffer, cgc->buflen);
  1128.             break;
  1129.     }
  1130.     #endif
  1131.     
  1132.     #if 1 //reduced code
  1133.     if ((cgc->cmd[0]==GPCMD_READ_DVD_STRUCTURE)||(cgc->cmd[0]==GPCMD_REPORT_KEY))
  1134.     {
  1135.         if (atapi_do_packet(cgc->cmd)!=0)
  1136.         {
  1137.             printf(__FUNCTION__ ":packet errorn");
  1138.             atapi_p_request_sense(pc_rdata);
  1139.             memset(cgc->buffer,0,cgc->buflen);
  1140.             return -1;
  1141.         }
  1142.         atapi_receive_data(cgc->buffer, cgc->buflen);
  1143.     }   
  1144.     else if(cgc->cmd[0]==GPCMD_SEND_KEY)
  1145.     {
  1146.         if (atapi_do_packet(cgc->cmd)!=0)
  1147.         {
  1148.             printf(__FUNCTION__ ":packet errorn");
  1149.             atapi_p_request_sense(pc_rdata);
  1150.             memset(cgc->buffer,0,cgc->buflen);
  1151.             return -1;
  1152.         }
  1153.         atapi_send_data(cgc->buffer, cgc->buflen);
  1154.     }   
  1155.     #endif
  1157.     { 
  1158.         int i;
  1159.         i = atapi_is_error();
  1160.         if (i != 0) { 
  1161.             UINT8 ubuf[20];
  1162.             printf(__FUNCTION__":error %dn", i);
  1163.             atapi_p_request_sense(ubuf);
  1164.         }
  1165.         return -i;
  1166.     }
  1167. }
  1168. UINT8 
  1169. atapi_get_cprm_config(void)
  1170. {
  1171.     BYTE ret=0;
  1172.     UINT8 pc[12];
  1173.     UINT8 pc_rdata[32];
  1175.     memset(pc, 0, 12);
  1176.     pc[0] = 0x46;     
  1177.     pc[1] = 0x02; //feature descriptor be returned
  1178.     pc[2] = 0x01; //cprm 
  1179.     pc[3] = 0x0B;
  1180.     
  1181.     // transfer length
  1182.     pc[8] = 0x08;       
  1183.     if( atapi_do_packet(pc)==0 )
  1184.     {
  1185.         if(atapi_receive_data(pc_rdata, 8) ) 
  1186.         {
  1187.             printf("atapi_get_cprm_config  receive errorn");
  1188.             //memset(pc_rdata, 0, 2048*len);    
  1189.             ret = ATAPI_ERROR;    
  1190.         }else
  1191.         {
  1192.             print_block(pc_rdata,8);//01:0x010B         
  1193.             if(pc_rdata[2]&0x01)
  1194.             {
  1195.                 printf("DVD-R,DVD-RW or DVD-RAMn");
  1196.             }
  1197.         } 
  1198.     }else
  1199.     {
  1200.         printf("get cprm config failn");
  1201.         atapi_p_request_sense(pc_rdata);        
  1202.         ret = ATAPI_ERROR;    
  1203.     }
  1204.     
  1205.     return ret;
  1206. }
  1210. UINT8 
  1211. atapi_block_read(UINT32 lba, UINT32 len)
  1212. {
  1213.     UINT8 pc_rdata[32];
  1214.     
  1215. #ifdef USE_HDD
  1216.       //Verdure add, cyue:2002-06-12 04:45PM modified
  1217.       if  (hd_play)
  1218.       {
  1219.           hdd_block_read(lba, len);
  1220.           return 0;
  1221.       }
  1222. #endif
  1224.     if (atapi_is_error() == ATAPI_ERROR) {
  1225.         printf("enter block_read errorn");
  1226.         atapi_p_request_sense(pc_rdata);
  1227.         
  1228.         cderr_handler(CDERR_DAT_DISCONTINUE);
  1229.         //lba=lba_st.lba;
  1230.         return ATAPI_ERROR;//2001/12/20
  1231.         
  1232.     }
  1234.     if (is_user_opened())
  1235.     {
  1236.         printf("USER OPEN!!!n");
  1237.         return ATAPI_ERROR;
  1238.     }   
  1239.     
  1240.     dev_status_flag|=READ_PRESENT_DATA;//kenny
  1241.    
  1242.     if (DiscType != CDDVD)
  1243.     {
  1244.         //printf("readcdn");
  1245.         if (atapi_read_cd(lba, len) == ATAPI_ERROR) return ATAPI_ERROR;
  1246.         
  1247.         if ( (cd_type_loaded==CDDA) && (cd_subtype!=CD_DTS) )
  1248.             regs0->dvddsp_blocksize = iBlockLen; //Jeff 20020927
  1249.         else
  1250.            regs0->dvddsp_blocksize = 2352/2;
  1252.         regs0->dvddsp_blocklength = len;        
  1253.       #ifdef DVD728
  1254.         regs0->dvddsp_ata_config = DVDDSP_CONFIG_DEF;
  1255.       #else
  1256.         regs0->dvddsp_config = PIO_MODE2|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  1257.       #endif
  1258.     }
  1259.     else
  1260.     { // DVD
  1261.         //printf("read12n");
  1262.     if (atapi_p_read_12(lba, len) == ATAPI_ERROR) return ATAPI_ERROR;
  1263. #ifdef DVD728
  1265.     regs0->dvddsp_public    = 0;
  1266.     if (CSSEnable)
  1267.     {
  1268. #define CPPM_ENABLE             
  1269. #ifdef CPPM_ENABLE      
  1270.       /*if(len==1)
  1271.       {
  1272.         regs0->dvddsp_public = 0x0080;        
  1273.       }else      */
  1274.       {
  1275.         //regs0->dvddsp_public = 0x80|ATAPI_CSS_ENABLE|(1<<8);      // for FPGA
  1276.         regs0->dvddsp_public = 0x80|ATAPI_CSS_ENABLE;       // for 8200 real chip + ATAPI loader
  1277.       }
  1278.         
  1279.       regs0->css_config     = 0x00;                 // css use hw
  1280.       //regs0->css_public       = 1<<8;                 // cppm
  1281.       regs0->css_public     = 0;
  1282. #else
  1283.       regs0->dvddsp_public = 0x0080 | ATAPI_CSS_ENABLE;
  1284.       regs0->css_config     = 0x00;                 // css use hw
  1285.       //regs0->css_public       = 0<<8;                 // css
  1286. #endif    
  1287.     }else
  1288.       regs0->dvddsp_public = 0x0080;
  1289. #if 0
  1290.     regs0->dvddsp_public    = 0;
  1291.     regs0->dvddsp_public    = 0x0080|(1<<8);        // host enable cppm
  1292.     regs0->css_config       = 0x00;                 // css use hw
  1293.     regs0->css_public       = 1<<8;                 // ..
  1294. #endif
  1295.     regs0->dvddsp_ata_config = DVDDSP_CONFIG_DEF;
  1296. #else
  1297.     #ifdef NINTAUS_LOADER//only use PIO_MODE2
  1298.     #define PIO_MODE_USE PIO_MODE2
  1299.     #else
  1300.     #define PIO_MODE_USE PIO_MODE3
  1301.     #endif
  1302.     if (CSSEnable)
  1303.       regs0->dvddsp_config = PIO_MODE_USE|ATAPI_CSS_ENABLE|DVDDSP_CONFIG_DEF;
  1304.     else
  1305.       regs0->dvddsp_config = PIO_MODE_USE|DVDDSP_CONFIG_DEF;
  1306. #endif // DVD728
  1307.       
  1309.     regs0->dvddsp_blocksize = 1024;
  1310.     regs0->dvddsp_blocklength = len;
  1312.     }   
  1313.     
  1314.   
  1315.   if (atapi_reg_read(IDE_STATUS) == 0x50) { //DRQ=0,BSY=0,DRDY=1,DSC=1
  1316.     printf("skip directly!n");
  1317.     return ATAPI_ERROR;
  1318.   } else { 
  1319.   #ifdef DVD728
  1320.     regs0->dvddsp_function = ATAPI_READ | DATA_MODE | HOST_START | 0x00;
  1321.   #else
  1322.     regs0->dvddsp_function = (IDE_DATA<<8) | ATAPI_READ | DATA_MODE | HOST_START ;
  1323.   #endif
  1324.   }
  1325.   
  1326.   
  1327.   #if 0
  1328.    if((atapi_reg_read(IDE_STATUS) & (STATUS_BSY|STATUS_DRQ)) != STATUS_DRQ){
  1329.     printf("skip directly!n");
  1330.     return ATAPI_ERROR;
  1331.   } else { 
  1332.     
  1333.     regs0->dvddsp_function = (IDE_DATA<<8) | ATAPI_READ | DATA_MODE | HOST_START ;
  1334.   }
  1335.   #endif
  1338.     return ATAPI_OK;
  1339. }
  1347. void 
  1348. atapi_init(void)
  1349. {
  1350. #ifdef DVD728
  1351.     regs0->dvddsp_ata_config = DVDDSP_CONFIG_DEF;
  1352.     atapi_rst(DSP_HOST_RESET|ATA_HW_RESET);
  1353.     regs0->dvddsp_ata_config = DVDDSP_CONFIG_DEF;
  1354. #else
  1355.     regs0->dvddsp_config = PIO_MODE2|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;
  1356.     atapi_rst(DSP_HOST_RESET|ATA_HW_RESET);
  1357.     regs0->dvddsp_config = PIO_MODE2|DVDDSP_CONFIG_DEF;//DVDDSP_CONFIG_DEF;     
  1358. #endif
  1359.     delay(1);       
  1360.     atapi_p_test_unit_ready();//start up loader
  1361. }
  1364. #include "dvdioctl.h"
  1366. #if DISC_SYSTEM==DISC_SYSTEM_ATAPI  
  1367. void disc_init(void)
  1368. { 
  1370.    DiscType = CDUNKNOWN;
  1371.    if (udf_find_anchor() == 0) 
  1372.    {
  1373.         printf("no anchor foundn");
  1374.       
  1375.    } else {        
  1376.         printf("initialize filesystemn");
  1377.         if ( fs_init() < 0) return;
  1378.         if(dVMG_LSN)
  1379.         {
  1380.             DiscType = CDDVD;
  1381.             cd_type_loaded=DiscType;
  1384. #define ALWAYS_ENABLE_CSS
  1385. #ifdef  ALWAYS_ENABLE_CSS
  1386.             CSSEnable=1;
  1387. #else            
  1388. {
  1389.             dvd_struct s;
  1390.             
  1391.             s.type = DVD_STRUCT_COPYRIGHT;
  1392.             s.copyright.layer_num = 0;
  1394.             dvd_read_struct(&s);        
  1395.             CSSEnable=s.copyright.cpst;
  1396. }
  1397. #endif            
  1399.             printf("css:%xn",CSSEnable);
  1400.             /*
  1401.             if (s.copyright.cpst == 0) 
  1402.             { // no css
  1403.                   epp_write("no cssn");
  1404.                   CSSEnable = 0;
  1405.             } else 
  1406.             {
  1407.                   epp_write("css enn");
  1408.                   CSSEnable = 1;
  1409.             }*/
  1410.         }
  1411. #ifdef DVD_AUDIO
  1412.         cppm_init( dAMG_LSN );
  1413. #endif  
  1415.         
  1416.    }
  1417.    
  1418.    
  1419. }
  1420. #else
  1421. void disc_init(void)
  1422. {
  1423.    dvd_struct s;
  1424.    
  1425.    if (udf_find_anchor() == 0) 
  1426.    {
  1427.         printf("no anchor foundn");
  1428.         DiscType = CDUNKNOWN;      
  1429.    } else {        
  1430.         printf("initialize filesystemn");
  1431.         if ( fs_init() < 0)
  1432.         {
  1433.             DiscType = CDUNKNOWN;
  1434.             return;
  1435.         }
  1436.     
  1437.         if(dVMG_LSN)
  1438.         {
  1439.             DiscType = CDDVD;
  1440.             cd_type_loaded=DiscType;
  1442.             s.type = DVD_STRUCT_COPYRIGHT;
  1443.             s.copyright.layer_num = 0;
  1444.             CSSEnable = 1;
  1446.         }else
  1447.         {
  1448.             DiscType = CDUNKNOWN;
  1449.         }    
  1450.    }   
  1451. }
  1452. #endif
  1454. BYTE user_only=0;
  1456. UINT8 
  1457. atapi_read_cd(UINT32 lba, UINT32 len)
  1458. {
  1459.     BYTE ret;
  1460.     UINT8 pc[12];
  1461.     UINT8 pc_rdata[32];
  1463.     memset(pc, 0, 12);
  1464.     pc[0] = 0xBE;
  1465.       // LBA
  1466.     pc[2] = (lba >> 24) & 0x00ff; 
  1467.     pc[3] = (lba >> 16) & 0x00ff;
  1468.     pc[4] = (lba >> 8) & 0x00ff;
  1469.     pc[5] =  lba & 0x00ff;      
  1471.     // transfer length
  1472.     pc[6] = (len >> 16) & 0x00ff;
  1473.     pc[7] = (len >> 8) & 0x00ff;          
  1474.     pc[8] =  len & 0x00ff;  
  1475.     
  1477.     // ....
  1478.     #define ATAPI_READCD_9_SYNC     (1<<7)
  1479.     #define ATAPI_READCD_9_HEADER_NONE  (0<<5)
  1480.     #define ATAPI_READCD_9_HEADER_HEADER    (1<<5)
  1481.     #define ATAPI_READCD_9_HEADER_SUBHEADER (2<<5)
  1482.     #define ATAPI_READCD_9_HEADER_ALL   (3<<5)
  1483.     #define ATAPI_READCD_9_USERDATA     (1<<4)
  1484.     #define ATAPI_READCD_9_ECC      (1<<3)
  1486.     
  1487.     
  1488.     if(user_only==1)
  1489.     {
  1490.         
  1491.     pc[9] =0x10;    
  1492.     }
  1493.     else
  1494.     {   
  1495.     pc[9] = ATAPI_READCD_9_SYNC
  1496.             | ATAPI_READCD_9_HEADER_ALL
  1497.         | ATAPI_READCD_9_USERDATA
  1498.         | ATAPI_READCD_9_ECC;
  1499.         
  1500.     }   
  1502.     if ( (cd_type_loaded==CDDA) && (cd_subtype!=CD_DTS) )
  1503.        pc[10]=bReadSubChannel; //Jeff 20020927
  1505.     
  1506.      ret=atapi_do_packet(pc);
  1508.      if((dev_status_flag&READ_PRESENT_DATA))         {
  1510.          dev_status_flag&=~READ_PRESENT_DATA;         }  
  1516.     if (ret == 1) {
  1517.         printf("p_read_cd errorn");
  1518.         atapi_p_request_sense(pc_rdata);
  1519.         return 1;
  1520.     }
  1522.     return 0;
  1523. }
  1525. int 
  1526. cdrom_read_tocentry(int trackno, int msf_flag, BYTE format, int buflen)
  1527. {
  1528.     UINT8 pc[12];
  1529.     UINT8 pc_rdata[32];
  1531.     memset(&pc, 0, sizeof(pc));
  1533.     pc[0] = 0x43;
  1534.     pc[2] = format;//2001/9/26
  1535.     pc[6] = trackno;
  1536.     pc[7] = (buflen >> 8);
  1537.     pc[8] = (buflen & 0xff);
  1538.     //pc[9] = (format << 6);//2001/9/26 mark it
  1540.     if (msf_flag)
  1541.         pc[1] = 2;
  1543.     if (atapi_do_packet(pc) == 1) {
  1544.         printf("cdrom_read_tocentry errorn");
  1545.         
  1546.         atapi_p_request_sense(pc_rdata);
  1547.         
  1548.         
  1549.         if(request_sense_flag&ATAPI_NOT_READY)//kenny
  1550.           {
  1551.             
  1552.             printf("!!!!!cdrom_read_tocentry , Unit not ready");
  1553.             
  1554.             
  1555.             
  1556.             cderr_handler(CDERR_ATA_NOT_READY);
  1557.             
  1558.             if (atapi_do_packet(pc) == 1) {
  1559.         printf("cdrom_read_tocentry error againn");
  1560.         
  1561.          atapi_p_request_sense(pc_rdata);
  1562.         } 
  1563.             
  1564.                         
  1565.             
  1566.           } //if(not_ready==1)
  1567.         
  1568.         
  1569.         
  1570.        
  1571.         return 1;
  1572.     }
  1574.     //memset(pc_rdata, 0, sizeof(pc_rdata));
  1575.     
  1576.     //if (atapi_receive_data(pc_rdata, buflen) == 1) {
  1577.     memset(pwb, 0, sizeof(pwb));    
  1578.     if (atapi_receive_data(pwb, buflen) == 1) { 
  1579.         
  1580.         printf("cdrom_read_tocentry receive data errorn");
  1581.         return 1;
  1582.     }
  1584.     return 0;
  1585. }
  1588. /************************************************/
  1589. // atapi_p_mode_sense:
  1590. //  This function is only used before excute disc_init().
  1591. //  Because before reading TOC( disc type is unknown), I don't know read command should be command 0xA8 or 0xBE.
  1592. //  I found that if disc is CDDA and send 0xA8 or 0x28 to loader, then loader will response illegle mode error.
  1593. //  So we must make sure disc is CDDA or not. 
  1594. //  If DISC is CDDA then DiscType is setting CDDA, for other disc  DiscType is CDDVD. 
  1595. //  And we can use disc_init() to identify disc is real DVD disc or not. 
  1596. //  If it is not DVD disc then read toc to classify CDDA,VCD, MP3.
  1597. //  
  1598. /***********************************************/
  1601. BYTE atapi_p_get_disc_info(void)
  1602. {
  1603.  BYTE buflen;
  1604.  UINT8 pc[12];
  1605.  UINT8 pc_rdata[32];
  1608.  #ifdef NINTAUS_LOADER
  1609.  DiscType=CDDVD;  
  1610.  return 0;
  1611.  #endif
  1612.  
  1615.   memset(&pc, 0, sizeof(pc));
  1617.     pc[0] = 0x5A;
  1618.     pc[2]=0x41;
  1619.     pc[7] = 0;
  1620.     pc[8] =buflen =0x0A;
  1621.     
  1623.     if (atapi_do_packet(pc) == 1) {
  1624.         printf("atapi_mode_sense errorn");
  1625.         
  1626.         atapi_p_request_sense(pc_rdata);    
  1627.         
  1628.         return 1;
  1629.     }
  1630.      
  1631.      
  1632.      
  1633.         memset(pwb, 0, sizeof(pwb));    
  1634.     if (atapi_receive_data(pwb, buflen) == 1) { 
  1635.         
  1636.         printf("atapi_mode_sense receive data errorn");
  1637.         return 1;
  1638.     }
  1641.        //printf("DISC TYPE=%xn",pwb[2]);
  1642.        
  1643.        //pwb[2]=0x01: VCD,MP3
  1644.        //pwb[2]=0x02,0x06,0x12,0x16,0x22,0x26: CDDA
  1645.        //pwb[2]=0x041: DVD
  1646.         
  1647.         
  1648.         if(pwb[2]==0x02||pwb[2]==0x06||pwb[2]==0x12||pwb[2]==0x16||pwb[2]==0x22||pwb[2]==0x26)      
  1649.          DiscType=CDDA;
  1650.         else if(pwb[2]==0x41)
  1651.          DiscType=CDDVD;          
  1652.         else
  1653.          DiscType=CDUNKNOWN; 
  1656.     return 0;   
  1657.     
  1658.     
  1659. }   
  1662. int
  1663. atapi_open_tray(void)
  1664. {
  1665.     printf("openn");
  1666.     return atapi_p_start_stop_unit(START_STOP_DO_EJECT);                        
  1667. }
  1669. /*
  1670. int
  1671. atapi_close_tray(void)
  1672. {
  1673.     printf("closen");
  1674.     return atapi_p_start_stop_unit(START_STOP_DO_LOAD);             
  1675. }
  1676. */
  1677. int
  1678. atapi_close_tray(UINT8 nStatus)
  1679. {
  1680.     printf("closen");
  1681.     if (!nStatus) // Robert 2003/12/16
  1682.         return atapi_p_start_stop_unit(START_STOP_DO_LOAD);
  1683.     else
  1684.         return atapi_p_start_stop_unit(START_STOP_DO_LOAD_POWER_OFF);
  1685. }
  1687. int
  1688. atapi_abort_play(void)
  1689. {
  1690.     printf("stopn");
  1691.     if(!is_user_opened())
  1692.     {
  1693.         return atapi_p_start_stop_unit(START_STOP_DO_STOP);
  1694.     }else
  1695.         return 0;
  1696. }
  1698. /*
  1699. ** FUNCTION
  1700. ** atapi_read_toc
  1701. **
  1702. */
  1703. int atapi_read_toc(void)
  1704. {
  1705.   BYTE  cd_trk_cna;
  1706.   //int done;
  1707.   int toc_retry;
  1708.   int i;
  1709.   int ret;
  1710.   
  1711.   /*
  1712.   ** init toc table
  1713.   */  
  1714.   {    
  1715.     for (i=0; i<=0x66; i++)
  1716.       settrkmsf(i, READTOC_INIT);    
  1717.   }
  1720.   for(toc_retry=0;toc_retry<READTOC_RETRY;toc_retry++)
  1721.   {  
  1722.       if(is_user_opened())
  1723.         return -1;
  1724.         
  1725.       flush_atapi();          
  1726.       ret=cdrom_read_tocentry(1,1,2,4);       
  1727.       
  1728.       if(ret==0)
  1729.         break;
  1730.       else if(ret<0)
  1731.        return -2;
  1732.       else
  1733.       {
  1734.         printf("READ TOC retry:%xn",toc_retry);        
  1735.       }  
  1736.   }
  1737.   
  1738.   if(toc_retry>=READTOC_RETRY)
  1739.   {
  1740.     printf("READ LONG TOC FAIL,exitn");    
  1741.     return -2;
  1742.   }
  1743.   
  1744.   { 
  1745.     UINT8 *p;
  1746.     int len,trk;
  1747.      
  1748.     len=(pwb[0]<<8) + pwb[1] - 2;  
  1749.     if( (len<=0)||(len>2048) )
  1750.     {
  1751.         printf("Read toc length errorn");
  1752.         return -2;
  1753.     }
  1754.     
  1755.     printf("toc table length:%dn",len);
  1756.     
  1757.     if(is_user_opened())
  1758.         return -1;
  1759.         
  1760.     cdrom_read_tocentry(1,1,2,(len/2*2)+4);
  1761.     
  1762. #if 0
  1763.     {
  1764.         int j;
  1765.         printf("=========================n");
  1766.         for(j=0;j<(len/11);j++)
  1767.         {
  1768.             for(i=0;i<=10;i++)
  1769.                 printf("%02x ",pwb[j*11+i]);             
  1770.             printf("n");
  1771.         }
  1772.         printf("=========================n");
  1773.     }   
  1774. #endif       
  1775.      SessionNs=0;           
  1776.      for (i=4; i<len; i+=11)
  1777.      {
  1778.        p=&pwb[i];
  1779.        
  1780.        cd_trk_cna=(p[1]&0x0f)<<4;
  1781.        cd_trk_cna|=(p[1]&0xf0)>>4;
  1782.        
  1783.        if(p[3]<=0xa2)
  1784.        {
  1785.                     
  1786.             
  1787.             if(p[3]==0xa0)
  1788.             {
  1789.                 trk=0x64;
  1790.                 if(p[0]==1)
  1791.                     {
  1792.                         cd_trk_lo_now=cd_trk_lo=p[8];                           
  1793.                     }else if(p[0]>1)
  1794.                     {
  1795.                         SessionNs=p[8];
  1796.                         printf("lo:%xn",p[8]);
  1797.                     }
  1798.                 
  1799.             }
  1800.             else if(p[3]==0xa1)
  1801.             {
  1802.                 cd_trk_hi=p[8];
  1803.                 trk=0x65;
  1804.                 
  1805.             }   
  1806.             else if(p[3]==0xa2)
  1807.             {
  1808.                 trk=0x66;
  1809.                 
  1810.             }   
  1811.             else
  1812.             {
  1813.                 trk=p[3];                   
  1814.                 if(trk>100)
  1815.                 {
  1816.                         printf("~~read toc trk no.(%x) error~~n",trk);
  1817.                         return -2;
  1818.                 }
  1819.             }   
  1820.             
  1821.             
  1822.             
  1823.             pFsJpeg->cdrom.track_info[trk]=((UINT32)(cd_trk_cna)<<24) | ((UINT32)p[8] <<16)| ((UINT32)p[9]<<8)  | ((BYTE)(p[10]));
  1824.             printf("trk:%d msf:%08xn",trk,pFsJpeg->cdrom.track_info[trk]);
  1825.        }
  1826.         
  1827.      }  
  1828.      pFsJpeg->cdrom.track_info[0]=pFsJpeg->cdrom.track_info[1];
  1829.      
  1830.      {
  1831.          UINT32 max,min;
  1832.          
  1833.          for(trk=cd_trk_lo_now;trk<cd_trk_hi;trk++)
  1834.          {
  1835.             max=pFsJpeg->cdrom.track_info[trk+1]&0xffffff;
  1836.             min=pFsJpeg->cdrom.track_info[trk]&0xffffff;
  1837.             if( (min>max)||(min==0xffffff) )
  1838.             {
  1839.                 cd_trk_hi=trk-1;
  1840.                 printf("Read toc length error,max:%x min:%xn",max,min);
  1841.                 break;
  1842.             }
  1843.          }
  1844.          
  1845.          if(cd_trk_hi<cd_trk_lo_now)
  1846.          {
  1847.               printf("Read toc length error,hi:%x low:%xn",cd_trk_hi,cd_trk_lo_now);
  1848.               return -2;
  1849.          }
  1850.      }
  1851.      printf("read finishn");
  1852.      return 0;
  1853.   }   
  1854. }
  1856. //=============ycwen 2004/08/10================
  1857. #ifdef NO_DVD_SERVO
  1858. void servo_turn_off(void)
  1859. {
  1860.     //Decoder gated clock
  1861.     WriteServoReg(0x4333,0x07);
  1862.     WriteServoReg(0x4334,0xff);
  1863.     WriteServoReg(0x4335,0xff);
  1864.     WriteServoReg(0x4336,0xff);
  1865.     WriteServoReg(0x4337,0xff);
  1866.     //Servo AFE power down
  1867.     WriteServoReg(0x4403,0x04);
  1868.     WriteServoReg(0x440e,0x02);
  1869.     WriteServoReg(0x4435,0x00);
  1870.     WriteServoReg(0x453c,0x20);
  1871.     //servo DSP gated clock
  1872.     WriteServoReg(0x4410,0x03);
  1873.     WriteServoReg(0x4416,0x01);
  1874. }
  1875. #endif //NO_DVD_SERVO
  1877. #if 0
  1878. void 
  1879. atapi_menu(void)
  1880. {
  1881.     char buf[5];
  1883.     while (1) {
  1884.         epp_write_wait("n");
  1885.         //printf("config 0x%04xn", regs0->dvddsp_config);
  1886.         epp_write_wait("1. EJECTn");
  1887.         epp_write_wait("2. LOADn");
  1888.         epp_write_wait("3. STARTn");
  1889.         epp_write_wait("4. STOPn");
  1890.         epp_write_wait("5. Hard Resetn");
  1891.         epp_write_wait("enter> continuen");
  1892.         //regs0->dvddsp_config = E10MHZ_MODE;
  1893.         regs0->dvddsp_config = 0;
  1894.         mon_read(buf);
  1895.         if (buf[0] == '1') {
  1896.             atapi_p_start_stop_unit(START_STOP_DO_EJECT);
  1897.             epp_write_wait("ejectn");
  1898.         } else if (buf[0] == '2') {
  1899.             atapi_p_start_stop_unit(START_STOP_DO_LOAD);
  1900.             epp_write_wait("loadn");
  1901.         } else if (buf[0] == '3') {
  1902.             atapi_p_start_stop_unit(START_STOP_DO_START);
  1903.             epp_write_wait("startn");
  1904.         } else if (buf[0] == '4') {
  1905.             atapi_p_start_stop_unit(START_STOP_DO_STOP);
  1906.             epp_write_wait("stopn");
  1907.         } else if (buf[0] == '5') {
  1908.             atapi_hard_rst();
  1909.             epp_write_wait("hard resetn");
  1910.         } else if (buf[0] == 0) {
  1911.             return;
  1912.         }
  1913.     }
  1914. }
  1918. UINT8
  1919. atapi_p_unlock(void)
  1920. {
  1921.     
  1922.     flush_atapi();
  1923.     
  1924.     memset(pc, 0, 12);
  1925.     pc[0] = 0x1E;
  1926.      pc[4] = 0x03;  
  1927.     if (atapi_do_packet(pc) == 1) {
  1928.         printf("atapi_p_unlock errorn");
  1929.          atapi_p_request_sense(pc_rdata);//kenny
  1930.         return 1;
  1931.     }
  1933.     return 0;   
  1934. }   
  1936. // read 512 bytes
  1937. UINT8 atapi_do_identify_packet_device(UINT8 *block_info)
  1938. {
  1939.     UINT8 block_cmd[4];
  1941.     memset(block_cmd, 0, 4);
  1942.     block_cmd[3] = 0xA1;
  1943.     atapi_write_block(block_cmd);
  1944.     if (atapi_is_error() == 1) {
  1945.         printf("do_identify_packet_device errorn");
  1946.         return 1;
  1947.     }
  1948.     if (atapi_receive_data(block_info, 512) == 1) {
  1949.         printf("do_identify_packet_device receive errorn");
  1950.         return 1;
  1951.     }
  1953.     return 0;
  1954. }
  1956. UINT8 
  1957. atapi_read_cd_msf(t_cdrom_msf *pmsf)
  1958. {
  1959.     UINT8 pc[12];
  1960.     UINT8 pc_rdata[32];
  1962.     memset(pc, 0, 12);
  1963.     pc[0] = 0xB9;
  1965.     pc[3] = pmsf->m0; 
  1966.     pc[4] = pmsf->s0;
  1967.     pc[5] = pmsf->f0;
  1969.     pc[6] = pmsf->m1;
  1970.     pc[7] = pmsf->s1;
  1971.     pc[8] = pmsf->f1;
  1973.     pc[9] = 0x10;  
  1974.     print_block(pc, 12);
  1976.     if (atapi_do_packet(pc) == 1) {
  1977.         printf("p_read_cd_msf errorn");
  1978.         atapi_p_request_sense(pc_rdata);
  1979.         return 1;
  1980.     }
  1982.     return 0;
  1983. }
  1985. UINT8 
  1986. atapi_p_read_capacity(UINT32 *plba, UINT32 *plen)
  1987. {
  1988.     UINT8 *p;
  1989.     UINT8 pc[12];
  1990.     UINT8 pc_rdata[32];
  1992.     memset(pc, 0, 12);
  1993.     pc[0] = 0x25;
  1995.     if (atapi_do_packet(pc) == 1) {
  1996.         printf("p_read_capacity errorn");
  1997.          atapi_p_request_sense(pc_rdata);//kenny
  1998.         return 1;
  1999.     }
  2001.     memset(pc_rdata, 0, 12);
  2002.     if (atapi_receive_data(pc_rdata, 8) == 1) {
  2003.         printf("p_read_capacity receive data errorn");
  2004.         return 1;
  2005.     }
  2007.     p = pc_rdata;
  2008.     print_block(p, 12);
  2009.     *plba = getUINT32_bi(((UINT8 *)p) + 0);
  2010.     *plen = getUINT32_bi(((UINT8 *)p) + 4);
  2012.     return 0;
  2013. }
  2016. #endif