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

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

DVD

开发平台：

C/C++

atapi_if728.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.                    
  12. =================================================================*/
  15. //#define NPRINTF
  16. //#define NEPRINTF
  18. #include "config.h"
  19. #include "misc.h"
  20. #include "global.h"
  21. #include "ata.h"
  22. #include "fs.h"
  23. #include "cderr.h"
  24. #include "drv.h"
  25. #include "sinf.h"
  27. #include "atapi_if.h"
  28. #include "pu8560.h"
  30. #include "emuio.h"
  31. #include "lbaif.h"
  33. #if 0//def SUPPORT_SPI_QSI
  34. #include "iop.h"
  35. #endif
  37. #ifdef SUPPORT_CD_TEXT
  38.     #include "CDTextUtil.h"
  39.     #include "memmap0.h"
  40. #endif
  42. #ifndef DVDRELEASE
  43. //#define DBG_ATAPI
  44. #endif
  46. #ifndef DBG_ATAPI
  47. #undef printf
  48. #undef print_block
  49. #define printf(f, a...) do {} while (0)
  50. #define print_block(x,y) do {} while (0)
  51. #endif
  53. extern UINT8  cIDEStatus;
  54. extern UINT8  *pServoMemXferPtr;
  55. extern UINT16 wServoMemXferLen;
  56. extern UINT8 cHostDVDDSPMode;
  57. extern UINT8 cCmdBlock[12];
  58. extern void ServoDecMainLoop(void);
  59. extern void save_cmp_disc_info(UINT32 info1);//wanghaoying 20030812
  60. extern UINT32 search_file(BYTE*);
  61. void IDECommandProc(void);
  62. void ServoDecInit(void);
  63. void ResetInterfaceProc(void);
  65. //==================================================================
  66. //UINT8 pc[12];  //reduce global var.
  67. //UINT8 pc_rdata[32];
  68. UINT16 request_sense_flag;
  69. // 0: DISC_VCD, 1: DISC_DVD
  70. UINT8 DiscType = CDDVD;
  71. //UINT8 CSSEnable = 0;
  72. UINT32 udf_find_anchor(void);
  74. //==================================================================
  75. #define DVDDSP_CONFIG_DEF ATA_INTR_MODE //ATAPI_INTR_MODE
  76. #define WaitIRQ()   while ((regs0->dvddsp_function & DEVICE_INT) == 0) ;//for test DRQ mode
  78. #define SHORT_TIME_OUT 400//4 sec
  79. #define NORMAL_TIME_OUT 700//7 sec 
  80. #define LONG_TIME_OUT 800//8 sec
  81. #define MAX_TIME_OUT       1000//10 sec
  84. //==================================================================
  85. //extern function and varible
  86. void disp_fan_in(void);
  87. void flush_atapi(void);;
  88. void cppm_init( UINT32 );
  89. void polling();
  90. extern UINT8   bReadSubChannel; //Jeff 20020927
  91. extern UINT16  iBlockLen;
  94. //terry,2004/2/6 05:43PM
  95. #ifdef DVD_SERVO
  96. //
  97. // FUNCTION
  98. // atapi_dvddsp_busy_waiting()
  99. //
  100. // DESCRIPTION
  101. // compatible atapi 
  102. //
  104. void atapi_dvddsp_busy_waiting(int seek)
  105. {
  106.    set_host_request();
  107.    ServoDecMainLoop();   // DVD_SERVO
  108. }
  109. #endif
  111. //==================================================================
  112. // ATAPI Procedure
  113. // return 1: ERR, 0: OK
  114. //inline UINT8 
  116. UINT16
  117. atapi_reg_read(UINT8 addr)
  118. {
  119. addr = IDE_STATUS;
  120. return (UINT16)cIDEStatus;
  121. }
  122.  
  124. UINT8 atapi_is_error(void)
  125. {
  126. return (atapi_reg_read(IDE_STATUS) & STATUS_ERR);
  127. }
  129. int atapi_read_error(void)
  130. {
  131. UINT16 id;
  132.     UINT8 ubuf[20];
  133.     
  134.     id=atapi_reg_read(IDE_STATUS) & STATUS_ERR;
  135. if (id != 0) 
  136. { 
  137. printf("atapi_read_error:error %dn",id);
  138. atapi_p_request_sense(ubuf);
  139. cderr_update_show_time();
  140. return -1;
  141. }
  143. return 0;
  144. }
  147. UINT8 atapi_rst(UINT8 mode)
  148. {
  149.     printf("atapi_rst: reset mode:%xnn",mode);
  151. if (mode & DSP_HOST_RESET) 
  152. {
  153. //necessary reset Loader HW
  155.         ServoDecInit();
  156.         ResetInterfaceProc();
  157.         
  158.         #ifdef SERVO_RANDOM_SEEK
  159.         while(1)
  160.         {
  161.          polling(); // for random seek
  162.          ServoDecMainLoop(); // barry add for polling servo status
  163.         }
  164.         #endif 
  165.         
  166. }
  167.     if(mode&ATA_SW_RESET)
  168.     { 
  169.      //necessary IDE_COMMAND=0x08 Driver reset        
  170. }
  172. if(mode&ATA_WAIT_RDY)
  173. {
  174.     //terry,2002/5/31 09:56PM, FUSS request: open must be avaible
  175.     
  176.     do
  177.     {
  178.        ServoDecMainLoop();
  179.     } while ( (cIDEStatus&0x80) == 0x80 );  // BSY bit
  181. io_write("Servo Start-up finishn");
  183. //wait 10sec for atapi_p_test_unit_ready() 
  184. //else return ATAPI_ERROR;
  185. }
  187.     return 0;//success
  188. }
  190. UINT8
  191. atapi_receive_data(UINT8 *p, int n)
  192. {
  193.    #define TIMEOUT 100 //1s
  194.    #define GET_RTC_15_0() (regs0->rtc_15_0)
  195.    UINT32 old,now,cnt;
  196.    
  197.    memset(p, 0, n);//clear buffer
  198.    //wait servo  ,run polling
  199.    //receive data to pointer p,size n
  201.    pServoMemXferPtr = p;
  202.    wServoMemXferLen = n;
  203.    cHostDVDDSPMode = 0;
  205.    old = GET_RTC_15_0(); 
  206.    
  207.    //for read disc, open tray delay bug.
  208.    if(system_state==SYSTEM_READ_TITLE)  cnt=TIMEOUT;//terry,2003/11/21 04:03PM
  209.    else cnt=0;
  210.    
  211.    do
  212.    {  
  213.       now = GET_RTC_15_0();   
  214.       if(old!=now)
  215.       {
  216.         cnt++;
  217.         old=now;
  218.       }
  219.       
  220.       if(cnt>TIMEOUT)
  221.       {
  222.           polling();          
  223.          // printf(".");
  224.       }
  225.       //ycwen 2005/1/21: To prevent audio buffer from underflow when ran_read() taking too much time (e.x. long seek)
  226.       #ifdef MP3_JPEG_COWORK 
  227.       polling_read_data();
  228.       #endif
  229.       
  230.       disp_fan_in();//terry 20030902       
  231.       ServoDecMainLoop();
  232.    } while ( (cIDEStatus&0x80) == 0x80 );  // BSY bit
  234.    //printf("IDE Status1 : %x n",cIDEStatus);
  236.    return atapi_is_error();
  237. }
  240. UINT8
  241. atapi_do_packet(UINT8 *pck)
  242. {
  243. #if 0
  244.     UINT8 i;
  245.     for (i=0 ; i<12 ; i++) { cCmdBlock[i] = *(pck+i); }
  246. #endif
  247.     
  248.     memcpyS(cCmdBlock,pck,12);    
  249.     print_block(cCmdBlock,6);
  250.     
  251.     IDECommandProc();
  253.     if (cIDEStatus & 0x01)
  254.         return ATAPI_ERROR;
  255.     else
  256.         return ATAPI_OK;
  257. }
  260. //return 
  261. //  1: error
  262. //  0: ok     
  263. /*UINT8 atapi_do_set_features(void)
  264. {
  265.   return 0;
  266. }*/
  269. // Packet command
  270. // read 18 bytes
  271. UINT8 
  272. atapi_p_request_sense(UINT8 *block_info)
  273. {
  274. int sense_key;
  275. UINT8 pc[12];
  277.     request_sense_flag=0;
  278. memset(pc, 0, 12);
  279. pc[0] = 0x03;
  280. pc[4] = 0x12;
  282. atapi_do_packet(pc);
  284. if (atapi_receive_data(block_info, 18) == 1) {
  285. printf("p_request_sense receive data errorn");
  286. return 1;
  287. }
  289.     sense_key=block_info[2]&0xf;
  290. if (block_info[2] == 00) {
  291. printf("no sensen");
  292. } else {
  293. //printf("Sense key: 0x%02xn",sense_key);
  294. //printf("ASC: 0x%02xn", block_info[12]);
  295. //printf("ASCQ:0x%02xn", block_info[13]);
  298. if(sense_key==2)
  299. {
  300. if(block_info[12]==0x04)
  301.            request_sense_flag|=ATAPI_NOT_READY;
  302.         else if((block_info[12]==0x3A)&&(block_info[13]==0x00))
  303.        request_sense_flag|=ATAPI_NO_MEDIA;
  304.     else if((block_info[12]==0x06)&&(block_info[13]==0x00))
  305.        request_sense_flag|=ATAPI_MEDIA_UPSIDE_DOWN;
  306. }else if(sense_key==5)
  307. {
  308. if(block_info[12]==0x30)
  309.        request_sense_flag|=ATAPI_UNKNOWN_MEDIA;
  310.     else if(block_info[12]==0x64)
  311.        request_sense_flag|=ATAPI_ILLEGAL_MODE;
  312. }
  313.         else if(sense_key==4) //servo can't focus for a long time, Jeff 20031203
  314. {
  315. request_sense_flag|=ATAPI_UNKNOWN_MEDIA;
  316. }
  317. }
  319. return 0;
  320. }
  322. UINT8
  323. atapi_p_test_unit_ready(void)
  324. {
  325. int ret;
  326. UINT8 pc[12];
  327.     UINT8 pc_rdata[32];
  329. memset(pc, 0, 12);
  330. //printf("!");
  332. ret=atapi_do_packet(pc);//ret==0, unit is ready
  334. //if(ret==1)
  335. if (cIDEStatus & 0x01)  // CHECK bit assert
  336. {
  337.  atapi_p_request_sense(pc_rdata);//kenny
  338.  
  339.  if(request_sense_flag&ATAPI_NO_MEDIA)
  340.  ret=ATAPI_NO_MEDIA;
  341. else if(request_sense_flag&ATAPI_NOT_READY)
  342.   ret=ATAPI_NOT_READY;
  344. else if(request_sense_flag&ATAPI_MEDIA_UPSIDE_DOWN)
  345.   ret=ATAPI_MEDIA_UPSIDE_DOWN; 
  346. else if(request_sense_flag&ATAPI_UNKNOWN_MEDIA)
  347.   ret=ATAPI_UNKNOWN_MEDIA; 
  348. else
  349.   ret=0xff; 
  350.  
  351. }
  353. return ret;
  354. }
  356. UINT8 
  357. atapi_p_start_stop_unit(UINT8 start)
  358. {
  359. UINT8 pc[12];
  360.     UINT8 pc_rdata[32];
  361.     
  362. flush_atapi();
  363. atapi_read_error();
  365. memset(pc, 0, 12);
  366. pc[0] = 0x1B;
  367. pc[1] = 0x01;
  368. pc[4] = start;
  369. if (atapi_do_packet(pc) == 1) {
  370. printf("p_start_stop_unit errorn");
  371.  atapi_p_request_sense(pc_rdata);//kenny
  372. return 1;
  373. }
  375. return 0;
  376. }
  379. UINT8 
  380. atapi_p_mechanism_status(void)
  381. {
  382. UINT8 pc[12];
  383.     UINT8 pc_rdata[32];
  385. flush_atapi();//alan 2002/5/30 06:29PM added to solve standby wake up fail when power on/off
  386. memset(pc, 0, 12);
  387. pc[0] = 0xBD;
  388. pc[9] = 0x08;
  389. if (atapi_do_packet(pc) == ATAPI_ERROR) {
  390. printf("p_mechanism_status do_packet errorn");
  391.  atapi_p_request_sense(pc_rdata);//kenny
  392. return ATAPI_ERROR;
  393. }
  395. memset(pc_rdata, 0, 8);
  396. if (atapi_receive_data(pc_rdata, 8) == ATAPI_ERROR) {
  397. printf("p_mechanism_status receive data errorn");
  399. #ifdef SHOW_SPECIAL_DISC_TYPE
  400.         read_disc_state = 0xf0; 
  401.         #endif
  402.         
  403. return ATAPI_ERROR;
  404. }
  406. //    printf("%dn", pc_rdata[1] >> 5);
  407.    
  408.     if(pc_rdata[1] & 0x01) 
  409. {
  410. //   printf("===============>>>>>door close errorn");
  411.   
  412.       return ATAPI_DOOR_CLOSE_ERR;
  413. }else if (((pc_rdata[1] >> 4) & 1) == 0) 
  414. {
  415. //   printf("door closen");
  416.       return ATAPI_DOOR_CLOSE;
  417. }
  419. //   printf("door openn");
  420. return ATAPI_DOOR_OPEN;
  421. }
  426. UINT8 
  427. atapi_p_read_12(UINT32 lba, UINT32 len)
  428. {
  429. BYTE ret;
  430. UINT8 pc[12];
  431.     UINT8 pc_rdata[32];
  433. memset(pc, 0, 12);
  434. pc[0] = 0xA8;
  436. pc[2] = (lba >> 24) & 0x000000ff; /* LBA (MSB) */
  437. pc[3] = (lba >> 16) & 0x000000ff;
  438. pc[4] = (lba >> 8) & 0x000000ff;
  439. pc[5] =  lba & 0x000000ff; /* LBA (LSB) */
  441. pc[6] = (len >> 24) & 0x000000ff;   // transfer length(MSB)
  442. pc[7] = (len >> 16) & 0x000000ff;        
  443. pc[8] = (len >> 8) & 0x000000ff;          
  444. pc[9] =  len & 0x000000ff;  
  445.     
  446.     ret=atapi_do_packet(pc);
  448. if(dev_status_flag&READ_PRESENT_DATA)
  449.          dev_status_flag&=~READ_PRESENT_DATA;
  451. if (ret == 1) {
  452. printf("!!!!!!!!p_read_12 errorn");
  454.         atapi_p_request_sense(pc_rdata);
  455.         printf("!!!!!!!!Request outn");
  456.       
  457.       if(request_sense_flag&ATAPI_NOT_READY)
  458.       {
  459.        printf("!!!!!!!!p_read_12 error, unit not readyn");
  460.     
  461.              cderr_handler(CDERR_ATA_NOT_READY);
  462.           
  463.            if(atapi_do_packet(pc) == 1) 
  464.        {
  465.        printf("p_read_12 again errorn");
  466.         atapi_p_request_sense(pc_rdata);//kenny
  467.       
  468.        }
  469.       
  470.              
  471.       
  472.       }//not ready
  473.       else if(request_sense_flag&ATAPI_ILLEGAL_MODE)
  474.       {
  475.       
  476.        return ATAPI_ILLEGAL;
  477.       
  478.   
  480.       } 
  481.           
  482. return 1;
  483. }
  485. return 0;
  486. }
  488. // generic packet command
  489. void 
  490. init_cdrom_command(struct cdrom_generic_command *cgc, void *buffer, int len)
  491. {
  492. memset(cgc, 0, sizeof(*cgc));
  493. memset(buffer, 0, len);
  494. cgc->buffer = (char *) buffer;
  495. cgc->buflen = len;
  496. }
  498. // only support 3 commands now
  499. // return 0: ok, -1: error
  500. int 
  501. generic_packet(struct cdrom_generic_command *cgc)
  502. {
  503.     UINT8 pc_rdata[32];
  505. if ((cgc->cmd[0]==GPCMD_READ_DVD_STRUCTURE)||(cgc->cmd[0]==GPCMD_REPORT_KEY))
  506. {
  507. if (atapi_do_packet(cgc->cmd)!=0)
  508. {
  509. printf("generic_packet:packet errorn");
  510. atapi_p_request_sense(pc_rdata);
  511. memset(cgc->buffer,0,cgc->buflen);
  512. return -1;
  513. }
  514. atapi_receive_data(cgc->buffer, cgc->buflen);
  515. }
  516. else if(cgc->cmd[0]==GPCMD_SEND_KEY)
  517. {
  518. if (atapi_do_packet(cgc->cmd)!=0)
  519. {
  520. printf("generic_packet:packet errorn");
  521. atapi_p_request_sense(pc_rdata);
  522. return -1;
  523. }
  524. //atapi_send_data(cgc->buffer, cgc->buflen);
  525. }
  528.     return atapi_read_error();
  529. }
  533. UINT8 
  534. atapi_get_cprm_config(void)
  535. {
  536. BYTE ret=0;
  537. UINT8 pc[12];
  538.     UINT8 pc_rdata[32];
  540. memset(pc, 0, 12);
  541. pc[0] = 0x46;   
  542. pc[1] = 0x02; //feature descriptor be returned
  543. pc[2] = 0x01; //cprm 
  544. pc[3] = 0x0B;
  546. // transfer length
  547. pc[8] = 0x08;   
  548.     if( atapi_do_packet(pc)==0 )
  549.     {
  550. if(atapi_receive_data(pc_rdata, 8) ) 
  551. {
  552. printf("atapi_get_cprm_config  receive errorn");
  553. //memset(pc_rdata, 0, 2048*len);    
  554. ret = ATAPI_ERROR;    
  555. }else
  556. {
  557. print_block(pc_rdata,8);//01:0x010B
  558. if(pc_rdata[2]&0x01)
  559. {
  560. printf("DVD-R,DVD-RW or DVD-RAMn");
  561. }
  562. } 
  563. }else
  564. {
  565. printf("get cprm config failn");
  566.         atapi_p_request_sense(pc_rdata);
  567.         ret = ATAPI_ERROR;    
  568. }
  570. return ret;
  571. }
  573. /*
  574. *   lba: read start location
  575. *   len: read start length
  576. */
  579. UINT8 
  580. atapi_block_read(UINT32 lba, UINT32 len)
  581. {
  582.     UINT8 pc_rdata[32];
  584. #ifdef USE_HDD
  585.     extern UINT8 hdd_block_read(UINT32 lba, UINT32 len);
  586.       //Verdure add, cyue:2002-06-12 04:45PM modified
  587.       if  (hd_play)
  588.       {
  589.           hdd_block_read(lba, len);
  590.           return 0;
  591.       }
  592. #endif
  594.     if (atapi_is_error() == ATAPI_ERROR) 
  595.     {
  596. printf("enter block_read errorn");
  597. atapi_p_request_sense(pc_rdata);
  598. cderr_handler(CDERR_DAT_DISCONTINUE);
  600. return ATAPI_ERROR;
  601. }
  603. if (is_user_opened())
  604. {
  605. printf("USER OPEN!!!n");
  606. return ATAPI_ERROR;
  607. }
  609. dev_status_flag|=READ_PRESENT_DATA;//kenny
  610.    
  611. cHostDVDDSPMode = 1;
  613. if (DiscType != CDDVD)
  614. {
  615. //printf("readcdn");
  616. if (atapi_read_cd(lba, len) == ATAPI_ERROR) 
  617.     return ATAPI_ERROR;
  619. }
  620. else
  621. { // DVD
  622. //printf("read12n");
  623.     if (atapi_p_read_12(lba, len) == ATAPI_ERROR) return ATAPI_ERROR;      
  624. }
  625.    
  626.   
  627.     if (atapi_reg_read(IDE_STATUS) == 0x50) 
  628.     {   //DRQ=0,BSY=0,DRDY=1,DSC=1
  629.        printf("skip directly!n");
  630.        return ATAPI_ERROR;
  631.     }   
  632.   
  633.     return ATAPI_OK;
  634. }
  637. void 
  638. atapi_init(void)
  639. {
  640.     //io_write("Servo atapi_init Start!n");
  642.     //ServoDecInit();
  643.     //ResetInterfaceProc();
  645.     hostx_servo_buf_init();
  646.     atapi_rst(DSP_HOST_RESET|ATA_HW_RESET);
  648.     //delay(1);
  650.     atapi_p_test_unit_ready();//start up loader
  652.     //io_write("Servo atapi_init End!n");
  653. }
  656. #include "dvdioctl.h"
  658. void disc_init(void)
  659. {
  660. //    #define DISC_IS_DVD() (gbSrvDiscStatus&0x40)//terry,2003/12/26 03:01PM
  661. //    extern BYTE gbSrvDiscStatus;
  662.     int     iRetry, nTryNum;
  663.     UINT32  iAnchor=0;
  664.    //UINT32 dVTS_LSN_VOB,dVTS_LSN_IFO;//terry,mark it,2003/8/7 02:19AM
  665.    
  666.    DiscType = CDUNKNOWN;
  667.    printf("disc_init n");
  669.    //add re-try anchor when read DVD disc, Jeff 20031017
  670.    if ( DISC_IS_DVD() )
  671.        nTryNum = 2;
  672.    else
  673.        nTryNum = 1;
  675.     for (iRetry=0; iRetry<nTryNum; iRetry++) {
  676.         iAnchor = udf_find_anchor();
  677.         if (iAnchor !=0) break;
  678.         
  679.         // 2004/07/16 yltseng
  680.         wb_tag_init();
  681.     }
  683.    //if (udf_find_anchor() == 0) 
  684.    //{
  685.    //     printf("no anchor foundn");
  686.    //}
  687.     if ( (iAnchor == 0) && (iRetry>=nTryNum) ) {
  688.         printf("no anchor foundn");
  689.     }
  690.    else
  691.    {        
  692.         printf("initialize filesystemn");
  693.         if ( fs_init() < 0) return;
  694.         if(dVMG_LSN)
  695.         {
  696.        DiscType = CDDVD;
  697.        cd_type_loaded=DiscType;
  698. #if defined (SAME_DISC_RESUME) || defined (RECORD_KEY) || defined(POWER_RESUME) //terry,2003/8/7 02:20AM
  699. #ifdef DVD_AUDIO//nono 2004-2-25 0:40
  700.           if((cd_type_loaded==CDDVD) && (dAMG_LSN==0)) 
  701. #endif //DVD_AUDIO
  702.   {
  703. same_disc_vob11_pos = search_file("VTS_01_1.VOB");
  704. save_cmp_disc_info(same_disc_vob11_pos);
  705.   }
  706. #endif //Maoyong 2004.02.25 end #if defined (SAME_DISC_RESUME) || defined (RECORD_KEY) || defined(POWER_RESUME) //terry,2003/8/7 02:20AM
  707. #define ALWAYS_ENABLE_CSS
  708. #ifdef  ALWAYS_ENABLE_CSS
  709. //            CSSEnable=1;
  710. #else            
  711. {
  712.         dvd_struct s;
  713.         
  714.             s.type = DVD_STRUCT_COPYRIGHT;
  715.     s.copyright.layer_num = 0;
  717.     dvd_read_struct(&s);
  718.             CSSEnable=s.copyright.cpst;
  719. }
  720. #endif            
  721.         }
  722. #ifdef DVD_AUDIO
  723.         cppm_init( dAMG_LSN );
  724. #endif
  725.    }
  726. }
  728. BYTE user_only=0;
  729. //user_only : 
  730. // 1:user data only
  731. // 0:ATAPI_READCD_9_SYNC|ATAPI_READCD_9_HEADER_ALL|ATAPI_READCD_9_USERDATA
  732. // | ATAPI_READCD_9_ECC;
  733. //if ( (cd_type_loaded==CDDA) && (cd_subtype!=CD_DTS) )
  734. //      pc[10]=bReadSubChannel; //Jeff 20020927
  735. UINT8 
  736. atapi_read_cd(UINT32 lba, UINT32 len)
  737. {
  738. BYTE ret;
  739. UINT8 pc[12];
  740.     UINT8 pc_rdata[32];
  742. memset(pc, 0, 12);
  743. pc[0] = 0xBE;
  745.     // LBA
  746. pc[2] = (lba >> 24) & 0x00ff; 
  747.    pc[3] = (lba >> 16) & 0x00ff;
  748.    pc[4] = (lba >> 8) & 0x00ff;
  749.    pc[5] =  lba & 0x00ff;  
  751.    // transfer length
  752.    pc[6] = (len >> 16) & 0x00ff;
  753.    pc[7] = (len >> 8) & 0x00ff;          
  754.    pc[8] =  len & 0x00ff;  
  755.   
  756.    // ....
  757. #define ATAPI_READCD_9_SYNC (1<<7)
  758. #define ATAPI_READCD_9_HEADER_NONE (0<<5)
  759. #define ATAPI_READCD_9_HEADER_HEADER (1<<5)
  760. #define ATAPI_READCD_9_HEADER_SUBHEADER (2<<5)
  761. #define ATAPI_READCD_9_HEADER_ALL (3<<5)
  762. #define ATAPI_READCD_9_USERDATA (1<<4)
  763. #define ATAPI_READCD_9_ECC (1<<3)
  765.    if(user_only==1)
  766.    {
  767.       pc[9] =0x10;
  768.    }
  769.    else
  770.    {
  771.       pc[9] = ATAPI_READCD_9_SYNC
  772.       | ATAPI_READCD_9_HEADER_ALL
  773.          | ATAPI_READCD_9_USERDATA
  774.      | ATAPI_READCD_9_ECC;
  775. }
  777.     if ( (cd_type_loaded==CDDA) && (cd_subtype!=CD_DTS) )
  778.         pc[10]=bReadSubChannel; //Jeff 20020927
  780.      ret=atapi_do_packet(pc);
  782.  if((dev_status_flag&READ_PRESENT_DATA))         
  783.  {
  784.          dev_status_flag&=~READ_PRESENT_DATA;
  785.      }  
  787. if (ret == 1) 
  788. {
  789. printf("p_read_cd errorn");
  790.         atapi_p_request_sense(pc_rdata);
  791. return 1;
  792. }
  794. return 0;
  795. }
  797. int 
  798. cdrom_read_tocentry(int trackno, BYTE format, int buflen)
  799. {
  800. UINT8 pc[12];
  801.     UINT8 pc_rdata[32];
  803. memset(&pc, 0, sizeof(pc));
  805. pc[0] = 0x43;
  806. pc[2] = format;//2001/9/26
  807. pc[6] = trackno;
  808. pc[7] = (buflen >> 8);
  809. pc[8] = (buflen & 0xff);
  810. pc[1] = 2;//msf_flag
  812. if (atapi_do_packet(pc) == 1) {
  813. printf("cdrom_read_tocentry errorn");
  815.         atapi_p_request_sense(pc_rdata);
  818. if(request_sense_flag&ATAPI_NOT_READY)//kenny
  819.       {
  820.       
  821.        printf("!!!!!cdrom_read_tocentry , Unit not ready");
  822.     
  823.     
  824.     
  825.      cderr_handler(CDERR_ATA_NOT_READY);
  826.     
  827.      if (atapi_do_packet(pc) == 1) {
  828. printf("cdrom_read_tocentry error againn");
  830.  atapi_p_request_sense(pc_rdata);
  831. } 
  832.     
  833.            
  834.       
  835.       } //if(not_ready==1)
  839.        
  840. return 1;
  841. }
  843. //memset(pc_rdata, 0, sizeof(pc_rdata));
  845. //if (atapi_receive_data(pc_rdata, buflen) == 1) {
  846. //memset(pwb, 0, sizeof(pwb));
  847. if (atapi_receive_data(pwb, buflen) == 1) {
  849. printf("cdrom_read_tocentry receive data errorn");
  850. return 1;
  851. }
  853. return 0;
  854. }
  855. /************************************************/
  856. // atapi_p_mode_sense:
  857. //  This function is only used before excute disc_init().
  858. //  Because before reading TOC( disc type is unknown), I don't know read command should be command 0xA8 or 0xBE.
  859. //  I found that if disc is CDDA and send 0xA8 or 0x28 to loader, then loader will response illegle mode error.
  860. //  So we must make sure disc is CDDA or not. 
  861. //  If DISC is CDDA then DiscType is setting CDDA, for other disc  DiscType is CDDVD. 
  862. //  And we can use disc_init() to identify disc is real DVD disc or not. 
  863. //  If it is not DVD disc then read toc to classify CDDA,VCD, MP3.
  864. //  
  865. /***********************************************/
  866. BYTE atapi_p_get_disc_info(void)
  867. {
  868.     BYTE buflen;  
  869.     UINT8 pc[12];
  871. pc[0] = 0x5A;
  872. pc[2] = 0x41;
  873. pc[7] = 0;
  874. pc[8] = buflen = 0x0A;
  877. atapi_do_packet(pc);
  879. // wait_servo();
  880.   
  881. if (atapi_receive_data(pwb, buflen) == 1) 
  882. {
  883. printf("atapi_mode_sense receive data errorn");
  884. return 1;
  885. }
  886.    
  887.     if(pwb[2]==0x02||pwb[2]==0x06||pwb[2]==0x12||pwb[2]==0x16||pwb[2]==0x22||pwb[2]==0x26)      
  888.          DiscType=CDDA;
  889.     else if(pwb[2]==0x41)
  890.          DiscType=CDDVD;          
  891.     else
  892.     {
  893.      printf("atapi_p_get_disc_infon");
  894.          DiscType=CDUNKNOWN; 
  895.     }
  896. return 0;
  897. }
  900. int
  901. atapi_open_tray(void)
  902. {
  903. #if 0//def SUPPORT_SPI_QSI
  904. BYTE run_in_value;
  905. ReadFromI2c(I2C_ID_MEMORY,PRODUCTION_TESTING,(BYTE *)&run_in_value,sizeof(run_in_value));
  907. if(run_in_value==0)//production reset
  908. return;
  909. #endif
  911. printf("openn");
  912. return atapi_p_start_stop_unit(START_STOP_DO_EJECT);                      
  913. }
  914. int
  915. atapi_close_tray(UINT8 nStatus)
  916. {
  917. #if 0//def SUPPORT_SPI_QSI
  918. BYTE run_in_value;
  919. ReadFromI2c(I2C_ID_MEMORY,PRODUCTION_TESTING,(BYTE *)&run_in_value,sizeof(run_in_value));
  921. if(run_in_value==0)//production reset
  922. return;
  923. #endif
  925. printf("closen");
  926. if (!nStatus) // Robert 2003/12/16
  927. return atapi_p_start_stop_unit(START_STOP_DO_LOAD);
  928. else
  929. return atapi_p_start_stop_unit(START_STOP_DO_LOAD_POWER_OFF);
  930. }
  931. int
  932. atapi_abort_play(void)
  933. {
  934. printf("stopn");
  935. if(!is_user_opened())
  936. {
  937.     return atapi_p_start_stop_unit(START_STOP_DO_STOP);
  938. }else
  939.     return 0;
  940. }
  942. //terry,2003/8/23 08:03PM
  943. int
  944. atapi_standby_mode(void)
  945. {
  947. #if defined(TOP_DOOR_LOADER)||defined(TCL_STANDBY)||defined(CHECK_PORTABLE_OPCLSW) //Jack added 04/11/25 //2004-4-19 18:59 lijd
  948.         extern  UINT8   srv_on;
  949.         printf("stopn");
  950. atapi_p_start_stop_unit(START_STOP_DO_STOP);
  951. #ifndef TOP_DOOR_FOR_NGAILIK     //hq add for ngailik, in order to wake up the system after power off-on quickly switch. 2004-3-3 17:38
  952.    if(srv_on!=0)                 //wthsin,2004/8/9 09:33pm to fast the standby time in Top Loader 
  953.     delay_srv_10ms(300);    
  954. #endif//TOP_DOOR_FOR_NGAILIK
  955. #endif
  956. printf("standbyn");
  957. return atapi_p_start_stop_unit(START_STOP_DO_STANDBY);
  958. }
  960. #ifdef SUPPORT_CD_TEXT
  961. int atapi_read_cd_text( void )
  962. {      
  963.     int iCDTextRetry = 0;
  964.     for( ; iCDTextRetry < READTOC_RETRY; iCDTextRetry++ )
  965.     {        
  966.         if(is_user_opened())
  967.             return -1;
  968.      
  969.         flush_atapi();      
  970.         int iRet = cdrom_read_tocentry( 1, 5, 4 );     
  971.      
  972.         if( iRet == 0 )
  973.             break;
  974.         else if( iRet < 0 )
  975.             return -2;
  976.         else
  977.             printf( "READ CD TEXT retry:%xn", iCDTextRetry );
  978.     }
  979.     
  980.     if( iCDTextRetry >= READTOC_RETRY )
  981.     {
  982.         ClearCDTextData();//lizhx 2004/08/23
  983.         printf( "READ CD TEXT FAIL,exitn" );    
  984.         return -2;
  985.     }
  986.      
  987.     int iLen = (pwb[0]<<8) + pwb[1];  
  988.     if( ( iLen <= 0 ) || ( iLen > 2048 ) )
  989.     {
  990.         printf( "Read CD TEXT length errorn" );
  991.         return -2;
  992.     }
  994.     printf( "CD TEXT length:%dn", iLen - 2 );
  996.     if( is_user_opened() )
  997.         return -1;
  998.   
  999.     cdrom_read_tocentry( 1, 5, ( iLen / 2 * 2 ) + 4 );
  1001.     PreParseCDTextData( pwb, iLen, cd_trk_hi - cd_trk_lo, (BYTE*) ( SDRAM_BASE + ( ( CD_TEXT_YA )<< 10 ) ), CD_TEXT_SIZE );
  1002. }
  1003. #endif
  1005. /*
  1006. ** FUNCTION
  1007. ** atapi_read_toc
  1008. **
  1009. ** History : 2003/12/08(Jeff) when (is_svo_dvd()), change to fmt=0
  1010. */
  1011. int atapi_read_toc(void)
  1012. {
  1013.     BYTE    cd_trk_cna;
  1014.     int     toc_retry;
  1015.     int     i;
  1016.     int     ret;
  1017.     BYTE    fmt;
  1018.     int     iSize;
  1020.     if ( is_svo_dvd() ) {
  1021.         fmt     = 0;
  1022.         iSize   = 4;
  1023.     } else {
  1024.         fmt     = 2;
  1025.         iSize   = 6;
  1026.     }
  1027.   
  1028. #ifdef NINTAUS_DVD
  1029. fmt     = 2;
  1030. iSize   = 6;
  1031. #endif
  1032.   
  1033.     //
  1034.     // init toc table
  1035.     //
  1036.     for (i=0; i<=0x66; i++)
  1037.         settrkmsf(i, READTOC_INIT);
  1040.     for(toc_retry=0;toc_retry<READTOC_RETRY;toc_retry++)
  1041.     {
  1042.         if(is_user_opened())
  1043.             return -1;
  1044.      
  1045.         flush_atapi();      
  1046.         ret = cdrom_read_tocentry(1, fmt, 4);     
  1047.      
  1048.         if(ret==0)
  1049.             break;
  1050.         else if(ret<0)
  1051.             return -2;
  1052.         else
  1053.         {
  1054.             printf("READ TOC retry:%xn",toc_retry);        
  1055.         }
  1056.     }
  1057.   
  1058.     if(toc_retry>=READTOC_RETRY)
  1059.     {
  1060.         printf("READ LONG TOC FAIL,exitn");    
  1061.         return -2;
  1062.     }
  1063.   
  1064.     {
  1065.         UINT8 *p;
  1066.         int len,trk;
  1067.     
  1068.         len=(pwb[0]<<8) + pwb[1] - 2;  
  1069.         if( (len<=0)||(len>2048) )
  1070.         {
  1071.             printf("Read toc length errorn");
  1072.             return -2;
  1073.         }
  1074.   
  1075.         printf("toc table length:%dn",len);
  1076.   
  1077.         if(is_user_opened())
  1078.             return -1;
  1079.      
  1080.         cdrom_read_tocentry(1, fmt, (len/2*2)+4);
  1081.   
  1082. #if 0
  1083.     {
  1084.         int j;
  1085.         int iSize;
  1086.         //iSize = 6;
  1087.         iSize = 4;
  1088.         printf("=========================n");
  1089.         printf("%02x%02x%02x%02x, len=%dn", pwb[0], pwb[1], pwb[2], pwb[3], len);
  1090.         for(j=4;j<len;j+=iSize)
  1091.         {
  1092.             for(i=0;i<iSize;i++)
  1093.                 printf("%02x ",pwb[j+i]);
  1094.             printf("n");
  1095.         }
  1096.         printf("=========================n");
  1097.     }  
  1098. #endif
  1101.     // fmt = 2
  1102.     // =======================================
  1103.     // BYTE    0        1    2    3    4    5
  1104.     // servo   Session  ADR  Pnt  Min  Sec  Frm
  1105.     // atapi   0        1    3    8    9    10
  1106.     // =======================================
  1107.     // fmt = 0(for DVD only)
  1108.     // =======================================
  1109.     // BYTE    0        1    2    3
  1110.     // servo   Session  Min  Sec  Frm
  1111.     // atapi   2        4    5    6
  1112.     //
  1113.     SessionNs=0;       
  1114.     //print_block(pwb,1024);
  1115.     for (i=4; i<len; i+=iSize)
  1116.     {
  1117.         p=&pwb[i];
  1119.         if (fmt==2) {
  1120.             cd_trk_cna=(p[1]&0x0f)<<4;
  1121.             cd_trk_cna|=(p[1]&0xf0)>>4;
  1122.        
  1123.             if(p[2]<=0xa2) {
  1124.                 if(p[2]==0xa0) {
  1125.                     trk=0x64;
  1126.                     if(p[0]==1) {
  1127.                         cd_trk_lo_now=cd_trk_lo=p[3];       
  1128.                     }else if(p[0]>1) {
  1129.                         SessionNs=p[3];
  1130.                         printf("lo:%xn",p[3]);
  1131.                     }
  1132.                 } else if(p[2]==0xa1) {
  1133.             cd_trk_hi=p[3];
  1134.             trk=0x65;
  1135.                 } else if(p[2]==0xa2) {
  1136.             trk=0x66;
  1137.                 } else {
  1138.                     trk=p[2];       
  1139.                     if(trk>100) {
  1140.                         printf("~~read toc trk no.(%x) error~~n",trk);
  1141.                         return -2;
  1142.                     }
  1143.                 }
  1144.        
  1145.                 {
  1146.                     UINT32  iMSF;
  1147.             
  1148.                     //check msf validation, Jeff update, 20030819
  1149.                     //pFsJpeg->cdrom.track_info[trk]=((UINT32)(cd_trk_cna)<<24) | ((UINT32)p[3] <<16)| ((UINT32)p[4]<<8) | ((BYTE)(p[5]));
  1150.                     iMSF = ((UINT32)p[3] << 16)| ((UINT32)p[4] << 8) | ((BYTE)(p[5]));
  1151.                     if (iMSF<0x200) iMSF = 0x200;
  1152.                     pFsJpeg->cdrom.track_info[trk]=((UINT32)(cd_trk_cna)<<24) | iMSF;
  1154.                 printf("trk:%d msf:%08xn",trk,pFsJpeg->cdrom.track_info[trk]);
  1155.                 }
  1156.             } //if(p[2]<=0xa2) {
  1157.         } else { //fmt=0(for DVD only)
  1158.             trk = p[0];
  1159.             pFsJpeg->cdrom.track_info[trk] = ((UINT32)( (0x41000000) | (p[1]<<16) | (p[2]<<8) | p[3]) );
  1160.             cd_trk_hi = trk;
  1161.             SessionNs = trk;
  1162.         }
  1164. #ifdef MODIFY_MULTI_SESSION_CD_DISC//NONO for tonic GERMANY CD(totle trk 13->12).20040208
  1165. if( ((gettrkcna(1) & 0x0040/*CNA_MASK_TYPE*/) != 0x40/*CNA_DATA*/)/*&&(cd_trk_hi<= p[3])*/&&(p[0]>1) )
  1166. break;
  1167. #endif//MODIFY_MULTI_SESSION_CD_DISC
  1169.     } //for (i=4; i<len; i+=6)
  1171.     pFsJpeg->cdrom.track_info[0]=pFsJpeg->cdrom.track_info[1];
  1172.      
  1173.     {
  1174.         UINT32 max,min;
  1175.        
  1176.         for(trk=cd_trk_lo_now;trk<cd_trk_hi;trk++)
  1177.         {
  1178.             max=pFsJpeg->cdrom.track_info[trk+1]&0xffffff;
  1179.             min=pFsJpeg->cdrom.track_info[trk]&0xffffff;
  1180.             if( (min>max)||(min==0xffffff) )
  1181.             {
  1182.                 cd_trk_hi=trk-1;
  1183.                 printf("Read toc length error,max:%x min:%xn",max,min);
  1184.                 break;
  1185.             }
  1186.         }
  1187.      
  1188.         if(cd_trk_hi<cd_trk_lo_now)
  1189.         {
  1190.             printf("Read toc length error,hi:%x low:%xn",cd_trk_hi,cd_trk_lo_now);
  1191.             return -2;
  1192.         }
  1193.     }
  1195.     printf("read finishn" );
  1196.     return 0;
  1198.     }
  1199. }
  1201. //=============ycwen 2004/08/10================
  1202. #if defined(DVD_SERVO_REAL_TURN_OFF)//nono rename 4-12-30 11:19//def NO_DVD_SERVO
  1203. void servo_turn_off(void)
  1204. {
  1205.     //Decoder gated clock
  1206.     WriteServoReg(0x4333,0x07);
  1207.     WriteServoReg(0x4334,0xff);
  1208.     WriteServoReg(0x4335,0xff);
  1209.     WriteServoReg(0x4336,0xff);
  1210.     WriteServoReg(0x4337,0xff);
  1211.     //Servo AFE power down
  1212.     WriteServoReg(0x4403,0x04);
  1213.     WriteServoReg(0x440e,0x02);
  1214.     WriteServoReg(0x4435,0x00);
  1215.     WriteServoReg(0x453c,0x20);
  1216.     //servo DSP gated clock
  1217.     WriteServoReg(0x4410,0x03);
  1218.     WriteServoReg(0x4416,0x01);
  1219. }
  1220. #endif //DVD_SERVO_REAL_TURN_OFF
  1222. #ifdef MP4_SPEED_UP_SRV
  1224. /************************************************/
  1225. /* Change CD speed for some MP4 files that      */
  1226. /* need high transfer bit-rate.                 */
  1227. /* axel 20041018                                */
  1228. /************************************************/
  1230. void atapi_p_change_speed(UINT8 speed)
  1231. {
  1232.     UINT8 pc[12];
  1234. pc[0] = 0xf0;
  1235. pc[1] = 0xbb;
  1236. pc[2] = speed;
  1239. atapi_do_packet(pc);
  1240.     
  1241. }
  1243. #endif //MP4_SPEED_UP_SRV