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;
}
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;
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 (readl_relaxed(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl_relaxed(base + APP_DATA1);
if (data2)
*data2 = readl_relaxed(base + APP_DATA2);
ret = 0;
} 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:
#if 1
/* Do not disable proc_comm when device reset */
#else
msm_proc_comm_disable = 1;
printk(KERN_ERR "msm: proc_comm: proc comm disabled\n");
#endif
break;
}
end:
/* Make sure the writes complete before returning */
wmb();
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;
static unsigned mac1=0x0;
static unsigned mac2=0x0;
int ret;
if((mac1!=0||mac2!=0)&&cmd==PCOM_CUSTOMER_CMD1)
{
*data1=mac1;
*data2=mac2;
printk("zhp Read mac from buffer!\n");
return 0;
}
spin_lock_irqsave(&proc_comm_lock, flags);
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 */
dsb();
notify_other_proc_comm();
if (proc_comm_wait_for(base + APP_COMMAND, PCOM_CMD_DONE))
goto again;
if (readl_relaxed(base + APP_STATUS) == PCOM_CMD_SUCCESS) {
if (data1)
*data1 = readl_relaxed(base + APP_DATA1);
if (data2)
*data2 = readl_relaxed(base + APP_DATA2);
ret = 0;
} else {
ret = -EIO;
}
writel_relaxed(PCOM_CMD_IDLE, base + APP_COMMAND);
/* Make sure the writes complete before returning */
dsb();
spin_unlock_irqrestore(&proc_comm_lock, flags);
if(ret==0&&cmd==PCOM_CUSTOMER_CMD1)
{
mac1=*data1;
mac2=*data2;
printk("zhp Read mac from nv!\n");
}
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
unsigned base = (unsigned)MSM_SHARED_RAM_BASE;
unsigned long flags;
int ret;
#if defined (CONFIG_QSD_OEM_RPC_VERSION_CHECK)
if (version_check && rpc_version_checked == 0)
{
spin_lock_irqsave(&proc_comm_version_lock, flags);
rpc_version_checked = 1;
spin_unlock_irqrestore(&proc_comm_version_lock, flags);
rpc_version_check_func();
}
#endif /* CONFIG_QSD_OEM_RPC_VERSION_CHECK */
spin_lock_irqsave(&proc_comm_lock, flags);
again:
#if defined (CONFIG_QSD_ARM9_CRASH_FUNCTION)
if ((ret = proc_comm_wait_for(base + MDM_STATUS, PCOM_READY)) == -EAGAIN)
goto again;
else if (ret != 0)
goto fail;
#else /* CONFIG_QSD_ARM9_CRASH_FUNCTION */
if (proc_comm_wait_for(base + MDM_STATUS, PCOM_READY))
goto again;
#endif /* CONFIG_QSD_ARM9_CRASH_FUNCTION */
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);
#if defined (CONFIG_QSD_ARM9_CRASH_FUNCTION)
fail:
#endif /* CONFIG_QSD_ARM9_CRASH_FUNCTION */
spin_unlock_irqrestore(&proc_comm_lock, flags);
return ret;
}
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
int ret = -1;
unsigned status;
// dprintf(INFO, "proc_comm(%d,%d,%d)\n",
// cmd, data1 ? *data1 : 0, data2 ? *data2 : 0);
while (readl(MDM_STATUS) != PCOM_READY) {
/* XXX check for A9 reset */
}
if (data1)
writel(*data1, APP_DATA1);
if (data2)
writel(*data2, APP_DATA2);
/*
* As per the specs write data, cmd, interrupt for
* proc comm processing
*/
writel(cmd, APP_COMMAND);
// dprintf(INFO, "proc_comm tx\n");
notify_other_proc_comm();
while (readl(APP_COMMAND) != PCOM_CMD_DONE) {
/* XXX check for A9 reset */
}
status = readl(APP_STATUS);
// dprintf(INFO, "proc_comm status %d\n", status);
if (status != PCOM_CMD_FAIL) {
if (data1)
*data1 = readl(APP_DATA1);
if (data2)
*data2 = readl(APP_DATA2);
ret = 0;
/*
* Write command idle to indicate non HLOS that
* apps has finished reading the status & data
* of proc comm command
*/
writel(PCOM_CMD_IDLE, APP_COMMAND);
}
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)
{
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;
}
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;
}
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;
}
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);
//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(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_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 */
}
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;
}
//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_wince(struct msm_dex_command * in, unsigned *out)
{
unsigned base = (unsigned)(MSM_SHARED_RAM_BASE + 0xfc100);
unsigned long flags;
unsigned timeout;
unsigned status;
unsigned num;
unsigned base_cmd, base_status;
spin_lock_irqsave(&proc_comm_lock, flags);
DDEX("waiting for modem; command=0x%02x data=0x%x", in->cmd, in->data);
// Store original cmd byte
base_cmd = in->cmd & 0xff;
// Write only lowest byte
writeb(base_cmd, base + PC_COMMAND);
// If we have data to pass, add 0x100 bit and store the data
if ( in->has_data )
{
writel(readl(base + PC_COMMAND) | DEX_HAS_DATA, base + PC_COMMAND);
writel(in->data, base + PC_DATA);
} else {
writel(readl(base + PC_COMMAND) & ~DEX_HAS_DATA, base + PC_COMMAND);
writel(0, base + PC_DATA);
}
// Increment last serial counter
num = readl(base + PC_SERIAL) + 1;
writel(num, base + PC_SERIAL);
DDEX("command and data sent (cntr=0x%x) ...", num);
// Notify ARM9 with int6
notify_other_proc_comm();
// Wait for response... XXX: check irq stat?
timeout = TIMEOUT;
while ( --timeout && readl(base + PC_SERIAL_CHECK) != num )
udelay(1);
if ( ! timeout )
{
printk(KERN_WARNING "%s: DEX cmd timed out. status=0x%x, A2Mcntr=%x, M2Acntr=%x\n",
__func__, readl(base + PC_STATUS), num, readl(base + PC_SERIAL_CHECK));
goto end;
}
DDEX("command result status = 0x%08x", readl(base + PC_STATUS));
// Read status of command
status = readl(base + PC_STATUS);
writeb(0, base + PC_STATUS);
base_status = status & 0xff;
DDEX("status new = 0x%x; status base = 0x%x",
readl(base + PC_STATUS), base_status);
if ( base_status == base_cmd )
{
if ( status & DEX_STATUS_FAIL )
{
DDEX("DEX cmd failed; status=%x, result=%x",
readl(base + PC_STATUS),
readl(base + PC_DATA_RESULT));
writel(readl(base + PC_STATUS) & ~DEX_STATUS_FAIL, base + PC_STATUS);
}
else if ( status & DEX_HAS_DATA )
{
writel(readl(base + PC_STATUS) & ~DEX_HAS_DATA, base + PC_STATUS);
if (out)
*out = readl(base + PC_DATA_RESULT);
DDEX("DEX output data = 0x%x",
readl(base + PC_DATA_RESULT));
}
} else {
printk(KERN_WARNING "%s: DEX Code not match! a2m[0x%x], m2a[0x%x], a2m_num[0x%x], m2a_num[0x%x]\n",
__func__, base_cmd, base_status, num, readl(base + PC_SERIAL_CHECK));
}
end:
writel(0, base + PC_DATA_RESULT);
writel(0, base + PC_STATUS);
spin_unlock_irqrestore(&proc_comm_lock, flags);
return 0;
}
//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);
#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;
}
