init.c

MTK debug flash 兼容性的code

*
* DESCRIPTION
*   This function returns the version number of the baseband chip
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_char* release_bb_chip(void)
{
   static kal_char str_return[]="MT6205B, E00";

#if defined(FPGA)
   strcpy(str_return, "FPGA");
#elif defined(MT6208)
   strcpy(str_return, "MT6208");
#elif defined(MT6205)
   strcpy(str_return, "MT6205");
#else /* future chips will definitely apply this rule */
   kal_uint16 hw_code;
   kal_uint8 majrev; /* bit 8~11 of HW_VER register */
   kal_uint8 ffix; /* bit 0~3 of HW_VER register */
   kal_uint16 hw_version;
   kal_uint16 temp_num;

   hw_code = *HW_CODE;
   hw_version = *HW_VER;
   majrev = (hw_version >> 8) & 0x000f; /* get MAJREV from HW_VER */
   ffix = hw_version & 0x000f; /* get FFIX from HW_VER */

   /* convert the HW_CODE to natural representation*/
   temp_num = (hw_code & 0x000f);
   hw_code >>= 4;
   temp_num += (hw_code & 0x000f) * 10;
   hw_code >>= 4;
   temp_num += (hw_code & 0x000f) * 100;
   hw_code >>= 4;
   temp_num += (hw_code & 0x000f) * 1000;

   /* construct the string for the chips MTxxxxx, ECOx */
   if (majrev == 0x0a) /* directiver A, which often skip the directive */
   {
      sprintf(str_return, "MT%4d, E%02d", temp_num, ffix);
   }
   else if (majrev == 0x0b && temp_num == 6219)
   {
      /* special hanlding for MT6226M */
      sprintf(str_return, "MT6226M, E%02d", ffix);
   }
   else
   {
      sprintf(str_return, "MT%4d%1X, E%02d", temp_num, majrev, ffix);
   }
#endif

   return str_return;
}

/*************************************************************************
* FUNCTION
*  AnalogDieID
*
* DESCRIPTION
*  This function returns identification of analog die
*
* CALLS
*
* PARAMETERS
*  None
*
* RETURNS
*  Identification of analog die
*
* GLOBALS AFFECTED
*  None
*
*************************************************************************/
analog_die_id AnalogDieID()
{
#ifdef MT6218B

   if (*(ANALOG_HW_VERSION) == 0x0000 && *(ANALOG_HW_CODE) == 0x0000)
      return B63216A;
   else if (*(ANALOG_HW_VERSION) == 0x8c00 && *(ANALOG_HW_CODE) == 0x6216)
      return C63216A;
   else
      return UNKNOWN_ANALOG_DIE;

#elif defined(MT6219)   /* #ifdef MT6218B */

   if (*(ANALOG_HW_VERSION) == 0x8c00 && *(ANALOG_HW_CODE) == 0x6216)
      return C63216A;
   else if (*(ANALOG_HW_VERSION) == 0x8c01 && *(ANALOG_HW_CODE) == 0x6216)
      return C63216B;
   else
      return UNKNOWN_ANALOG_DIE;

#else   /* #ifdef MT6218B */

   return UNKNOWN_ANALOG_DIE;

#endif   /* MT6218B */
}

/*************************************************************************
* FUNCTION
*  INT_ecoVersion
*
* DESCRIPTION
*  This function returns the ECO version number of baseband chipset
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
ECO_VERSION INT_ecoVersion(void)
{
#if defined(MT6205B)

   if (*HW_CODE == 0x6205 && *HW_VER == 0x8b00)

      return EN;

   return MT6205B_latest_chip;

#elif defined(MT6218)   /* MT6205B */

   if (*HW_CODE == 0x6218 && *HW_VER == 0x8a00)

      return AN;

   return MT6218_latest_chip;

#elif defined(MT6218B)   /* MT6205B */

   if (*HW_CODE == 0x6218 && *HW_VER == 0x8b00)

      return BN;

   else if (*HW_CODE == 0x6218 && *HW_VER == 0x8b01)

      return CN;

   else if (*HW_CODE == 0x6218 && *HW_VER == 0x8b02) {

      if (AnalogDieID() == B63216A)

         return DN;

      else if (AnalogDieID() == C63216A)

         return EN;

   } else if (*HW_CODE == 0x6218 && *HW_VER == 0x8b03)

      return FN;

   else if (*HW_CODE == 0x6218 && *HW_VER == 0x8b04)

      return GN;

   return MT6218B_latest_chip;

