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; }