void msm_proc_comm_reset_modem_now(void)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
if(power_off_done) return;
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel_relaxed(PCOM_RESET_MODEM, base + APP_COMMAND);
writel_relaxed(0, base + APP_DATA1);
writel_relaxed(0, base + APP_DATA2);
spin_unlock_irqrestore(&proc_comm_lock, flags);
/* Make sure the writes complete before notifying the other side */
wmb();
notify_other_proc_comm();
return;
}
/*
* We need to wait for the ARM9 to at least partially boot
* up before we can continue. Since the ARM9 does resource
* allocation, if we dont' wait we could end up crashing or in
* and unknown state. This function should be called early to
* wait on the ARM9.
*/
void __init proc_comm_boot_wait(void)
{
void __iomem *base = MSM_SHARED_RAM_BASE;
proc_comm_wait_for(base + MDM_STATUS, PCOM_READY);
}
void msm_proc_comm_reset_modem_now(void)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
#ifdef CONFIG_KERNEL_DEBUG_SEC
samsung_vendor1_id* smem_vendor1 = NULL;
smem_vendor1 = (samsung_vendor1_id *)smem_alloc(SMEM_ID_VENDOR1, sizeof(samsung_vendor1_id));
//smem_vendor1->modem_dump.modem = 0x0f;
smem_vendor1->apps_dump.apps = 0xf0;
smem_vendor1->off_charging_off = 0x11;
modem_reset_requested = 1;
#endif
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(PCOM_RESET_MODEM, base + APP_COMMAND);
writel(0, base + APP_DATA1);
writel(0, base + APP_DATA2);
spin_unlock_irqrestore(&proc_comm_lock, flags);
/* Make sure the writes complete before notifying the other side */
dsb();
notify_other_proc_comm();
return;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
KFUNC_TRACE3("proc_comm_start", cmd, data1?*data1:0, data2?*data2:0);
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
/* Make sure the writes complete before notifying the other side */
dsb();
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
/* Make sure the writes complete before returning */
dsb();
spin_unlock_irqrestore(&proc_comm_lock, flags);
KFUNC_TRACE3("proc_comm_end", cmd, data1?*data1:0, data2?*data2:0);
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
if (Arm9Crashed)
{
printk("[HSIL] %s : Arm9Crashed #1\n", __func__);
spin_unlock_irqrestore(&proc_comm_lock, flags);
return -1;
}
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
void __iomem *base = MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
spin_lock_irqsave(&proc_comm_lock, flags);
for (;;) {
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
continue;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
continue;
if (readl(base + APP_STATUS) != PCOM_CMD_FAIL) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
break;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
void msm_proc_comm_reset_modem_now(void)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(PCOM_RESET_MODEM, base + APP_COMMAND);
writel(0, base + APP_DATA1);
writel(0, base + APP_DATA2);
spin_unlock_irqrestore(&proc_comm_lock, flags);
notify_other_proc_comm();
return;
}
//Added for new touch calibration by Stanley++
int msm_proc_comm_oem_for_nv(unsigned cmd, unsigned *data1, unsigned *data2, unsigned *cmd_parameter)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
size_t sizeA, sizeB;
smem_oem_cmd_data *cmd_buf;
void* test;
/* FIH, Debbie Sun, 2009/06/18 { */
/* get share memory command address dynamically */
int size;
sizeA=40;
sizeB=64;
cmd_buf = smem_get_entry(SMEM_ID_VENDOR1, &size);
test = cmd_buf+sizeof(unsigned int);
/* FIH, Debbie Sun, 2009/06/18 } */
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_WRITE)
{
//memcpy(cmd_buf->cmd_data.cmd_parameter[0],cmd_parameter,40);
memcpy(test,(const void *)cmd_parameter,sizeA);
} else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_WRITE)
{
//memcpy(cmd_buf->cmd_data.cmd_parameter[0],cmd_parameter,64);
memcpy(test,(const void *)cmd_parameter,sizeB);
} else
{
// Set the parameter of OEM_CMD1
cmd_buf->cmd_data.cmd_parameter[0] = cmd_parameter[0];
cmd_buf->cmd_data.cmd_parameter[1] = cmd_parameter[1]; //Added for new touch calibration by Stanley
cmd_buf->cmd_data.cmd_parameter[2] = cmd_parameter[2]; //Added for new touch calibration by Stanley
}
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
#if 0
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
#endif
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
//spin_unlock_irqrestore(&proc_comm_lock, flags);
/* read response value, Hanson Lin */
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag))
{
//waiting
}
ret = (cmd_buf->return_data.check_flag & 0x1111);
//if(ret)
//return ret;
if(!ret)
{
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_READ)
{
//memcpy(data2,cmd_buf->return_data.return_value[0],40);
memcpy((void *)data2, test,sizeA);
} else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_READ)
{
//memcpy(data2,cmd_buf->return_data.return_value[0],64);
memcpy((void *)data2,test,sizeB);
} else {
*data2 = cmd_buf->return_data.return_value[0];
}
memcpy(cmd_parameter, cmd_buf->return_data.return_value, 8); //Added for new touch calibration by Stanley
}
//*data2 = cmd_buf->return_data.return_value[0];
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
/* read response value, Hanson Lin */
}
int msm_proc_comm_oem_tcp_filter(void *cmd_data, unsigned cmd_size)
{
unsigned cmd = PCOM_CUSTOMER_CMD1;
unsigned oem_cmd = SMEM_PROC_COMM_OEM_UPDATE_TCP_FILTER;
//unsigned oem_resp;
unsigned *data1 = &oem_cmd;
unsigned *data2 = NULL;
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
smem_oem_cmd_data *cmd_buf;
void* ptr;
int size;
#if 1
unsigned short *content = (unsigned short *)cmd_data;
for(ret=0; ret<cmd_size/2; ret++) {
printk(KERN_INFO "tcp filter [%d, %4x]\n", ret, *(content+ret));
}
#endif
cmd_buf = smem_get_entry(SMEM_ID_VENDOR1, &size);
ptr = (unsigned*)&cmd_buf->cmd_data.cmd_parameter[0];
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
{
memcpy(ptr,(const void *)cmd_data,cmd_size);
}
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
/* read response value, Hanson Lin */
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag))
{
//waiting
}
ret = (cmd_buf->return_data.check_flag & 0x1111);
spin_unlock_irqrestore(&proc_comm_lock, flags);
if(ret) {
printk(KERN_ERR "msm_proc_comm_oem_tcp_filter() returns %d\n", ret);
}
return ret;
}
int msm_proc_comm_oem(unsigned cmd, unsigned *data1, unsigned *data2, unsigned *cmd_parameter)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
size_t sizeA, sizeB;
smem_oem_cmd_data *cmd_buf;
void* test;
/* FIH, Debbie Sun, 2009/06/18 { */
/* get share memory command address dynamically */
int size;
sizeA=40;
sizeB=64;
cmd_buf = smem_get_entry(SMEM_ID_VENDOR1, &size);
// test = cmd_buf+sizeof(unsigned int);
//FIH, WilsonWHLee, 2009/11/26++
/* [FXX_CR], read product id as serial number*/
test= (unsigned*)&cmd_buf->cmd_data.cmd_parameter[0];
//FIH, WilsonWHLee, 2009/11/26--
/* FIH, Debbie Sun, 2009/06/18 } */
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_WRITE)
{
//memcpy(cmd_buf->cmd_data.cmd_parameter[0],cmd_parameter,40);
memcpy(test,(const void *)cmd_parameter,sizeA);
} else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_WRITE)
{
//memcpy(cmd_buf->cmd_data.cmd_parameter[0],cmd_parameter,64);
memcpy(test,(const void *)cmd_parameter,sizeB);
} else if(*data1==SMEM_PROC_COMM_OEM_POWER_OFF)
{
memcpy(test,(const void *)cmd_parameter, SMEM_OEM_CMD_BUF_SIZE*sizeof(int));
} else
{
// Set the parameter of OEM_CMD1
cmd_buf->cmd_data.cmd_parameter[0] = cmd_parameter[0];
}
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
#if 0
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
#endif
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
//spin_unlock_irqrestore(&proc_comm_lock, flags);
/* read response value, Hanson Lin */
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag))
{
//waiting
}
ret = (cmd_buf->return_data.check_flag & 0x1111);
//if(ret)
//return ret;
if(!ret)
{
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_READ)
{
//memcpy(data2,cmd_buf->return_data.return_value[0],40);
memcpy((void *)data2, test,sizeA);
} else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_READ)
{
//memcpy(data2,cmd_buf->return_data.return_value[0],64);
memcpy((void *)data2,test,sizeB);
/* FIH, WilsonWHLee, 2009/11/19 { */
/* [FXX_CR], add for download tool */
} else if(*data1==SMEM_PROC_COMM_OEM_NV_READ)
{
memcpy(data2,&cmd_buf->return_data.return_value[0],128); //WilsonWHLee, 2010/08/12 extend length for pc tool
//*test = cmd_buf->return_data.return_value;
// memcpy((void *)data2,test,32);
/* }FIH:WilsonWHLee 2009/11/19 */
//FIH, NeoChen, Check FUSE for adjusting AXI & ARM11 clock, 2010/07/27 ++
#ifdef CONFIG_FIH_PROJECT_F0X
} else if(*data1==SMEM_PRPC_COMM_OEM_FUSE_READ)
{
memcpy(data2,&cmd_buf->return_data.return_value[0],32);
//FIH, NeoChen, Check FUSE for adjusting AXI & ARM11 clock, 2010/07/27 --
#endif
} else {
*data2 = cmd_buf->return_data.return_value[0];
}
}
//*data2 = cmd_buf->return_data.return_value[0];
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
/* read response value, Hanson Lin */
}
//SW2-5-1-BH-DbgCfgTool-00+[
int msm_proc_comm_oem_n(unsigned cmd, unsigned *data1, unsigned *data2, unsigned *cmd_parameter, int u32_para_size)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
size_t sizeA, sizeB;
smem_oem_cmd_data *cmd_buf;
void* test;
/* get share memory command address dynamically */
int size;
sizeA=40;
sizeB=64;
cmd_buf = smem_get_entry(SMEM_ID_VENDOR1, &size);
if( (cmd_buf == 0) || (size < u32_para_size) )
{
printk(KERN_ERR "[SMEM_PROC_COMM] %s() LINE:%d, Can't get shared memory entry.(size %d,u32_para_size %d)\n", __func__, __LINE__, size, u32_para_size);
return -EINVAL;
}
test= (unsigned*)&cmd_buf->cmd_data.cmd_parameter[0];
if( (cmd_parameter == NULL) || (u32_para_size == 0) )
{
printk(KERN_ERR "[SMEM_PROC_COMM] %s() LINE:%d, ERROR: u32_para_size %d.\n", __func__, __LINE__, u32_para_size);
return -EINVAL;
}
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
// Set the parameter of OEM_CMD1
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
memcpy(cmd_buf->cmd_data.cmd_parameter,cmd_parameter,sizeof(unsigned)*u32_para_size);
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
{
goto again;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
/* read response value, Hanson Lin */
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag))
{
//waiting
}
/* Div6-D1-SY-FIHDBG-00*{
* Due to review return value in AMSS, we decide to modify the mask
* from 0x1111 to 0xFFFF to identify the correct error type.
* Notice: Need to review the "check_flag" usage in both mARM and aARM.
*/
ret = (cmd_buf->return_data.check_flag & 0xFFFF);
/* Div6-D1-SY-FIHDBG-00*} */
if(!ret)
{
*data2 = cmd_buf->return_data.return_value[0];
/* Copy the returned value back to user "cmd_parameter" */
memcpy(cmd_parameter, cmd_buf->return_data.return_value, sizeof(unsigned) * u32_para_size);
}
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
spin_lock_irqsave(&proc_comm_lock, flags);
#ifdef CONFIG_LGE_BLUE_ERROR_HANDLER
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto crash;
#else
if (msm_proc_comm_disable) {
ret = -EIO;
goto end;
}
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
#endif
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
/* Make sure the writes complete before notifying the other side */
dsb();
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
#ifdef CONFIG_LGE_BLUE_ERROR_HANDLER
goto crash;
#else
goto again;
#endif
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
switch (cmd) {
case PCOM_RESET_CHIP:
case PCOM_RESET_CHIP_IMM:
case PCOM_RESET_APPS:
msm_proc_comm_disable = 1;
printk(KERN_ERR "msm: proc_comm: proc comm disabled\n");
break;
}
end:
/* Make sure the writes complete before returning */
dsb();
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
#ifdef CONFIG_LGE_BLUE_ERROR_HANDLER
/* LGE_CHANGE_S [[email protected]] 2009-07-06 <For Error Handler > */
crash:
{
extern char * error_modem_message ;
extern int LG_ErrorHandler_enable;
// extern int get_status_hidden_reset();
int ret;
spin_unlock_irqrestore(&proc_comm_lock, flags);
if (LG_ErrorHandler_enable) // check using proc_comm after arm9 crash
return 0;
// if(get_status_hidden_reset()==0 ) {
ret = LGE_ErrorHandler_Main(MODEM_CRASH, error_modem_message);
smsm_reset_modem(ret);
// } else {
// smsm_reset_modem(SMSM_SYSTEM_REBOOT);
// }
while(1)
;
}
/* LGE_CHANGE_E [[email protected]] 2009-07-06 <For Error Handler > */
#endif
}
int msm_proc_comm_oem_multi(unsigned cmd, unsigned *data1, unsigned *data2, unsigned *cmd_parameter, int number)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
unsigned int size;
int ret, index;
smem_oem_cmd_data *cmd_buf;
//Div2-SW2-BSP, JOE HSU,rename smem_mem_type
cmd_buf = (smem_oem_cmd_data *)smem_get_entry(SMEM_ID_VENDOR1, &size);
printk(KERN_INFO "%s: 0x%08x\n", __func__, (unsigned)cmd_buf);
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
// Set the parameter of OEM_CMD1
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
for( index = 0 ; index < number ; index++)
cmd_buf->cmd_data.cmd_parameter[index] = cmd_parameter[index];
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
for (index = 0; index < number; index++) {
cmd_parameter[index] = cmd_buf->return_data.return_value[index];
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag)) {
//waiting
mdelay(100);
printk(KERN_INFO "%s: wait...... 0x%04x\n", __func__, cmd_buf->return_data.check_flag);
}
ret = (cmd_buf->return_data.check_flag & 0x1111);
if(!ret) {
*data2 = cmd_buf->return_data.return_value[0];
}
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
//MTD-BSP-VT-PROC-00+[
int msm_proc_comm_oem(unsigned cmd, unsigned *data1, unsigned *data2, unsigned *cmd_parameter)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
size_t sizeA, sizeB;
smem_oem_cmd_data *cmd_buf;
void* test;
int size;
sizeA=40;
sizeB=64;
cmd_buf = smem_get_entry(SMEM_ID_VENDOR1, &size);
test= (unsigned*)&cmd_buf->cmd_data.cmd_parameter[0];
spin_lock_irqsave(&proc_comm_lock, flags);
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
cmd_buf->cmd_data.check_flag = smem_oem_locked_flag;
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_WRITE)
{
memcpy(test,(const void *)cmd_parameter,sizeA);
}
else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_WRITE)
{
memcpy(test,(const void *)cmd_parameter,sizeB);
}
else if(*data1==SMEM_PROC_COMM_OEM_POWER_OFF)
{
memcpy(test,(const void *)cmd_parameter, SMEM_OEM_CMD_BUF_SIZE*sizeof(int));
}
else
{
cmd_buf->cmd_data.cmd_parameter[0] = *cmd_parameter;
}
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
#if 0
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
#endif
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
//spin_unlock_irqrestore(&proc_comm_lock, flags);
/* read response value, Hanson Lin */
while(!(cmd_buf->return_data.check_flag & smem_oem_unlocked_flag))
{
//waiting
}
ret = (cmd_buf->return_data.check_flag & 0x1111);
if(!ret)
{
if(*data1==SMEM_PROC_COMM_OEM_PRODUCT_ID_READ)
{
memcpy((void *)data2, test,sizeA);
}
else if(*data1==SMEM_PROC_COMM_OEM_TEST_FLAG_READ)
{
memcpy((void *)data2,test,sizeB);
}
else if(*data1==SMEM_PROC_COMM_OEM_NV_READ)
{
memcpy(data2,&cmd_buf->return_data.return_value[0],128);
}
else
{
*data2 = cmd_buf->return_data.return_value[0];
}
}
else
{
/* Get the error code */
if(*data1==SMEM_PROC_COMM_OEM_OTP_PROCESS)
memcpy(data2,&cmd_buf->return_data.return_value[0],128);
}
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
spin_lock_irqsave(&proc_comm_lock, flags);
//LGE_CHANGE_S [[email protected]] 2009-04-01 <For Error Handler>
/* again :*/
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY)) {
goto crash;
}
//LGE_CHANGE_E [[email protected]] 2009-04-01 <For Error Handler>
writel(cmd, base + APP_COMMAND);
writel(data1 ? *data1 : 0, base + APP_DATA1);
writel(data2 ? *data2 : 0, base + APP_DATA2);
notify_other_proc_comm();
//LGE_CHANGE_S [[email protected]] 2009-04-01 <For Error Handler>
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE)) {
goto crash;
}
//LGE_CHANGE_E [[email protected]] 2009-04-01 <For Error Handler>
if (readl(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl(base + APP_DATA1);
if (data2)
*data2 = readl(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
writel(PCOM_CMD_IDLE, base + APP_COMMAND);
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
/* LGE_CHANGE_S [[email protected]] 2009-07-06 <For Error Handler > */
crash:
{
extern char * error_modem_message ;
extern int LG_ErrorHandler_enable;
// extern int get_status_hidden_reset();
int ret;
spin_unlock_irqrestore(&proc_comm_lock, flags);
if (LG_ErrorHandler_enable) // check using proc_comm after arm9 crash
return 0;
// if(get_status_hidden_reset()==0 ) {
ret = LGE_ErrorHandler_Main(MODEM_CRASH, error_modem_message);
smsm_reset_modem(ret);
// } else {
// smsm_reset_modem(SMSM_SYSTEM_REBOOT);
// }
while(1)
;
}
/* LGE_CHANGE_E [[email protected]] 2009-07-06 <For Error Handler > */
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
unsigned pcom_ret; /* FUJITSU:2012-05-24 Add OEM */
spin_lock_irqsave(&proc_comm_lock, flags);
if (msm_proc_comm_disable) {
ret = -EIO;
goto end;
}
again:
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
writel_relaxed(cmd, base + APP_COMMAND);
writel_relaxed(data1 ? *data1 : 0, base + APP_DATA1);
writel_relaxed(data2 ? *data2 : 0, base + APP_DATA2);
/* Make sure the writes complete before notifying the other side */
wmb();
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
#if 0 /* FUJITSU:2012-05-24 Mod OEM start */
if (readl_relaxed(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
#else
pcom_ret = readl_relaxed(base + APP_STATUS);
if (pcom_ret == PCOM_CMD_SUCCESS) {
#endif/* FUJITSU:2012-05-24 Mod OEM end */
if (data1)
*data1 = readl_relaxed(base + APP_DATA1);
if (data2)
*data2 = readl_relaxed(base + APP_DATA2);
ret = 0;
/* FUJITSU:2012-05-24 Add OEM start */
} else if (pcom_ret == PCOM_CMD_FAIL_DURING_EFS_SYNC) {
printk(KERN_ERR "msm: proc_comm: fail during efs sync\n");
ret = -EBUSY;
/* FUJITSU:2012-05-24 Add OEM end */
} else {
ret = -EIO;
}
writel_relaxed(PCOM_CMD_IDLE, base + APP_COMMAND);
switch (cmd) {
case PCOM_RESET_CHIP:
case PCOM_RESET_CHIP_IMM:
case PCOM_RESET_APPS:
msm_proc_comm_disable = 1;
printk(KERN_ERR "msm: proc_comm: proc comm disabled\n");
break;
}
end:
/* Make sure the writes complete before returning */
wmb();
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
EXPORT_SYMBOL(msm_proc_comm);