#elif defined(MT6217)   /* MT6218 */

   if (*HW_CODE == 0x6217 && *HW_VER == 0x8a00) {

      if (AnalogDieID() == C63216B)

         return BN;
   }

   return MT6217_latest_chip;

#elif defined(MT6219)   /* MT6205B */

   if (*HW_CODE == 0x6219 && *HW_VER == 0x8a00) {

      if (AnalogDieID() == C63216A)

         return AV;

      else if (AnalogDieID() == C63216B)

         return BV;

   } else if (*HW_CODE == 0x6219 && *HW_VER == 0x8a01) {

      if (AnalogDieID() == C63216B)

         return EV;

   }

   return MT6219_latest_chip;

#elif defined(MT6227) || defined(MT6226) || defined(MT6226M)

   /* the hardware code of MT6226M IS 6219 */

   if ( (*HW_CODE == 0x6226 || *HW_CODE == 0x6227 || *HW_CODE == 0x6219) && *HW_VER == 0x8a00) {

      return ECO_E1;

   } else if ( (*HW_CODE == 0x6226 || *HW_CODE == 0x6227 || *HW_CODE == 0x6219) && *HW_VER == 0x8a01) {

      return ECO_E2;

   }

   return MT6227_latest_chip;

#elif defined(MT6225)

   if (*HW_CODE == 0x6225 && *HW_VER == 0x8a00) {
      return ECO_E1;
   } else if (*HW_CODE == 0x6225 && *HW_VER == 0x8a01) {
      return ECO_E2;
   } else if (*HW_CODE == 0x6225 && *HW_VER == 0x8a02) {
      return ECO_E3;
   } else if (*HW_CODE == 0x6225 && *HW_VER == 0x8a03) {
      return ECO_E4;
   }

   return MT6225_latest_chip;

#elif defined(MT6228)

   return MT6228_latest_chip;

#elif defined(MT6229)

   return MT6229_latest_chip;
   
#elif defined(MT6230)

   return MT6230_latest_chip;   
   
#elif defined(MT6223) || defined(MT6223P)

/*
   if (*HW_CODE == 0x6223 && *HW_VER == 0x8a01) {
      return ECO_E2;   
   } else if (*HW_CODE == 0x6223 && *HW_VER == 0x8a04) {
      return ECO_E5;
   }
*/   
   return MT6223_latest_chip;      

#elif defined(MT6227D) || defined(MT6226D)

   return MT6227D_latest_chip;
   
#else   /* MT6205B */

   /* no one should invoke this function for unknown chip */

   EXT_ASSERT(0, 0, 0, 0);

   return 0;

#endif   /* MT6025B */
}

/*************************************************************************
* FUNCTION
*  INT_VersionNumbers
*
* DESCRIPTION
*   This function returns the version number of the followings
*   1. Chip version
*   2. DSP version
*   3. DSP patch version
*   4. MCU software version
*   5. Baseband board version
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
void INT_VersionNumbers(version_struct * ptr_version)
{
   ptr_version->bb_chip = release_bb_chip();
   ptr_version->dsp_fw = release_dsp_fw();
   ptr_version->dsp_ptch = release_dsp_ptch();
   ptr_version->mcu_sw = release_verno();
   ptr_version->mcu_sw_branch = release_branch();
   ptr_version->bb_board = release_hw_ver();
   return;
}

#ifdef __RVCT__

/*************************************************************************
* FUNCTION
*  __user_initial_stackheap
*
* DESCRIPTION
*  This dummy function is implemented to make the linker happy for RVCT.
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
__value_in_regs struct __initial_stackheap __user_initial_stackheap(unsigned i0, unsigned i1, unsigned i2, unsigned i3)
{
   struct __initial_stackheap config;

   kal_fatal_error_handler("Should-not-Execute", KAL_ERROR_SHOULD_NOT_EXECUTE, KAL_ERROR_KAL_SUB_ERROR_CODE1);

   config.heap_base = i1;
   config.heap_limit = i1;
   config.stack_base = i1; 
   config.stack_limit = 0;

   return config;
}

/*************************************************************************
* FUNCTION
*  _sys_command_string
*
* DESCRIPTION
*  This dummy function is implemented for non semi-hosting and
*  heap extension support.
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
char *$Sub$$_sys_command_string(char *cmd, int len)
{
   return 0;
}

#endif   /* __RVCT__ */

