/******************************************************************************
Function Name: SYSPARM_GetActual4p2VoltReading( void )
Description: Return batt_Actual4p2VoltReading
Notes:
******************************************************************************/
UInt16 SYSPARM_GetActual4p2VoltReading(void)
{
UInt32 batt_Actual4p2VoltReading_addr;
UInt16 *batt_Actual4p2VoltReading_ptr;
UInt16 batt_Actual4p2VoltReading_value;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
batt_Actual4p2VoltReading_addr
= SYSPARM_GePAtByIndex("batt_Actual4p2VoltReading",
sizeof(*batt_Actual4p2VoltReading_ptr), 1);
if (!batt_Actual4p2VoltReading_addr) {
pr_err("[sysparm]: Get batt_Default4p2VoltReading PA failed\n");
return 0;
}
batt_Actual4p2VoltReading_ptr
= (UInt16 *)ioremap_nocache(batt_Actual4p2VoltReading_addr,
sizeof(*batt_Actual4p2VoltReading_ptr));
if (!batt_Actual4p2VoltReading_ptr) {
pr_err
("[sysparm]: batt_Actual4p2VoltReading_addr ioremap failed\n");
return 0;
}
batt_Actual4p2VoltReading_value = *batt_Actual4p2VoltReading_ptr;
iounmap(batt_Actual4p2VoltReading_ptr);
return batt_Actual4p2VoltReading_value;
}
/******************************************************************************
Function Name: SYSPARM_GetGPIO_Default_Value
Description: Obtain one record of a GPIO pin settings based on index
Notes:
******************************************************************************/
UInt8 *SYSPARM_GetGPIO_Default_Value(UInt8 gpio_index)
{
UInt32 gpioInit_addr;
UInt8 *gpioInit_ptr;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
gpioInit_addr = SYSPARM_GePAtByIndex("gpioInit",
sizeof(gpioInit_table), 1);
if (!gpioInit_addr) {
pr_err("[sysparm]: Get gpioInit PA failed\n");
return 0;
}
gpioInit_ptr = (UInt8 *)ioremap_nocache(gpioInit_addr,
sizeof(gpioInit_table));
if (!gpioInit_ptr) {
pr_err("[sysparm]: gpioInit_addr ioremap failed\n");
return 0;
}
memcpy(&gpioInit_table[gpio_index][0],
&gpioInit_ptr[gpio_index * 5],
GPIO_INIT_FIELD_NUM * sizeof(UInt8));
iounmap(gpioInit_ptr);
return &gpioInit_table[gpio_index][0];
}
/******************************************************************************
Function Name: APSYSPARM_GetMultimediaAudioParmAccessPtr
Description: Return the multimedia audio parm ptr
Notes:
******************************************************************************/
SysMultimediaAudioParm_t __iomem
*APSYSPARM_GetMultimediaAudioParmAccessPtr(void)
{
UInt32 mmaudio_parm_addr;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
if (!mmaudio_parm_table) {
int parm_table_size = sizeof(SysMultimediaAudioParm_t) *
MMAUDIO_PARM_TABLE_ENTRIES;
mmaudio_parm_addr = SYSPARM_GePAtByIndex("mmaudio_parm",
parm_table_size, 1);
if (!mmaudio_parm_addr) {
pr_err("[sysparm]: Get mmaudio_parm PA failed\n");
return 0;
}
mmaudio_parm_table
= ioremap_nocache(mmaudio_parm_addr, parm_table_size);
if (!mmaudio_parm_table)
pr_err("[sysparm]: mmaudio_parm_addr ioremap failed\n");
}
return mmaudio_parm_table;
}
/******************************************************************************
Function Name: SYSPARM_GetLogFormat
Description: Return default log output format
0: ASCII, 1: binary(Mobile Analyzer), 2: MTT
Notes:
******************************************************************************/
UInt16 SYSPARM_GetLogFormat(void)
{
UInt32 log_format_addr;
UInt16 *log_format_ptr;
UInt16 log_format;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
log_format_addr
= SYSPARM_GePAtByIndex("log_format", sizeof(*log_format_ptr), 1);
if (!log_format_addr) {
pr_err("[sysparm]: Get log_format PA failed\n");
return 0;
}
log_format_ptr
= (UInt16 *)ioremap_nocache(log_format_addr, sizeof(UInt16));
if (!log_format_ptr) {
pr_err("[sysparm]: log_format_addr ioremap failed\n");
return 0;
}
log_format = *log_format_ptr;
iounmap(log_format_ptr);
return log_format;
}
/******************************************************************************
Function Name: APSYSPARM_GetAudioParmAccessPtr
Description: Get access pointer to root of audio sysparm structure
Notes: This is only applicable to audio tuning parameters.
******************************************************************************/
SysAudioParm_t __iomem *APSYSPARM_GetAudioParmAccessPtr(void)
{
UInt32 audio_parm_addr;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err("[sysparm]: sysparm is not yet initialised\n");
return 0;
}
}
if (!audio_parm_table) {
int parm_table_size =
AUDIO_MODE_NUMBER_VOICE * sizeof(SysAudioParm_t);
audio_parm_addr = SYSPARM_GePAtByIndex("audio_parm",
parm_table_size, 1);
if (!audio_parm_addr) {
pr_err("[sysparm]: Get audio_parm PA failed\n");
return 0;
}
audio_parm_table
= ioremap_nocache(audio_parm_addr, parm_table_size);
if (!audio_parm_table)
pr_err("[sysparm]: audio_parm_addr ioremap failed\n");
}
return audio_parm_table;
}
//******************************************************************************
//
// Function Name: SYSPARM_GetBattEmptyThresh
//
// Description: Get battery empty charge threshold
//
// Notes:
//
//******************************************************************************
UInt16 SYSPARM_GetBattEmptyThresh()
{
UInt32 default_batt_empty_thresh_addr;
UInt16* default_batt_empty_thresh_ptr;
UInt16 default_batt_empty_thresh_value;
if(!fuse_sysparm_initialised)
{
if(sysparm_init())
{
pr_err("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
default_batt_empty_thresh_addr = SYSPARM_GePAtByIndex("batt_empty_thresh", sizeof(*default_batt_empty_thresh_ptr), 1);
if(!default_batt_empty_thresh_addr)
{
pr_err("[sysparm]: Get default_batt_empty_thresh_addr PA failed\n");
return 0;
}
default_batt_empty_thresh_ptr = (UInt16*)ioremap_nocache(default_batt_empty_thresh_addr, sizeof(*default_batt_empty_thresh_ptr));
if(!default_batt_empty_thresh_ptr)
{
pr_err("[sysparm]: default_batt_empty_thresh_addr ioremap failed\n");
return 0;
}
default_batt_empty_thresh_value = *default_batt_empty_thresh_ptr;
iounmap(default_batt_empty_thresh_ptr);
return default_batt_empty_thresh_value;
}
/*****************************************************************************
* Function Name: SYSPARM_GetParamU32ByName
*
* Description:Generic function to read value of 32-bit parameters from
* sysparm. Returns 0 on success, negative on error. The
* arguments are:
*
* name - name of the parameter.
* parm - 32-bit value of the parameter is returned via this
* address (memory must be allocated by caller).
*
* Notes:
*****************************************************************************/
int SYSPARM_GetParmU32ByName(char *name, unsigned int *parm)
{
UInt32 parm_addr;
UInt32 *parm_ptr;
if (name == NULL || parm == NULL) {
pr_err("%s: invalid arguments\n", __func__);
return -EINVAL;
}
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err("%s: Fuse sysparm is not yet initialised\n",
__func__);
return -EIO;
}
}
parm_addr = SYSPARM_GePAtByIndex(name, sizeof(*parm_ptr), 1);
if (!parm_addr)
return -ENOENT;
parm_ptr = (UInt32 *)ioremap_nocache(parm_addr, sizeof(UInt32));
if (!parm_ptr) {
pr_err("%s: ioremap failed\n", __func__);
return -EIO;
}
*parm = ioread32(parm_ptr);
iounmap(parm_ptr);
return 0;
}
//******************************************************************************
//
// Function Name: SYSPARM_GetActualLowVoltReading( void )
//
// Description: Return batt_ActualLowVoltReading from sysparms
//
// Notes:
//
//******************************************************************************
UInt16 SYSPARM_GetActualLowVoltReading(void)
{
UInt32 default_batt_ActualLowVoltReading_addr;
UInt16* default_batt_ActualLowVoltReading_ptr;
UInt16 default_batt_ActualLowVoltReading_value;
if(!fuse_sysparm_initialised)
{
if(sysparm_init())
{
pr_err("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
default_batt_ActualLowVoltReading_addr = SYSPARM_GePAtByIndex("batt_ActualLowVoltReading", sizeof(*default_batt_ActualLowVoltReading_ptr), 1);
if(!default_batt_ActualLowVoltReading_addr)
{
pr_err("[sysparm]: Get default_batt_ActualLowVoltReading_addr PA failed\n");
return 0;
}
default_batt_ActualLowVoltReading_ptr = (UInt16*)ioremap_nocache(default_batt_ActualLowVoltReading_addr, sizeof(*default_batt_ActualLowVoltReading_ptr));
if(!default_batt_ActualLowVoltReading_ptr)
{
pr_err("[sysparm]: default_batt_ActualLowVoltReading_addr ioremap failed\n");
return 0;
}
default_batt_ActualLowVoltReading_value = *default_batt_ActualLowVoltReading_ptr;
iounmap(default_batt_ActualLowVoltReading_ptr);
return default_batt_ActualLowVoltReading_value;
}
//******************************************************************************
//
// Function Name: SYSPARM_Get_AUDVOC_PEQCOF_Ptr
//
// Description: Get access pointer to AUDVOC_PEQCOF sysparm
//
//******************************************************************************
UInt16* SYSPARM_Get_AUDVOC_PEQCOF_Ptr( void )
{
UInt32 AUDVOC_PEQCOF_parm_addr;
UInt16* AUDVOC_PEQCOF_ptr;
if(!fuse_sysparm_initialised)
{
if(sysparm_init())
{
pr_err("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
AUDVOC_PEQCOF_parm_addr = SYSPARM_GePAtByIndex("AUDVOC_PEQCOF", sizeof(AUDVOC_PEQCOF), 1);
if(!AUDVOC_PEQCOF_parm_addr)
{
pr_err("[sysparm]: Get AUDVOC_PEQCOF PA failed\n");
return 0;
}
AUDVOC_PEQCOF_ptr = (UInt16*)ioremap_nocache(AUDVOC_PEQCOF_parm_addr, sizeof(AUDVOC_PEQCOF));
if(!AUDVOC_PEQCOF_ptr)
{
pr_err("[sysparm]: AUDVOC_PEQCOF_parm_addr ioremap failed\n");
return 0;
}
memcpy(AUDVOC_PEQCOF, AUDVOC_PEQCOF_ptr, sizeof(AUDVOC_PEQCOF));
iounmap(AUDVOC_PEQCOF_ptr);
return (UInt16*)AUDVOC_PEQCOF;
}
//******************************************************************************
//
// Function Name: APSYSPARM_GetMultimediaAudioParmAccessPtr
//
// Description: Get access pointer to root of mmaudio_parm structure
//
// Notes: This is only applicable to audio tuning parameters.
//
//******************************************************************************
SysIndMultimediaAudioParm_t* APSYSPARM_GetMultimediaAudioParmAccessPtr(void)
{
UInt32 mmaudio_parm_addr;
SysIndMultimediaAudioParm_t* mm_audio_parm_ptr;
static int mm_audioparm_inited = 0;
// don't copy again if we've already populated our local cache
if ( mm_audioparm_inited )
{
return &mm_audio_parm_table[0][0];
}
if(!fuse_sysparm_initialised)
{
if(sysparm_init())
{
pr_err("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
mmaudio_parm_addr = SYSPARM_GePAtByIndex("mmaudio_parm", sizeof(mm_audio_parm_table), 1);
if(!mmaudio_parm_addr)
{
pr_err("[sysparm]: Get mmaudio_parm PA failed\n");
return 0;
}
mm_audio_parm_ptr = (SysIndMultimediaAudioParm_t*)ioremap_nocache(mmaudio_parm_addr, sizeof(mm_audio_parm_table));
if(!mm_audio_parm_ptr)
{
pr_err("[sysparm]: mmaudio_parm_addr ioremap failed\n");
return 0;
}
memcpy(&mm_audio_parm_table[0][0], mm_audio_parm_ptr, sizeof(mm_audio_parm_table));
iounmap(mm_audio_parm_ptr);
mm_audioparm_inited = 1;
return &mm_audio_parm_table[0][0];
}
int SYSPARM_GetPMURegSettings(int index, unsigned int *parm)
{
/* DLG start */
#if defined(CONFIG_MFD_MAX8986)
UInt32 parm_addr;
UInt8 *parm_ptr;
if (index < 0 || index >= PARM_PMU_REG_TOTAL || parm == NULL) {
pr_err("%s: invalid arguments\n", __func__);
return -EINVAL;
}
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err("%s: Fuse sysparm is not yet initialised\n",
__func__);
return -EIO;
}
}
parm_addr = SYSPARM_GePAtByIndex(PARM_PMU_REG_NAME, PARM_PMU_REG_TOTAL,
1);
if (!parm_addr)
return -ENOENT;
parm_ptr = (UInt8 *)ioremap_nocache(parm_addr, PARM_PMU_REG_TOTAL);
if (!parm_ptr) {
pr_err("%s: ioremap failed\n", __func__);
return -EIO;
}
*parm = ioread8(parm_ptr + index);
iounmap(parm_ptr);
#endif
/* DLG end */
return 0;
}
//******************************************************************************
//
// Function Name: SYSPARM_GetExtAudioParmAccessPtr
//
// Description: Get access pointer to sysparm structure
// based on the audio tuning mode.
//
// Notes: This api is deprecated. You should use
// APSYSPARM_GetAudioParmAccessPtr().
//
//******************************************************************************
SysAudioParm_t* SYSPARM_GetExtAudioParmAccessPtr(UInt8 AudioApp)
{
UInt32 audio_parm_addr;
SysAudioParm_t *audio_parm_ptr;
static int loaded_audio_parm_table=0;
if(loaded_audio_parm_table)
return &audio_parm_table[AudioApp][0];
if(!fuse_sysparm_initialised)
{
if(sysparm_init())
{
pr_err("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
audio_parm_addr = SYSPARM_GePAtByIndex("audio_parm", sizeof(audio_parm_table), 1);
if(!audio_parm_addr)
{
pr_err("[sysparm]: Get audio_parm PA failed\n");
return 0;
}
audio_parm_ptr = (SysAudioParm_t*)ioremap_nocache(audio_parm_addr, sizeof(audio_parm_table));
if(!audio_parm_ptr)
{
pr_err("[sysparm]: audio_parm_addr ioremap failed\n");
return 0;
}
memcpy(&audio_parm_table, &audio_parm_ptr, sizeof(audio_parm_table));
iounmap(audio_parm_ptr);
loaded_audio_parm_table = 1;
return &audio_parm_table[AudioApp][0];
}
/******************************************************************************
Function Name: APSYSPARM_GetIndMultimediaAudioParmAccessPtr
Description: Return the independent multimedia audio parm ptr
Notes:
******************************************************************************/
SysIndMultimediaAudioParm_t __iomem
*APSYSPARM_GetIndMultimediaAudioParmAccessPtr(void)
{
UInt32 ind_mmaudio_parm_addr;
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return 0;
}
}
if (!ind_mmaudio_parm_table) {
int parm_table_size =
AUDIO_MODE_NUMBER * sizeof(SysIndMultimediaAudioParm_t);
ind_mmaudio_parm_addr
= SYSPARM_GePAtByIndex("ind_mmaudio_parm",
parm_table_size, 1);
if (!ind_mmaudio_parm_addr) {
pr_err("[sysparm]: Get ind_mmaudio_parm PA failed\n");
return 0;
}
ind_mmaudio_parm_table
= ioremap_nocache(ind_mmaudio_parm_addr, parm_table_size);
if (!ind_mmaudio_parm_table)
pr_err
("[sysparm]: ind_mmaudio_parm_addr ioremap failed\n");
}
return ind_mmaudio_parm_table;
}
/******************************************************************************
Function Name: SYSPARM_GetImeiStr
Description: This function gets the 14-digit IMEI saved in Sys Parm
and calculates the 15th digit (check digit) based on the
14 digits. It then returns the 15-digit IMEI in a
Null-terminated string.
UInt8* inImeiStr - Buffer to store the
returned 15-digit IMEI buffer. Must
be at least 16-byte in size.
******************************************************************************/
Boolean SYSPARM_GetImeiStr(UInt8 *inImeiStr)
{
UInt8 indexA = 0;
UInt8 indexB = 0;
UInt32 imei_addr;
UInt8 *pCurrImei;
UInt8 *pSysparmImei;
Boolean bIMEIError = FALSE;
/* Default IMEI (allocated to Broadcom as test IMEI) to return in case:
* 1. The IMEI digits in Sysparm are all 0's or
* 2. The IMEI digits in Sysparm are invalid
*/
static const UInt8 default_imei[SYS_IMEI_LEN]
= { 0x0F, 0x10, 0x60, 0x00, 0x00, 0x10, 0x32, 0xF4 };
/* sanity check */
if (!inImeiStr) {
pr_err("[sysparm]: SYSPARM_GetImeiStr inImeiStr NULL\n");
return FALSE;
}
if (!fuse_sysparm_initialised) {
if (sysparm_init()) {
pr_err
("[sysparm]: Fuse sysparm is not yet initialised\n");
return FALSE;
}
}
/* lookup address of IMEI sysparm data by name */
imei_addr = SYSPARM_GePAtByIndex("imei", IMEI_SIZE, 1);
if (!imei_addr) {
pr_err("[sysparm]: Get imei_addr PA failed\n");
return FALSE;
}
/* do some linux memory magic... */
pSysparmImei = (UInt8 *)ioremap_nocache(imei_addr, IMEI_SIZE);
if (!pSysparmImei) {
pr_err("[sysparm]: imei_addr ioremap failed\n");
return FALSE;
}
/* Check the validity of sysparm IMEI */
for (indexA = 0; indexA < SYS_IMEI_LEN; indexA++) {
if ((indexA != (SYS_IMEI_LEN - 1)
&& (pSysparmImei[indexA] & 0xF0) > 0x90) ||
(indexA != 0 && (pSysparmImei[indexA] & 0x0F) > 0x09)) {
pr_err
("[sysparm]: invalid imei digit, using default\n");
bIMEIError = TRUE; /* invalid IMEI digit */
}
}
/* check for all-zero IMEI */
if (!bIMEIError &&
((pSysparmImei[0] & 0xF0) == 0
&& pSysparmImei[1] == 0 && pSysparmImei[2] == 0
&& pSysparmImei[3] == 0 && pSysparmImei[4] == 0
&& pSysparmImei[5] == 0 && pSysparmImei[6] == 0
&& (pSysparmImei[7] & 0x0F) == 0)
) {
/*all-zero IMEI considered error */
pr_err("[sysparm]: all zero sysparm imei, using default\n");
bIMEIError = TRUE;
}
if (bIMEIError) {
/*invalid sysparm IMEI, so use hardcoded default testing value */
pCurrImei = (UInt8 *)default_imei;
} else {
pCurrImei = pSysparmImei;
}
/* convert from BCD to NULL terminated string */
indexA = 0;
inImeiStr[indexB] = pCurrImei[indexA] >> 4; /*First Digit */
for (indexA = 1, indexB = 1; indexA < 7; indexA++) { /*2-13th Digit */
inImeiStr[indexB++] = pCurrImei[indexA] & 0x0F;
inImeiStr[indexB++] = pCurrImei[indexA] >> 4;
}
inImeiStr[indexB++] = pCurrImei[indexA] & 0x0F; /*14th Digit */
inImeiStr[indexB++] = CalculateCheckDigit(inImeiStr); /*15th Digit */
inImeiStr[indexB] = '\0';
indexA = 0;
while (indexA < 15) { /* 1-15th Digit */
inImeiStr[indexA] = inImeiStr[indexA] | 0x30;
indexA++;
}
iounmap(pSysparmImei);
return TRUE;
}
