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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
8202_usb_card_if.c
资源名称：8202s_8281s_050405_dvd_622.rar　[点击查看]
上传用户：caisangzi8
上传日期：2013-10-25
资源大小：15756k
文件大小：46k
源码类别：

DVD

开发平台：

C/C++

8202_usb_card_if.c：源码内容
  1. /**************************************************************************
  2.  *                                                                        *
  3.  *         Copyright (c) 2002 by Sunplus Technology Co., Ltd.             *
  4.  *                                                                        *
  5.  *  This software is copyrighted by and is the property of Sunplus        *
  6.  *  Technology Co., Ltd. All rights are reserved by Sunplus Technology    *
  7.  *  Co., Ltd. This software may only be used in accordance with the       *
  8.  *  corresponding license agreement. Any unauthorized use, duplication,   *
  9.  *  distribution, or disclosure of this software is expressly forbidden.  *
  10.  *                                                                        *
  11.  *  This Copyright notice MUST not be removed or modified without prior   *
  12.  *  written consent of Sunplus Technology Co., Ltd.                       *
  13.  *                                                                        *
  14.  *  Sunplus Technology Co., Ltd. reserves the right to modify this        *
  15.  *  software without notice.                                              *
  16.  *                                                                        *
  17.  *  Sunplus Technology Co., Ltd.                                          *
  18.  *  19, Innovation First Road, Science-Based Industrial Park,             *
  19.  *  Hsin-Chu, Taiwan, R.O.C.                                              *
  20.  **************************************************************************/
  21. /*--------------------------------------------------------------------------
  22. |  File Name   :  8202_usb_card_if.c
  23. |
  24. |  Description :  8202 Usb and Card Interface
  25. |
  26. |  Version    :  0.1  
  27. | 
  28. | 
  29. |  Rev Date         Author(s)      Status & Comments
  30. |---------------------------------------------------------------------------------
  31. |  0.1 2004/9/18         wthsin         Creating
  32. |--------------------------------------------------------------------------------*/ 
  33. #include "user_init.h"
  34. #include "global.h"
  35. #include "emuio.h"
  36. #include "gpio.h"
  37. #include "func.h"
  38. #include "cpu.h"//wanghaoying 20030812
  39. #include "macro.h"
  40. #include "memmap.h"
  41. #include "memmap0.h"
  42. #include "fsNav.h"//liweihua 2004-3-30 14:34
  43. #include "cderr.h"
  44. #include "cardfs.h"
  45. #include "osd.h"
  46. #include "scsi.h"
  47. #include "usb.h"
  48. #ifdef HOST_UHCI 
  49.  #include "uhci.h"
  50. #else
  51.  #include "host_811.h"
  52. #endif  
  53. #if defined(SPHE8202_CARD_STORAGE)
  54.  #include "card_main.h"
  55.  #include "sd.h"
  56.  #include "cf.h"
  57.  #include "ms.h"
  58. #endif
  60. #ifdef SUPPORT_MIDI         ///xlluo add 04-1-21
  61. #include "fsmidi.h"
  62. #include "fsMidiUI.h"
  63. #endif
  66. #ifdef SPHE8202_ALL_TYPE_CARD_WRITE
  67. extern BYTE card_browse_sign;//dingzhy 4-11-18 9:40
  68. #endif
  70. #ifdef FILE_MODE_WRITE                  //sunzhh add for file mode 2005-1-14
  71. extern BYTE file_mode_flag;                   
  72. #endif    
  74. #if defined(SUPPORT_USB)||defined(SPHE8202_CARD_STORAGE) 
  75.     extern UINT8 MediaIsEmpty;
  76.     extern void show_card_reading_osd(BYTE type);
  77.     extern void ircmd_stop(void);
  78.     extern void SwitchMedia(BYTE direction);
  79. #endif
  81. #if defined(SUPPORT_USB)||defined(SPHE8202_CARD_STORAGE) 
  82.  //0x01: USB ,0x02: CF ,0x04: SD_MMC ,0x08: MS ,0x10: SMC  
  83.  const UINT8 storage_parity_type[]=  { 0x00, 0x01, 0x02, 0x01, 0x04, 0x01, 0x02, 0x01,
  84.                                        0x08, 0x01, 0x02, 0x01, 0x04, 0x01, 0x02, 0x01,
  85.                                        0x10, 0x01, 0x02, 0x01, 0x04, 0x01, 0x02, 0x01,
  86.                                        0x08, 0x01, 0x02, 0x01, 0x04, 0x01, 0x02, 0x01,};
  87. #endif
  89. #ifndef DVDRELEASE
  90.  #define USB_CARD_IF_DBG       1
  91. #endif
  93. #define D printf("INFO: __%d__(%s:%s)n",__LINE__,__FILE__,__FUNCTION__);
  95. #ifndef USB_CARD_IF_DBG
  96.  #undef printf
  97.  #undef print_block
  98.  #define printf(f, a...) do {} while (0)
  99.  #define print_block(x,y) do {} while (0)
  100. #endif
  102. #if defined(SUPPORT_USB)||defined(SPHE8202_CARD_STORAGE) 
  103. #ifdef SPHE8202_CARD_STORAGE  
  104. UINT8   CardEna=0;  
  106. #ifdef IR_SWITCH_CD_USB_CF_OTHER  //dingzhy for bus switch 04-10-22
  107. EXTERN  BYTE detect_result_last;
  108. EXTERN  BYTE now_valid_type;
  109. #endif
  111. #ifdef CARD_SETUP_TYPE_5
  112.  UINT8 PMP_CF_Card_Insert=0;
  113.  UINT8 PMP_CF_Card_Play=0;
  114.  #ifdef SUPPORT_MULTI_PARTITION
  115.   extern void Refresh_Partition_Menu(void);
  116.   #ifdef FAT_FILE_MODE
  117.   extern UINT16 fat_play_mode;
  118.   extern void Refresh_FAT_Mode_GUI(void); 
  119.   #endif//#ifdef FAT_FILE_MODE
  120.  #endif//#ifdef SUPPORT_MULTI_PARTITION
  121. #endif //#ifdef CARD_SETUP_TYPE_5
  122. /**************************************************************************
  123.  *                                                                        *
  124.  *  Function Name: Card_power_reset                                       *
  125.  *                                                                        *
  126.  *  Purposes:                                                             *
  127.  *    USE GPIO to reset card power                                        *
  128.  *  Descriptions:                                                         *
  129.  *    USE GPIO to reset card power                                        *
  130.  *  Arguments:                                                            *
  131.  *          NONE                                                          *
  132.  *  Returns:     NONE                                                     *
  133.  *                                                                        *
  134.  *  See also:    NONE                                                     *
  135.  *                                                                        *
  136.  **************************************************************************/
  137. void Card_power_reset()
  138. {
  139.     GPIO_O_SET(CARD_POWER_RESET,1);  //Power Off
  140.     delay_srv_10ms(30);  
  141.     GPIO_O_SET(CARD_POWER_RESET,0);  //Power On
  142.    #if defined(CARD_SETUP_TYPE_1)||defined(CARD_SETUP_TYPE_2)  
  143.     regs0->fm_gpio_len  = 12                    // Set FMGPIO_B[41:0] turn on
  144.                         |  (0xf << 4);          // Set FMGPIO_B[41:0] enable   
  145.    #elif defined(CARD_SETUP_TYPE_3)||defined(CARD_SETUP_TYPE_5)        
  146.     regs0->fm_gpio_len  = 11                    // Set FMGPIO_B[26:0] turn on
  147.                         |  (0xf << 4);          // Set FMGPIO_B[26:0] enable  
  148.    #elif defined(CARD_SETUP_TYPE_4)      
  149.      regs0->fm_gpio_len  = 3                    // Set FMGPIO_B[5:0] turn on
  150.                         |  (0x1 << 4);          // Set FMGPIO_B[5:0] enable                     
  151.    #endif                                        
  152.     delay_srv_10ms(30); 
  153. }    
  154. /**************************************************************************
  155.  *                                                                        *
  156.  *  Function Name: Card_power_off                                         *
  157.  *                                                                        *
  158.  *  Purposes:                                                             *
  159.  *    turn off card power, let card invalid                               *
  160.  *  Descriptions:                                                         *
  161.  *    turn off card power, let card invalid                               *
  162.  *  Arguments:                                                            *
  163.  *          NONE                                                          *
  164.  *  Returns:     NONE                                                     *
  165.  *                                                                        *
  166.  *  See also:    NONE                                                     *
  167.  *                                                                        *
  168.  **************************************************************************/
  169. void Card_power_off()
  170. {
  171.     GPIO_O_SET(CARD_POWER_RESET,1);  //Power Off
  172.     regs0->fm_gpio_len  = 0; 
  173. }    
  174. /**************************************************************************
  175.  *                                                                        *
  176.  *  Function Name: Card_gpio_init                                         *
  177.  *                                                                        *
  178.  *  Purposes:                                                             *
  179.  *    initialize card GPIO, Set card GPIO valid                           *
  180.  *  Descriptions:                                                         *
  181.  *    initialize card GPIO, Set card GPIO valid                           *
  182.  *  Arguments:                                                            *
  183.  *          NONE                                                          *
  184.  *  Returns:     NONE                                                     *
  185.  *                                                                        *
  186.  *  See also:    NONE                                                     *
  187.  *                                                                        *
  188.  **************************************************************************/
  189. void Card_gpio_init()
  190. {
  191.   #ifdef CARD_SETUP_TYPE_1
  192. regs0->sft_cfg3 &= ~(0x1 << 5);  //set GPIO 50 ca8202 pin193
  193. regs0->sft_cfg1 &= ~(0x1 << 2);  //set GPIO 17 ca8202 pin77
  194. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  195. GPIO_M_SET(CARD_POWER_RESET,1);
  196.   #elif defined(CARD_SETUP_TYPE_2)
  197. regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 pin76
  198. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  199. GPIO_M_SET(CARD_POWER_RESET,1);
  200.   #elif defined(CARD_SETUP_TYPE_3)
  201.     regs0->sft_cfg3 &= ~(0x1 << 5);  //set AUD4 disable, wthsin 2004/6/14 04:23pm
  202.     regs0->sft_cfg0 &= ~(0x1 << 7);  //set CS1  disable
  203.     regs0->sft_cfg1 &= ~(0x1 << 5);  //set A12  disable
  205.      #ifdef PORTABLE_DVD
  206.      regs0->sft_cfg0 &= ~(0x1 << 5);  //set GPIO 38 ca8202 pin161
  207.      #elif defined(IDE_CF_SW)
  208.      regs0->sft_cfg0 &= ~(0x1 << 5);     //set GPIO 38 ca8202 pin161
  209.      #elif defined(COSMIC_CARD_READER) //FanGang added 2005-1-10 17:32
  210.      regs0->sft_cfg0 &= ~(0x1 << 4);     //set GPIO 39 ca8202 pin162
  211.      #else
  212.     regs0->sft_cfg0 &= ~(0x1 << 6);  //set GPIO 29 ca8202 pin145
  213.      #endif
  214. regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 pin76
  215. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  216. GPIO_M_SET(CARD_POWER_RESET,1);
  217. #ifdef HDMI_SMC_CLE
  218.   GPIO_M_SET(CARD_SMC_CLE_PIN, 1); // benson 2004/11/17 01:40PM  set gpio 36
  219.   GPIO_E_SET(CARD_SMC_CLE_PIN, 1); // benson 2004/11/17 01:40PM  set gpio 36
  220. #endif
  221.   #elif defined(CARD_SETUP_TYPE_4)
  222. #if defined(MP_BOARD_256_PIN_NON_SHARE)//kenny 2004/7/14
  223. regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 pin76
  224. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  225. GPIO_M_SET(CARD_POWER_RESET,1);
  226. #elif defined(MP_BOARD_216_PIN_NON_SHARE)
  227. regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 ns-216 pin66
  228. #ifdef USE_SERVO_DFCT_GPIO //if define USE_SERVO_DFCT_GPIO, then we  set pin55 to be GPIO
  229. regs0->sft_cfg4 &= ~(0x1 << 6);  //set GPIO 8 ca8202 ns-216 pin55 (servo DFCT pin)
  231. #endif
  232. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  233. GPIO_M_SET(CARD_POWER_RESET,1);
  234. #else
  235. regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 pin76
  236. GPIO_M_SET(CARD_SENSE1_PIN, 1);
  237. GPIO_M_SET(CARD_POWER_RESET,1);
  238. #endif
  239.   #elif defined(CARD_SETUP_TYPE_5)
  240.     regs0->sft_cfg0 &= ~(0x1 << 7);  //set CS1  disable
  241.     regs0->sft_cfg1 &= ~(0x1 << 5);  //set A12  disable
  242.    #ifdef PMP_PCB_VER_B 
  243.     regs0->sft_cfg1 &= ~(0x1 << 3);  //set GPIO 16 ca8202 pin76
  244.     #else  //PMP_PCB_VER_C
  245.      regs0->sft_cfg0 &= ~(0x1 << 4);     //set GPIO 39 ca8202 pin162
  246.     #endif 
  247.     regs0->sft_cfg1 &= ~(0x1 << 1);  //set GPIO 18 ca8202 pin78  
  248.     GPIO_M_SET(CF_INS_SENSE, 1);
  249. GPIO_M_SET(CARD_POWER_RESET,1);
  250. GPIO_E_SET(CF_INS_SENSE, 0);
  251.   #endif
  252.   #ifndef CARD_SETUP_TYPE_5
  253. GPIO_E_SET(CARD_SENSE1_PIN, 0);
  254. GPIO_E_SET(CARD_SENSE2_PIN, 0);
  255.   #endif
  256.   #if !defined(CARD_SETUP_TYPE_4)&&!defined(CARD_SETUP_TYPE_5)
  257. GPIO_E_SET(CARD_SENSE3_PIN, 0);
  258.   #endif
  259. GPIO_E_SET(CARD_POWER_RESET,1);
  260. CardEna=TRUE;
  262. GPIO_O_SET(CARD_POWER_RESET,1);  //Power Off
  264. }
  265. /**************************************************************************
  266.  *                                                                        *
  267.  *  Function Name: CardStorageIsPlugIn                                    *
  268.  *                                                                        *
  269.  *  Purposes:                                                             *
  270.  *    Check card  Storage plug in or not                                  *
  271.  *  Descriptions:                                                         *
  272.  *    Check card  Storage plug in or not                                  *
  273.  *  Arguments:                                                            *
  274.  *          NONE                                                          *
  275.  *  Returns:                                                              *
  276.  *          0: FALSE                                                               *
  277.  *          1: TRUE                                                             *
  278.  *                                                                        *
  279.  *  See also:    NONE                                                     *
  280.  *                                                                        *
  281.  **************************************************************************/
  282. int CardStorageIsPlugIn(void)
  283. {
  284.     UINT8 card_result=0;
  285.     switch(storage_type)
  286.     {
  287.      #if defined(COMPACT_FLASH)    
  288.          case CF_CARD_DEVICE:
  289.                         #if defined(CARD_SETUP_TYPE_5)
  290.                          if((PMP_CF_Card_Play==1)&&(PMP_CF_Card_Insert==0))
  291.                               ircmd_return();   //card_result=1;
  292.                          else     
  293.                               card_result=0;
  294.                         #else 
  295.                          if(GPIO_I_GET(CARD_SENSE2_PIN))  card_result=1;
  296.                         #endif  
  297.                          break; 
  298.         #endif     
  299.         #if defined(SD_MMC_CARD)    
  300.          case SD_CARD_DEVICE:
  301.                         #ifdef CARD_SETUP_TYPE_4
  302.                          if(GPIO_I_GET(CARD_SENSE1_PIN))  card_result=1;
  303.                         #else  
  304.                          if(GPIO_I_GET(CARD_SENSE3_PIN))  card_result=1;
  305.                         #endif 
  306.                          break; 
  307.         #endif  
  308.         #if defined(MEMORY_STICK)    
  309.          case MS_CARD_DEVICE:
  310.                         #ifdef CARD_SETUP_TYPE_4
  311.                          if(GPIO_I_GET(CARD_SENSE2_PIN))  card_result=1;
  312.                         #else 
  313.                          if(GPIO_I_GET(CARD_SENSE1_PIN))  card_result=1;
  314.                         #endif 
  315.                          break; 
  316.         #endif  
  317.         #if defined(SMART_MEDIA)    
  318.          case SMC_CARD_DEVICE:
  319.                          if(GPIO_I_GET(CARD_SENSE1_PIN))  card_result=1;
  320.                          break; 
  321.         #endif  
  322.          default:
  323.          break;
  324.     }     
  325.     
  326. if(card_result)  return FALSE;
  327. else             return TRUE;
  328. }
  329. /**************************************************************************
  330.  *                                                                        *
  331.  *  Function Name: Detect_Card_Storage                                    *
  332.  *                                                                        *
  333.  *  Purposes:                                                             *
  334.  *    Detect which card exist                                             *
  335.  *  Descriptions:                                                         *
  336.  *    Use card GPIO to Detect which card exist                            *
  337.  *  Arguments:                                                            *
  338.  *          NONE                                                          *
  339.  *  Returns:                                                              *
  340.  *          0x02: CF ,0x04: SD_MMC ,0x08: MS ,0x10: SMC                   *
  341.  *          0x06: SD+CF ,0x0a: CF+MS ,0x12: CF+SMC                        *
  342.  *                                                                        *
  343.  *  See also:    NONE                                                     *
  344.  *                                                                        *
  345.  **************************************************************************/
  346. BYTE Detect_Card_Storage()
  347. {
  348.  UINT8 card_sense=0;
  349.  BYTE  card_storage_type=0;
  350.     detect_type &= USB_DEVICE;//liweihua 2004-6-7 
  351.    #ifdef CARD_SETUP_TYPE_4
  352.      card_sense=GPIO_I_GET(CARD_SENSE1_PIN)<<1;
  353.  card_sense|=GPIO_I_GET(CARD_SENSE2_PIN);  
  354.    
  355.      //printf("card_sense =%x!n",card_sense);
  356.      switch(card_sense)
  357.  {
  358.   case 2:
  359.          card_storage_type|=MS_CARD_DEVICE; 
  360.          break; 
  361.   case 1:
  362.          card_storage_type|=SD_CARD_DEVICE;           
  363.          break; 
  364.   default: 
  365.          card_storage_type=0;
  366.          break; 
  367.  }   
  368.    #elif defined(CARD_SETUP_TYPE_5)  
  369.         card_storage_type|=CF_CARD_DEVICE; 
  370.         //liweihua mod 2004-12-1
  371.         int check_result=PMP_CF_Card_IsPlugIn();
  372.         #ifdef SUPPORT_MULTI_PARTITION//liweihua 2004-12-10
  373.         if((check_result>1) || (check_result<0)) 
  374.         {
  375.             #if defined(FAT_FILE_MODE) && (!defined(PMP_UI))//liweihua 2005-1-5
  376.             if(fat_play_mode == 1)
  377.                 Refresh_FAT_Mode_GUI();
  378.             else if((fat_play_mode == 2)&&(pFsJpeg->gifsState == FS_STATE_HDD))
  379.             #else
  380.             if(pFsJpeg->gifsState == FS_STATE_HDD)
  381.             #endif
  382.                 Refresh_Partition_Menu();
  383.         }
  384.         else
  385.         #endif
  386.         if(check_result==1) 
  387.          PMP_CF_Card_Insert=1;
  388.         else
  389.          PMP_CF_Card_Insert=0;
  390.    #else  //CARD_SETUP_TYPE_1 ,CARD_SETUP_TYPE_2,CARD_SETUP_TYPE_3
  391.  card_sense=GPIO_I_GET(CARD_SENSE1_PIN)<<2;
  392.  card_sense|=GPIO_I_GET(CARD_SENSE2_PIN)<<1;
  393.  card_sense|=GPIO_I_GET(CARD_SENSE3_PIN);
  394.  //printf("card_sense =%x!n",card_sense);
  395.  switch(card_sense)
  396.  {
  397.   case 7:
  398.          card_storage_type=0;
  399.          break;  
  400.   case 6:
  401.              card_storage_type|=SD_CARD_DEVICE; 
  402.          break; 
  403.   case 5:
  404.          card_storage_type|=CF_CARD_DEVICE; 
  405.          break; 
  406.   case 4:
  407.          card_storage_type|=CF_CARD_DEVICE; 
  408.          card_storage_type|=SD_CARD_DEVICE; 
  409.          break; 
  410.   case 3:
  411.          card_storage_type|=MS_CARD_DEVICE; 
  412.          break; 
  413.   case 2:
  414.          card_storage_type|=SMC_CARD_DEVICE;
  415.          break; 
  416.   case 1:
  417.          card_storage_type|=CF_CARD_DEVICE; 
  418.          card_storage_type|=MS_CARD_DEVICE; 
  419.          break; 
  420.   case 0:
  421.          card_storage_type|=CF_CARD_DEVICE; 
  422.          card_storage_type|=SMC_CARD_DEVICE;
  423.          break; 
  424.   default: 
  425.          card_storage_type=0;
  426.          break; 
  427.  }   
  428.    #endif  
  429.      detect_type |=card_storage_type;//liweihua 2004-6-7
  430.      return card_storage_type;
  431. }
  432. #endif //#ifdef SPHE8202_CARD_STORAGE  
  433. //-----------------------------------------------------------
  434. #ifdef SUPPORT_USB
  435. extern UINT8 UsbTestUnitReady(BYTE dev_lun);
  436. extern BYTE IsUSBCardReader(void);
  437. extern UINT8 USBEna;  
  438. extern UINT8 CBWLUN;
  439. extern UINT8 SLAVE_ENUMERATED;
  440. extern UINT8 USB_ADDR; 
  441. extern UINT8 MaxLUN;
  442. extern void USBCardReaderDetect(void);
  443. /**************************************************************************
  444.  *                                                                        *
  445.  *  Function Name: UsbIsPlugIn                                            *
  446.  *                                                                        *
  447.  *  Purposes:                                                             *
  448.  *    Detect if the U disk is pluged                                      *
  449.  *  Descriptions:                                                         *
  450.  *    use UHCI command Detect if the U disk is pluged                                      *
  451.  *  Arguments:                                                            *
  452.  *          NONE                                                          *
  453.  *  Returns:                                                              *
  454.  *          TRUE or FALSE                                                 *
  455.  *                                                                        *
  456.  *  See also:    NONE                                                     *
  457.  *                                                                        *
  458.  **************************************************************************/
  459. int UsbIsPlugIn(void)
  460. {
  461.     int detect_result = 0;
  462.   #ifdef HOST_UHCI   
  463.     detect_result = uhci_slaveDetect();
  464.   #else //#define HOST_SL811HS   
  465.     detect_result = slave_detect();
  466.   #endif    
  467.     if((detect_result == 0) && (card_plug_state ==  USER_DO_PLUG_IN))
  468.         return TRUE;
  469.     else if((detect_result == 0) && (card_plug_state == USER_DO_PLUG_OUT))
  470.         return FALSE;
  471.     else
  472.         return FALSE;
  473. }
  474. /**************************************************************************
  475.  *    *
  476.  *  Function Name: uhci_slaveDetect                                       *
  477.  *   *
  478.  *  Purposes:                                                             *
  479.  *    detect whether the U-Device is plugged in or not                    *
  480.  *  Descriptions:                                                         *
  481.  *    This function detect whether the U-Device is plugged in or not.     *
  482.  *  Arguments:                                                            *
  483.  *          NONE                                                          *
  484.  *  Returns:                                                              *
  485.  *          0: nothing  1: plug in  2: detached                           *
  486.  *  See also:    NONE                                                     *
  487.  *   *
  488.  **************************************************************************/
  489. /**************************************************************************************************
  490.  *    *
  491.  * Description: This function detect whether the U-Device is plugged in or not.   *
  492.  *   *
  493.  * Author     : wthsin   *
  494.  * Date       : 2004/1/14 08:31pm   *
  495.  *   *
  496.  * Update     : liweihua 2004-6-7
  497.  **************************************************************************************************/
  498. BYTE usb_plug_out_flag; //for USB plug out when copying lijd 2004-11-19 16:15
  499. UINT32 uhci_slaveDetect(void)
  500. {
  501. int  result;
  503. //-------------------------------------------------------------------------
  504. // Wait for USB enumeration
  505. //-------------------------------------------------------------------------
  506. if(!SLAVE_ENUMERATED)
  507. {  // wait for an USB device to be inserted  
  508.     if(uhci_PlugInOutDetect())
  509.     {  
  510.              printf("slave is plug in!!!n");
  511.              usb_plug_out_flag=0;
  512.              uhci_reset(); //wthsin   2003/12/30 04:43
  513.              USB_ADDR=uDisk_ADDR;
  514.              result=EnumUsbDev(USB_ADDR);
  515.       if(no_disk_cnt == 1)//liweihua 20040324
  516.                  system_state=SYSTEM_OPEN;   //wthsin,    2004/3/16 07:36pm    
  517.      if(result)
  518.      {         // enumerate USB device, assign USB address = #1
  519.                 SLAVE_ENUMERATED = TRUE; // Set slave USB device enumerated flag
  520.                 #ifdef SUPPORT_SLOT_IN_LOADER
  521.                 card_plug_state = USER_DO_PLUG_IN;
  522.                 #else
  523.                 if(play_state != VCD_STATE_OPEN)//liweihua add 2004-3-11
  524.                 card_plug_state = USER_DO_PLUG_IN;
  525.                 else
  526.                     card_plug_state = 0;
  527.                 #endif    
  528.             detect_type |= USB_DEVICE;   //wthsin ,2004/3/1 03:16pm
  529.             MaxLUN = 0;     //Maoyong 2004.05.19
  530.         return 1;
  531.      }
  532.     }
  533. }
  534. //-------------------------------------------------------------------------
  535. // USB enumerated, proceed accordingly
  536. //-------------------------------------------------------------------------
  537. else
  538. {
  539.    if(!uhci_PlugInOutDetect())          // test for slave device detach  
  540.    {
  541.             printf("slave is detached!!!n");
  542.             usb_plug_out_flag=1;
  543.      #ifdef MP3_ONLY_STOP_TO_GUI 
  544.             if( (play_state==VCD_STATE_MP3_FILELIST) && (media_type==MEDIA_CARD) )
  545.             {
  546.          ShowTitle();
  547.          SwitchMedia(CARD2CD);      //wsf 2004-9-16 16:43
  548.       }
  549.  #endif 
  550.  
  551.             SLAVE_ENUMERATED = FALSE; // return to un-enumeration
  552.         if((media_type == MEDIA_CARD)&&(storage_type == USB_DEVICE)) //liweihua mod 2004-3-30
  553.             {
  554.              if(Mp3ReadFinish)
  555.              Mp3ReadFinish = 0;
  556.              if((play_state == VCD_STATE_PAUSE)||(GetCurrentFileType() == CDROM_WMA))//liweihua mod 2004-4-19
  557.              ircmd_stop();         
  558.             AVD_SetMediaInterrupt();        //wthsin ,  2004/4/19 02:47pm         
  559.             }
  560.             if(play_state != VCD_STATE_OPEN) //liweihua add 2004-2-1
  561.             {
  562.             if((media_type == MEDIA_CARD)&&(storage_type == USB_DEVICE))
  563.                 play_state = VCD_STATE_STOP;
  564.              
  565.             card_plug_state = USER_DO_PLUG_OUT;
  566.          }
  567.         detect_type &= (~USB_DEVICE);
  568.         storage_type &= (~USB_DEVICE);
  569.     return 2; // exit now.
  570.    }
  571. }   
  572. //-------------------------------------------------------------------------
  573. //USB Card reader special process
  574. //-------------------------------------------------------------------------
  575. USBCardReaderDetect();
  576.        
  577. return 0;
  578. }     
  579. #endif//end SUPPORT_USB
  580. /**************************************************************************
  581.  *                                                                        *
  582.  *  Function Name: CardTestReady                                          *
  583.  *                                                                        *
  584.  *  Purposes:                                                             *
  585.  *    detect and initialize card/usb, then set card to browse             *
  586.  *  Descriptions:                                                         *
  587.  *    detect and initialize card/usb, then set card to browse             *
  588.  *  Arguments:                                                            *
  589.  *          NONE                                                          *
  590.  *  Returns:     NONE                                                     *
  591.  *                                                                        *
  592.  *  See also:    NONE                                                     *
  593.  *                                                                        *
  594.  **************************************************************************/
  595. void CardTestReady(void)
  596. {
  597. UINT8 media_exit=0;
  599. #ifdef  IR_SWITCH_CD_USB_CF_OTHER
  600. storage_type = detect_result_last;        
  601.         now_valid_type = storage_type; //for bug:read cf,insert usb,will read cf again.
  602.         #ifdef HIGH_CORTROL_CF
  603.         GPIO_O_SET(SWITCH_GPIO,0);//dingzhy for switch bus 4-10-22 10:43
  604.         #else
  605.         GPIO_O_SET(SWITCH_GPIO,1);
  606.         #endif
  607. #endif
  609.     if(storage_type!=0)
  610.     {
  611.         #ifdef SPHE8202_CARD_STORAGE    //Maoyong 2004-8-12 do card power reset.
  612.         if(storage_type != USB_DEVICE)
  613.             Card_power_reset();
  614.         #endif
  615.     switch(storage_type)
  616.     {         
  617.             #ifdef SPHE8202_CARD_STORAGE         
  618.         #if defined(COMPACT_FLASH)    
  619.          case CF_CARD_DEVICE:
  620.           #ifdef IR_SWITCH_CD_USB_CF_OTHER  //dingzhy 4-10-22 10:41
  621.           #ifdef HIGH_CORTROL_CF
  622.          GPIO_O_SET(SWITCH_GPIO,1);//dingzhy use vfd data for test switch bus 4-10-22 10:43
  623.          #else
  624.          GPIO_O_SET(SWITCH_GPIO,0);
  625.          #endif
  626.           #endif         
  627.                          #ifdef CARD_SETUP_TYPE_2
  628.                            regs0->fm_gpio_mode = 8;  
  629.                          #elif defined(CARD_SETUP_TYPE_3)||defined(CARD_SETUP_TYPE_5)
  630.                            regs0->gpio_mode_B=2;
  631.                            regs0->fm_gpio_mode = 3;
  632.                          #endif  
  633.                          
  634.                    #ifdef IDE_CF_SW 
  635.                    IdeSetSequence(HD);//kenny 2004/8/29
  636.                    #endif
  637.                       cfIdeDetect();
  638.                          media_exit=1;
  639.                          break; 
  640.         #endif     
  641.         #if defined(SD_MMC_CARD)    
  642.          case SD_CARD_DEVICE:
  643.                         #ifdef CARD_SETUP_TYPE_2
  644.                           regs0->fm_gpio_mode = 3;  
  645.                         #elif defined(CARD_SETUP_TYPE_3)||defined(CARD_SETUP_TYPE_4)
  646.                           regs0->gpio_mode_B=0;
  647.                           regs0->fm_gpio_mode = 3;                      
  648.                         #endif //CARD_SETUP_TYPE_2
  649.                      if(sdDetect())    //wthsin, 2004/6/24 07:40pm
  650.                      {
  651.                         psprintf(RegionValStr[REGION1], "SD Err");
  652.                            PrintOsdMsg(STR_OS_SPACE, REGION1, 0, 1);  
  653.                      }
  654.                      else    
  655.                        media_exit=1;    
  656.                         break; 
  657.         #endif  
  658.         #if defined(MEMORY_STICK)    
  659.          case MS_CARD_DEVICE:
  660.                         #ifdef CARD_SETUP_TYPE_2
  661.                           regs0->fm_gpio_mode = 4;  
  662.                         #elif defined(CARD_SETUP_TYPE_3)||defined(CARD_SETUP_TYPE_4)
  663.                           regs0->gpio_mode_B=0;
  664.                           regs0->fm_gpio_mode = 4;   
  665.                         #endif //CARD_SETUP_TYPE_2
  666.                      msDetect();
  667.                      media_exit=1;    
  668.                         break; 
  669.         #endif  
  670.         #if defined(SMART_MEDIA)    
  671.          case SMC_CARD_DEVICE:
  672.                         #ifdef CARD_SETUP_TYPE_2
  673.                           regs0->fm_gpio_mode = 8;  
  674.                         #elif defined(CARD_SETUP_TYPE_3)
  675.                           regs0->fm_gpio_mode = 3;  
  676.                           regs0->gpio_mode_B=1;
  677.                         #endif //CARD_SETUP_TYPE_2
  678.                         if(smcDetect())
  679.                         {
  680.                         psprintf(RegionValStr[REGION1], "SMC Err");
  681.                            PrintOsdMsg(STR_OS_SPACE, REGION1, 0, 1);  
  682.                      }
  683.                      else 
  684.                        media_exit=1;              
  685.                         break; 
  686.         #endif  
  687.             #endif//#ifdef SPHE8202_CARD_STORAGE
  688.             #ifdef SUPPORT_USB//liweihua 2004-6-7
  689.             case  USB_DEVICE:
  690.              #if defined(IR_SWITCH_CD_USB_CF_OTHER)||defined(SPHE8202_USB_Write)||defined(FILE_MODE_WRITE) //dingzhy add it
  691.                 UsbTestReady();    //for bug:power on without usb,then insert usb,but can't play usb; dingzhy 04-10-22
  692.                 #endif
  694.                 media_exit=1;
  695.                 break;
  696.             #endif//#ifdef SUPPORT_USB
  697.          default:
  698.                          return;
  699. } 
  700. } 
  701.     //#endif 
  702.     if(media_exit)   
  703.     { 
  704.      #ifdef SPHE8202_ALL_TYPE_CARD_WRITE
  705.      if(card_browse_sign)
  706.      #endif
  707.         #ifdef FILE_MODE_WRITE                  //sunzhh add for file mode 2005-1-14
  708.         if(!file_mode_flag)                   
  709.         #endif        
  710.         CardSetBrowse();
  711.     }
  712. }
  713. /**************************************************************************
  714.  *                                                                        *
  715.  *  Function Name: CARDIsPlugIn                                           *
  716.  *                                                                        *
  717.  *  Purposes:                                                             *
  718.  *    Detect if the USB or CARD is pluged                                        *
  719.  *  Descriptions:                                                         *
  720.  *    Detect if the USB or CARD is pluged                                        *
  721.  *  Arguments:                                                            *
  722.  *          NONE                                                          *
  723.  *  Returns:                                                              *
  724.  *          0: FALSE                                                               *
  725.  *          1: TRUE                                                             *
  726.  *  See also:    NONE                                                     *
  727.  *                                                                        *
  728.  **************************************************************************/
  729. int CARDIsPlugIn(void)
  730. {//liweihua update 2004-6-8
  731.     int detect_result = 0;  
  732.     if(storage_type!=0)
  733.     {
  734.      #ifdef SUPPORT_USB
  735.         if(storage_type == USB_DEVICE)
  736.       detect_result=UsbIsPlugIn();
  737.      #endif
  738.      #if defined(SUPPORT_USB)&&defined(SPHE8202_CARD_STORAGE)  
  739.         else
  740.      #endif 
  741.      #ifdef SPHE8202_CARD_STORAGE
  742.         detect_result=CardStorageIsPlugIn();  
  743.      #endif       
  744.     }  
  745.    return  detect_result; 
  746. }
  747. /**************************************************************************
  748.  *                                                                        *
  749.  *  Function Name: polling_storage                                        *
  750.  *                                                                        *
  751.  *  Purposes:                                                             *
  752.  *    polling to detect usb/card plus in or plug out                      *
  753.  *  Descriptions:                                                         *
  754.  *    polling to detect usb/card plus in or plug out                      *
  755.  *  Arguments:                                                            *
  756.  *          NONE                                                          *
  757.  *  Returns:     NONE                                                     *
  758.  *                                                                        *
  759.  *  See also:    NONE                                                     *
  760.  *                                                                        *
  761.  **************************************************************************/
  762. extern int check_support_usb(void); //wthsin, 2004/5/27 01:34pm
  763. void polling_storage()
  764. {//liweihua update 2004-6-8         
  765.     BYTE detect_result = 0;
  767.     #ifdef SPHE8202_CARD_STORAGE
  768.     if(CardEna == TRUE)   //only after card init then polling.
  769.         Detect_Card_Storage();
  770.     #endif
  771.   #if defined(SUPPORT_USB)               
  772.      if(USBEna == TRUE)    //only after USB init then polling.
  773.     {
  774.         #ifdef SPHE1000
  775.             #ifdef HOST_UHCI 
  776.             uhci_slaveDetect();
  777.             #else //#define HOST_SL811HS   
  778.             slave_detect();
  779.             #endif
  780.         #else
  781.             #ifdef HOST_UHCI 
  782.             if(check_support_usb()==0)   return;  
  783.             uhci_slaveDetect();
  784.             #else //#define HOST_SL811HS   
  785.             slave_detect();
  786.             #endif
  787.         #endif
  788.     }
  789.   #endif
  790.   
  791.     detect_result=storage_parity_type[detect_type];
  792.         
  793.     #ifdef SWITCH_CD_CARD_USB//liweihua 2004-6-9
  794.     extern BYTE select_media_type;
  795.     if(detect_type&select_media_type)
  796.         detect_result = select_media_type;
  797.     else
  798.         select_media_type = 0;
  799.     #endif
  800.     
  801.     #ifdef IR_SWITCH_CD_USB_CF_OTHER   //dingzhy for bus switch 04-10-22
  802.     if((detect_type)&&(now_valid_type))
  803.     {
  804. detect_result = storage_parity_type[now_valid_type];
  805.     }
  806.     else
  807.      now_valid_type = 0;
  808.     
  809.      detect_result_last = detect_result;
  810.    //dingzhy for debug switch function
  811.      //psprintf(RegionValStr[REGION2], "D %x L %x V %x",detect_type,detect_result_last,now_valid_type);
  812. //PrintOsdMsg(STR_OS_SPACE, REGION2, 1, 1);
  813.     #endif
  814.     
  815.     if((detect_result==0)&&(storage_type==0)) 
  816.     {
  817.         //printf("-------- Do nothing! ------n");
  818.         return;
  819.     }
  820.     else if((detect_result!=0)&&((storage_type)==0))   
  821.     {
  822.         printf("-------- Card/USB Insert! ------n");
  823.         printf("media_type = %d",media_type);
  824.         #ifndef SWITCH_CD_CARD_USB//liweihua 2004-6-9
  825.         if(no_disk_cnt == 1)             //liweihua 20040324
  826.         #endif
  827.             system_state=SYSTEM_OPEN;   
  828.         if(play_state != VCD_STATE_OPEN) //liweihua add 2004-3-11
  829.             card_plug_state = USER_DO_PLUG_IN;    
  830.         storage_type = detect_result;
  831.      if(media_type != MEDIA_CD)//nono 2004-9-24 20:17
  832.      {
  833.         t_disp = 0;     //wthsin, 2004/7/6 11:39pm
  834.         remain= 0;
  835.      }
  836.         if(media_type == MEDIA_CARD)
  837.             SwitchMedia(CD2CARD);
  838. #ifdef SUPPORT_CARDREADER_TEST
  839.         else if ((Is_MIDI_STATE())&&(gIsMidiSelMenu))
  840.         {
  841.             printf("polling_storage MidiCard_GetCardFile n");
  842.             MidiCard_GetCardFile();
  843.         }
  844. #endif
  845.     }
  846.     //else if((storage_type!=0)&&(storage_type!=detect_result))
  847.     else if( (storage_type!=0)&& ((storage_type & detect_type) == 0) )
  848.     {
  849.         printf("-------- Card/USB Remove! ------n");
  851.         MediaIsEmpty = MEDIA_NOT_EMPTY;//dingzhy 05-1-11 20:26
  853.         #ifdef IR_SWITCH_CD_USB_CF_OTHER   //dingzhy for tonic 4-10-22 13:19
  854.          now_valid_type = 0;    //for bug:move media,always show no media
  855.         #endif
  857.      #ifdef MP3_ONLY_STOP_TO_GUI 
  858.             if( (play_state==VCD_STATE_MP3_FILELIST) && (media_type==MEDIA_CARD) )
  859.             {
  860.          ShowTitle();
  861.          SwitchMedia(CARD2CD);      //wsf 2004-9-16 16:43
  862.       }
  863.  #endif 
  864.    
  865.         if(media_type == MEDIA_CARD)
  866.         { 
  867.             SwitchMedia(CARD2CD);   //Maoyong 2004-8-11 22:52 marked above and add this.
  868.         }
  869. #ifdef SUPPORT_CARDREADER_TEST
  870.         if ((Is_MIDI_STATE())&&(gIsMidiSelMenu))
  871.         {
  872.             MidiCardReadInit();
  873.         }
  874. #endif
  875.         if(play_state != VCD_STATE_OPEN)
  876.             card_plug_state = USER_DO_PLUG_OUT;
  878.      #ifdef SPHE8202_CARD_STORAGE
  879.         if(storage_type!=USB_DEVICE)    //wthsin, 2004/6/28 10:09am
  880.          Card_power_off();      //Power Off      
  881.      #endif//SPHE8202_CARD_STORAGE
  883.         detect_result = 0;
  884.         storage_type = 0;
  885.         t_disp = 0;     //wthsin, 2004/7/6 11:39pm
  886.         remain= 0;
  887.      }
  888. }
  889. /**************************************************************************
  890.  *                                                                        *
  891.  *  Function Name: CardSetBrowse                                          *
  892.  *                                                                        *
  893.  *  Purposes:                                                             *
  894.  *    set system to play card media                                       *
  895.  *  Descriptions:                                                         *
  896.  *    set system to play card media                                       *
  897.  *  Arguments:                                                            *
  898.  *          NONE                                                          *
  899.  *  Returns:     NONE                                                     *
  900.  *                                                                        *
  901.  *  See also:    NONE                                                     *
  902.  *                                                                        *
  903.  **************************************************************************/
  904. //commone function to make system play card media now. Maoyong 2004.05.17
  905. void CardSetBrowse(void)
  906. {
  907.      full_scrn = 0;  //Maoyong 2004-8-11 23:02 for clear setup menu, must place before ClearOsdMsg
  908.      ClearOsdMsg(0);
  909.      t_disp = 0;
  910.      #ifdef SUPPORT_MULTI_PARTITION//liweihua 2004-10-25 8:56
  911.      browser = HddCardBrowse;
  912.      #else
  913.      browser = read_iso9660;
  914.      #endif
  915.      cd_type_loaded=CDROM;
  916.      cd_type=CDROM;
  917.      play_state=VCD_STATE_CLOSE;
  918.      Mp3ReadFinish = 0;//liweihua 2004-5-13
  919.      memset(pFsJpeg, 0, sizeof(FSJPEGDATA));//liweihua add 2004-5-8 9:11
  920.      system_state=SYSTEM_BROWSE;
  921.      sys_cmd=CMD_FUNC|CMD_FUNC_CLOSE;
  922.      media_type = MEDIA_CARD;
  923.      
  924.      //customized osd information for card reading
  925.      //Maoyong 2004.05.25 build funtions in ircmd.card.c, need to make osd display until
  926.      //read all card files for some cards has too many files and take long times
  927.      show_card_reading_osd(SHOW_MEDIA);
  928. }
  929. /**************************************************************************
  930.  *                                                                        *
  931.  *  Function Name: PMP_CF_Card_IsPlugIn                                   *
  932.  *                                                                        *
  933.  *  Purposes:                                                             *
  934.  *    Detect if the PMP'CF is pluged                                      *
  935.  *  Descriptions:                                                         *
  936.  *    Detect if the PMP'CF is pluged                                      *
  937.  *  Arguments:                                                            *
  938.  *          NONE                                                          *
  939.  *  Returns:                                                              *
  940.  *          0: nothing  2: CF plug in  -2: CF plug out                    *
  941.  *  See also:    NONE                                                     *
  942.  *                                                                        *
  943.  **************************************************************************/
  944. #ifdef CARD_SETUP_TYPE_5
  945. UINT8 sense_check_result=0;//liweihua add 2004-11-30
  946. int PMP_CF_Card_IsPlugIn()
  947. {
  948.     UINT8 cf_card_result=0;
  949.     UINT8 check_result;
  950.     
  951.     check_result = sense_check_result;
  952.     sense_check_result = GPIO_I_GET(CF_INS_SENSE);
  953.     
  954.     if(check_result != sense_check_result)
  955.     {
  956.         if(!sense_check_result)
  957.         {
  958.             printf("CF plug in!n");
  959.             return 2;
  960.         }
  961.         else
  962.         {
  963.             printf("CF plug out!n");
  964.             return -2;
  965.         }
  966.     }     
  967.     if(!sense_check_result)  cf_card_result=1;
  968.      //printf("cf_card_result =%x!n",cf_card_result);
  969.      return cf_card_result;
  970. }       
  971. #endif// CARD_SETUP_TYPE_5
  973. #endif //#if defined(SUPPORT_USB)||defined(SPHE8202_CARD_STORAGE)
  975. /**************************************************************************
  976.  *                                                                        *
  977.  *  Function Name: pc_usb_access_mode                                     *
  978.  *                                                                        *
  979.  *  Purposes:                                                             *
  980.  *    Set system to  PC USB MODE                                          *
  981.  *  Descriptions:                                                         *
  982.  *    when connect computer with usb, Set system to  PC USB MODE          *
  983.  *  Arguments:                                                            *
  984.  *          NONE                                                          *
  985.  *  Returns:     NONE                                                     *
  986.  *                                                                        *
  987.  *  See also:    NONE                                                     *
  988.  *                                                                        *
  989.  **************************************************************************/
  990. #ifdef PMP_DVD 
  991. void pc_usb_access_mode()
  992. {
  993.    delay_1ms(50); //Continous 50ms Detect "USB INSERT"
  994.    if(!GPIO_I_GET(PC_USB_CONNECT_PIN)) return;
  995.    watchdog_onoff(0);    // disable watchdog 
  996.    psprintf(RegionValStr[REGION1], "PC USB MODE");
  997.    PrintOsdMsg(STR_OS_SPACE, REGION1, 0, 1); 
  998.   #ifdef PMP_PCB_VER_C 
  999.    regs0->fm_gpio_mode = 9; //8202 IDE PIN => Hi-Z
  1000.    UINT16 temp;
  1001.    temp=regs0->gpio_mode_B;
  1002.    regs0->gpio_mode_B=0;
  1003.   #endif //#ifdef PMP_PCB_VER_C
  1004.    GPIO_O_SET(IDE_BUS_SWITCH_CONTROL_PIN,0);
  1005.   #ifdef PMP_PCB_VER_C 
  1006.    GPIO_O_SET(USB_DEVICE_CHIP_POWER_PIN,0);
  1007.    delay_1ms(300); 
  1008.   #endif //#ifdef PMP_PCB_VER_C
  1009.    GPIO_O_SET(USB_DEVICE_CHIP_POWER_PIN,1);
  1010.    GPIO_O_SET(CARD_POWER_RESET,0); 
  1011.    
  1012.    while(GPIO_I_GET(PC_USB_CONNECT_PIN));
  1013.    
  1014.    GPIO_O_SET(IDE_BUS_SWITCH_CONTROL_PIN,1);
  1015.   #ifdef PMP_PCB_VER_B 
  1016.    GPIO_O_SET(USB_DEVICE_CHIP_POWER_PIN,0);
  1017.   #else //PMP_PCB_VER_C
  1018.    regs0->gpio_mode_B=temp;
  1019.   #endif //#ifdef PMP_PCB_VER_B
  1020.    watchdog_onoff(1);      // enable watchdog
  1021.    watchdog_renew(0xffff);//reset watchdog
  1022.    ClearOsdMsg(1); 
  1023.    system_state= SYSTEM_OPEN;
  1024.    ircmd_stop();
  1025.    ircmd_return();
  1026. }
  1027. /**************************************************************************
  1028.  *                                                                        *
  1029.  *  Function Name: PMP_PC_Usb_PlugInOut                                   *
  1030.  *                                                                        *
  1031.  *  Purposes:                                                             *
  1032.  *    detect if usb connect to computer                                   *
  1033.  *  Descriptions:                                                         *
  1034.  *    detect if usb connect to computer                                   *
  1035.  *  Arguments:                                                            *
  1036.  *          NONE                                                          *
  1037.  *  Returns:     NONE                                                     *
  1038.  *                                                                        *
  1039.  *  See also:    NONE                                                     *
  1040.  *                                                                        *
  1041.  **************************************************************************/
  1042. UINT8 pc_usb_vcc_flag=0;
  1043. void PMP_PC_Usb_PlugInOut()
  1044. {
  1045.    if(pc_usb_vcc_flag==0)
  1046.    {
  1047.      if(GPIO_I_GET(PC_USB_CONNECT_PIN))
  1048.      {
  1049.         #ifdef PMP_UI//liweihua 2005-1-17
  1050.         pmpkey_return();
  1051.         #endif
  1052.         pc_usb_access_mode();
  1053.         pc_usb_vcc_flag=1;
  1054.      }    
  1055.    } 
  1056.    else //(pc_usb_vcc_flag==0)
  1057.    {
  1058.      if(!GPIO_I_GET(PC_USB_CONNECT_PIN))
  1059.      {
  1060.         pc_usb_vcc_flag=0;
  1061.      }
  1062.    }  
  1063. }  
  1064. #endif //#ifdef PMP_DVD