/*************************************************************************
* FUNCTION
*  INT_GetCurrentTime
*
* DESCRIPTION
*  This function access 32KHz Counter and return Counter Value
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*  Value of 32KHz Counter
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint32 INT_GetCurrentTime(void)
{
   return *(volatile kal_uint32*)(0x80200230);
}

/*************************************************************************
* FUNCTION
*  INT_CheckSystemDriveOnNAND()
*
* DESCRIPTION
*  Query the location of system drive, either NAND-flash or NOR-flash
*
* PARAMETERS
*
* RETURNS
*  KAL_TRUE: NFB or System Drive On NAND
*  KAL_FALSE: otherwise
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool INT_CheckSystemDriveOnNAND(void)
{
#if ( defined(__FS_SYSDRV_ON_NAND__) || defined( _NAND_FLASH_BOOTING_) )

   return KAL_TRUE;
   
#else

   return KAL_FALSE;

#endif /* __FS_SYSDRV_ON_NAND__ || _NAND_FLASH_BOOTING_ */
}

/*************************************************************************
* FUNCTION
*  INT_IsBootByCodeShadow()
*
* DESCRIPTION
*  Query if system boot via code shadow, 
*  On the other word, binary code copy to RAM before execution
*
* PARAMETERS
*
* RETURNS
*  KAL_TRUE: Nand Flash booting
*  KAL_FALSE: otherwise
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool INT_IsBootByCodeShadow(void)
{
#if defined(_NAND_FLASH_BOOTING_)

   return KAL_TRUE;
   
#else

   return KAL_FALSE;

#endif /* _NAND_FLASH_BOOTING_ */
}

/*************************************************************************
* FUNCTION
*  INT_IsCodeShadowDone()
*
* DESCRIPTION
*  Query if binary code already ready via code shadow, 
*
* PARAMETERS
*
* RETURNS
*  KAL_TRUE: ! Nand Flash Booting , or Secondary Image loaded on NFB
*  KAL_FALSE: otherwise
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool INT_IsCodeShadowDone(void)
{
#if defined(_NAND_FLASH_BOOTING_)

   return NFB_SecondaryImageLoaded;
   
#else

   return KAL_TRUE;

#endif /* _NAND_FLASH_BOOTING_ */
}


/*************************************************************************
* FUNCTION
*  init_32khz_output
*
* DESCRIPTION
*  This function initializes 32khz clock output.
*  This should be invoked in the initial state to get the GPIO pin for
*  32khz clock output.
*
* PARAMETERS
*  gpio_pin   -   GPIO pin for 32KHz clock output
*
* RETURNS
*  none
*
*************************************************************************/
void init_32khz_output(kal_uint16 gpio_pin, kal_uint16 gpio_data)
{
    _32khz_gpio_pin = gpio_pin;
    _32khz_gpio_data = gpio_data;
}


/*************************************************************************
* FUNCTION
*  enable_32khz_output
*
* DESCRIPTION
*  This function enables 32KHz clock output.
*
* PARAMETERS
*  none
*
* RETURNS
*  0 for success; -1 for failure
*
*************************************************************************/
kal_int32 enable_32khz_output(void)
{
   kal_uint32 irq;


   /* validate user count */
   if ((_32khz_user_cnt + 1) == 0) {
       ASSERT(0);
   }

   /* validate GPIO pin number */
   if (_32khz_gpio_pin == 0xFFFF) {
       return -1;
   }

   /* increament user count */
   irq = SaveAndSetIRQMask();
   _32khz_user_cnt++;
   RestoreIRQMask(irq);

   if (_32khz_user_cnt == 1) {
       /* first enable; config 32KHz clock output */
       GPIO_ModeSetup(_32khz_gpio_pin, _32khz_gpio_data);
   }

   return 0;
}


/*************************************************************************
* FUNCTION
*  disable_32khz_output
*
* DESCRIPTION
*  This function disables 32KHz clock output (if and only if there is
*  no more use).
*
* PARAMETERS
*  none
*
* RETURNS
*  0 for success; -1 for failure
*
*************************************************************************/
kal_int32 disable_32khz_output(void)
{
   kal_uint32 irq;

   /* validate user count */
   if (_32khz_user_cnt == 0) {
       ASSERT(0);
   }

   /* validate GPIO pin number */
   if (_32khz_gpio_pin == 0xFFFF) {
       return -1;
   }

   /* decreament user count */
   irq = SaveAndSetIRQMask();
   _32khz_user_cnt--;
   RestoreIRQMask(irq);

   if (_32khz_user_cnt == 0) {
       /* last disable; config as general purpose IO */
       GPIO_ModeSetup(_32khz_gpio_pin, 0);
       GPIO_InitIO(OUTPUT, _32khz_gpio_pin);
       GPIO_WriteIO(0, _32khz_gpio_pin);
   }

   return 0;
}

#undef RTOS_DEBUG


#endif /*__FUE__*/