int slate_send_log_data(struct ats_mtc_key_log_type* p_ats_mtc_key_log)
{
unsigned short log_len;
key_msg_type * pRsp = NULL;
touch_msg_type * pRsp1 = NULL;
//switch (log->id) {
switch (p_ats_mtc_key_log->log_id) {
case ICD_LOG_ID_KEY:
printk(KERN_INFO "MTC_ETA_LOG_ID_KEY\n");
log_len = sizeof(key_msg_type);
pRsp = (key_msg_type *)diagpkt_alloc(DIAG_EXT_MSG_F, log_len);
if(!pRsp)
{
printk(KERN_ERR "[SLATE] packet for key logging response failed.\n");
return 0;
}
//slatekey=make_key_log_packet((unsigned long)log->data.key.key_code,(unsigned long)log->data.key.hold);
slatekey=make_key_log_packet((unsigned long)p_ats_mtc_key_log->y_code,(unsigned long)p_ats_mtc_key_log->x_hold);
printk(KERN_INFO "[SLATE] got keycode .\n");
memcpy(pRsp,&slatekey,log_len);
printk(KERN_INFO "[SLATE] key.cmd_cod =%d, func <%s>\n",slatekey.cmd_code, __func__);
diagpkt_commit(pRsp);
printk(KERN_INFO "[SLATE] diagbuf_encode_and_send_pkt returned! SEND finish.\n");
printk(KERN_INFO "[SLATE] diagpkt_free end.\n");
break;
case ICD_LOG_ID_TOUCH:
printk(KERN_INFO "MTC_ETA_LOG_ID_TOUCH\n");
log_len = sizeof(touch_msg_type);
pRsp1 = (touch_msg_type *)diagpkt_alloc(DIAG_EXT_MSG_F, log_len);
//slatetouch=make_touch_log_packet(log->data.touch.x,log->data.touch.y,log->data.touch.action);
slatetouch=make_touch_log_packet((unsigned long)p_ats_mtc_key_log->x_hold,
(unsigned long)p_ats_mtc_key_log->y_code, (unsigned long)p_ats_mtc_key_log->action);
memcpy(pRsp1,&slatetouch,log_len);
diagpkt_commit(pRsp1);
printk(KERN_INFO "[SLATE] touch msg commit complete.\n");
break;
default:
break;
}
printk(KERN_INFO "[SLATE] slate_send_log_data end.\n");
return 0;
}
PACKED void * diag_userDataBackUp_handler(PACKED void *req_pkt_ptr,uint16 pkt_len)
{
udbp_req_type *req_ptr = (udbp_req_type *) req_pkt_ptr;
udbp_rsp_type *rsp_ptr = NULL;
const rsp_len = sizeof( udbp_rsp_type );
rsp_ptr = (udbp_rsp_type *) diagpkt_alloc (DIAG_USET_DATA_BACKUP, rsp_len);
if(rsp_ptr)
{
switch(req_ptr->header.sub_cmd)
{
case SRD_INIT_OPERATION :
diag_SRD_Init(req_ptr,rsp_ptr);
break;
case USERDATA_BACKUP_REQUEST :
diag_userDataBackUp_entrySet(req_ptr,rsp_ptr);
break;
case GET_DOWNLOAD_INFO :
break;
case EXTRA_NV_OPERATION :
#ifdef LG_FW_SRD_EXTRA_NV
diag_extraNv_entrySet(req_ptr,rsp_ptr);
#endif
break;
case PRL_OPERATION :
#ifdef LG_FW_SRD_PRL
diag_PRL_entrySet(req_ptr,rsp_ptr);
#endif
break;
default :
rsp_ptr = (void *) diagpkt_err_rsp (DIAG_BAD_PARM_F, req_ptr, pkt_len);
break;
}
}
/* Execption*/
if (rsp_ptr == NULL){
return NULL;
}
if (!diagcomm_status()){
diagpkt_free(rsp_ptr);
return NULL;
}
return rsp_ptr;
}
return FALSE;
}
return true;
}
PACK (void *)LGE_WebDload_SRD(PACK (void *)req_pkt_ptr, uint16 pkg_len)
{
uint16 rsp_len =0;
byte *req_ptr = (byte*) req_pkt_ptr;
byte *rsp_ptr = NULL;
static char exe_flag=0;
rsp_len = sizeof(diag_webdload_rsp_type); /* 무조건 이 size로 보낸다는 가정임 */
rsp_ptr = (byte*)diagpkt_alloc(DIAG_WEBDLOAD_COMMON_F , rsp_len);
if( rsp_ptr == NULL )
return rsp_ptr;
if(exe_flag == 0) /* one-time execution */
{
if(diag_WebDL_SRD_Init()== TRUE) /* once intializing eMMC */
{
exe_flag = 1;/* once normal operation */
}
else
{/* eMMc initial operation ERROR */
return rsp_ptr;
}
}
if(gpio_get_value(86) == GPIO_SLIDE_OPEN) // hall ic
return 0;
else
return 1;
}
PACK (void *)LGF_KeyPress (
PACK (void *)req_pkt_ptr, /* pointer to request packet */
uint16 pkt_len ) /* length of request packet */
{
DIAG_HS_KEY_F_req_type *req_ptr = (DIAG_HS_KEY_F_req_type *) req_pkt_ptr;
DIAG_HS_KEY_F_rsp_type *rsp_ptr;
unsigned int keycode = 0;
const int rsp_len = sizeof( DIAG_HS_KEY_F_rsp_type );
rsp_ptr = (DIAG_HS_KEY_F_rsp_type *) diagpkt_alloc( DIAG_HS_KEY_F, rsp_len );
if (!rsp_ptr)
return 0;
if((req_ptr->magic1 == 0xEA2B7BC0) && (req_ptr->magic2 == 0xA5B7E0DF))
{
rsp_ptr->magic1 = req_ptr->magic1;
rsp_ptr->magic2 = req_ptr->magic2;
rsp_ptr->key = 0xff; //ignore byte key code
rsp_ptr->ext_key = req_ptr->ext_key;
keycode = LGF_KeycodeTrans((word) req_ptr->ext_key);
}
else
{
rsp_ptr->key = req_ptr->key;
/*===========================================================================
FUNCTION REX_DIAG_COREDUMP_HANDLER
DESCRIPTION
Forces a core dump
============================================================================*/
PACKED void * rex_diag_coredump_handler(
PACKED void *in_req_ptr,
word pkt_len
)
{
DIAG_SUBSYS_REX_COREDUMP_F_req_type *req_ptr;
DIAG_SUBSYS_REX_COREDUMP_F_rsp_type *rsp_ptr;
req_ptr = (DIAG_SUBSYS_REX_COREDUMP_F_req_type *) in_req_ptr;
/* Verify that the length passed in and the action specified are
** valid.
*/
if ( pkt_len != sizeof(DIAG_SUBSYS_REX_COREDUMP_F_req_type) )
{
return diagpkt_err_rsp(
DIAG_BAD_LEN_F,
req_ptr,
sizeof(DIAG_SUBSYS_REX_COREDUMP_F_req_type)
);
}
rsp_ptr = (DIAG_SUBSYS_REX_COREDUMP_F_rsp_type *)
diagpkt_alloc(
diagpkt_get_cmd_code( req_ptr ),
sizeof(DIAG_SUBSYS_REX_COREDUMP_F_rsp_type)
);
if ( rsp_ptr == NULL )
{
/* Allocation failed, and diagpkt_err_rsp will fail as well.
** So just return NULL.
*/
return NULL;
}
(void)memcpy(
(void*)rsp_ptr,
(void*)req_ptr,
sizeof(diagpkt_subsys_header_type)
);
#ifdef FEATURE_REX_CORE_DUMP
switch( req_ptr->action )
{
case 1:
rex_jettison_core();
break;
case 2:
rex_log_core_dump( __LINE__, __FILE__, "CORE_DUMP: %d %d %d", 1, 2, 3 );
break;
case 3:
ERR_FATAL( "REX CORE DUMP TEST",0,0,0 );
break;
}
#endif
return (void *) rsp_ptr;
} /* END rex_diag_coredump_handler */
/*===========================================================================
FUNCTION REX_DIAG_CODECOVERAGE_HANDLER
DESCRIPTION
This function handles the request to start or stop collection of code
coverage information.
============================================================================*/
PACKED void * rex_diag_codecoverage_handler(
PACKED void *req_ptr,
word pkt_len
)
{
DIAG_SUBSYS_REX_CODECOVERAGE_F_req_type *codecoverage_req_ptr;
DIAG_SUBSYS_REX_CODECOVERAGE_F_rsp_type *codecoverage_rsp_ptr;
codecoverage_req_ptr = (DIAG_SUBSYS_REX_CODECOVERAGE_F_req_type *) req_ptr;
/* Verify that the length passed in and the action specified are
** valid.
*/
if ( pkt_len != sizeof(DIAG_SUBSYS_REX_CODECOVERAGE_F_req_type) )
{
return diagpkt_err_rsp(
DIAG_BAD_LEN_F,
codecoverage_req_ptr,
sizeof(DIAG_SUBSYS_REX_CODECOVERAGE_F_req_type)
);
}
if( ( codecoverage_req_ptr->action != 1 ) &&
( codecoverage_req_ptr->action != 2 ) )
{
return diagpkt_err_rsp(
DIAG_BAD_PARM_F,
codecoverage_req_ptr,
sizeof(DIAG_SUBSYS_REX_CODECOVERAGE_F_req_type)
);
}
codecoverage_rsp_ptr = (DIAG_SUBSYS_REX_CODECOVERAGE_F_rsp_type *)
diagpkt_alloc(
diagpkt_get_cmd_code( req_ptr ),
sizeof(DIAG_SUBSYS_REX_CODECOVERAGE_F_rsp_type)
);
if ( codecoverage_rsp_ptr == NULL )
{
/* Allocation failed, and diagpkt_err_rsp will fail as well.
** So just return NULL.
*/
return NULL;
}
switch( codecoverage_req_ptr->action )
{
case 1:
rex_codecoverage_enable( );
codecoverage_rsp_ptr->status = 1;
break;
case 2:
rex_codecoverage_disable( );
codecoverage_rsp_ptr->status = 1;
break;
default:
/* This should never happen.
*/
codecoverage_rsp_ptr->status = 0;
break;
}
return (void *) codecoverage_rsp_ptr;
} /* END rex_diag_codecoverage_handler */
/*===========================================================================
FUNCTION REX_DIAG_TASKPROFILE_HANDLER
DESCRIPTION
This function handles the request to start or stop program counter
profiling.
action = 1 -> enable task profiling
action = 2 -> disable task profiling
============================================================================*/
PACKED void * rex_diag_taskprofile_handler(
PACKED void *req_ptr,
uint16 pkt_len
)
{
DIAG_SUBSYS_REX_TASKPROFILE_F_req_type *taskprofile_req_ptr;
DIAG_SUBSYS_REX_TASKPROFILE_F_rsp_type *taskprofile_rsp_ptr;
taskprofile_req_ptr = (DIAG_SUBSYS_REX_TASKPROFILE_F_req_type *) req_ptr;
/* Verify that the length passed in and the action specified are
** valid.
*/
/*
if ( pkt_len != sizeof(DIAG_SUBSYS_REX_TASKPROFILE_F_req_type) )
{
return diagpkt_err_rsp(
DIAG_BAD_LEN_F,
taskprofile_req_ptr,
sizeof(DIAG_SUBSYS_REX_TASKPROFILE_F_req_type)
);
}
*/
if( ( taskprofile_req_ptr->action == 0 ) ||
( taskprofile_req_ptr->action > 3 ) )
{
return diagpkt_err_rsp(
DIAG_BAD_PARM_F,
taskprofile_req_ptr,
sizeof(DIAG_SUBSYS_REX_TASKPROFILE_F_req_type)
);
}
taskprofile_rsp_ptr = (DIAG_SUBSYS_REX_TASKPROFILE_F_rsp_type *)
diagpkt_alloc(
diagpkt_get_cmd_code( req_ptr ),
sizeof(DIAG_SUBSYS_REX_TASKPROFILE_F_rsp_type)
);
if ( taskprofile_rsp_ptr == NULL )
{
/* Allocation failed, and diagpkt_err_rsp will fail as well.
** So just return NULL.
*/
return NULL;
}
(void)memcpy(
(void*)taskprofile_rsp_ptr,
(void*)taskprofile_req_ptr,
sizeof(diagpkt_subsys_header_type)
);
switch( taskprofile_req_ptr->action )
{
#ifdef FEATURE_REX_PROFILE
case 1:
MSG_HIGH( "PROF - ENABLE",0,0,0 );
rex_enable_task_profile(
taskprofile_req_ptr->sys_period,
taskprofile_req_ptr->task_period,
taskprofile_req_ptr->tasks_per_period
);
taskprofile_rsp_ptr->status = 1;
break;
#endif
#ifdef FEATURE_REX_PROFILE
case 2:
MSG_HIGH( "PROF - DISABLE",0,0,0 );
rex_disable_task_profile();
taskprofile_rsp_ptr->status = 1;
break;
#endif
#ifdef FEATURE_REX_PROFILE
case 3:
rextp_log_per_task_profile();
break;
#endif
default:
taskprofile_rsp_ptr->status = 0;
break;
}
return (void *) taskprofile_rsp_ptr;
} /* rex_diag_taskprofile_handler */
DIAG_SMS_TEST_TYPE_IMS_WMS_MO = 0x09,
DIAG_MMS_TEST_TYPE_CONFMSG = 0x0A,
DIAG_MMS_TEST_TYPE_LOG = 0x10,
DIAG_SMS_TEST_KEYPROCESS
}diagSmsTestType;
PACK (void *)LGF_MsgTest (
PACK (void *)req_pkt, /* pointer to request packet */
uint16 pkt_len ) /* length of request packet */
{
diag_sms_mode_rsp_type *rsp;
byte *req_ptr = (byte *) req_pkt;
byte smsTestType;
const unsigned int rsp_len = sizeof( diag_sms_mode_rsp_type );
rsp = (diag_sms_mode_rsp_type *)diagpkt_alloc (DIAG_SMS_TEST_F, rsp_len);
memcpy(&smsTestType, req_ptr + 1, 1);
rsp->sub_cmd_code = 0;
rsp->ret_stat_code = 0;
rsp->sms_mode_rsp.retvalue = 0;
switch(smsTestType)
{
case DIAG_SMS_TEST_TYPE_L2_PAGING_CHANNEL_WITH_CRC: // Layer2 SMS Page LOG with CRC
case DIAG_SMS_TEST_TYPE_L2_TRAFFIC_CHANNEL_WITH_CRC: // Layer2 SMS Traffic LOG with CRC
case DIAG_SMS_TEST_TYPE_L3: // Layer3 Normal Messagae
case DIAG_SMS_TEST_TYPE_VOICEMAIL: // VoiceMail Messagae
unifiedmsgtool_do_send_to_arm9((void*)req_ptr, (void*)rsp);
JNIEXPORT void JNICALL Java_com_qti_diagservices_DiagJNIInterface_getNextCommand
(JNIEnv *env, jclass cls) {
jclass dataClass = env->GetObjectClass(gDiagCommandObject);
sem_wait(&diagCommand_ready);
pthread_mutex_lock(&commandList_lock);
pthread_mutex_unlock(&commandList_lock);
return;
}
PACK(void *) android_diag_handler (PACK(void *)req_pkt, uint16 pkt_len)
{
LOGD("android_diag_handler called!");
/* TODO: Decode diag req_pkt */
void *rsp_pkt = diagpkt_alloc(DIAG_CONTROL_F, pkt_len);
if(rsp_pkt) {
memcpy(rsp_pkt, req_pkt, pkt_len);
}
diag_callback_handler("reboot");
return rsp_pkt;
}
static const diagpkt_user_table_entry_type android_diag_handler_tbl[] =
{
{DIAG_CONTROL_F, DIAG_CONTROL_F, android_diag_handler},
};
jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
JNIEnv *env;
static struct diagcmd_dev *diagpdev;
extern PACK(void *) diagpkt_alloc (diagpkt_cmd_code_type code, unsigned int length);
extern PACK(void *) diagpkt_free (PACK(void *)pkt);
extern void srd_send_to_arm9( void* pReq, void *pRsp);
PACK (void *)LGF_SRD (
PACK (void *)req_pkt_ptr, /* pointer to request packet */
uint16 pkt_len ) /* length of request packet */
{
srd_req_type *req_ptr = (srd_req_type *) req_pkt_ptr;
srd_rsp_type *rsp_ptr;
unsigned int rsp_len;
diagpdev = diagcmd_get_dev();
rsp_len = sizeof(srd_rsp_type);
rsp_ptr = (srd_rsp_type *)diagpkt_alloc(DIAG_SRD_F, rsp_len);
if (!rsp_ptr)
return 0;
printk(KERN_INFO "[SRD] cmd_code : [0x%X], sub_cmd : [0x%X] --> goto MODEM through oem rapi\n",req_ptr->header.cmd_code, req_ptr->header.sub_cmd);
printk(KERN_INFO "[SRD] backup : [0x%X], class : [0x%X] --> goto MODEM through oem rapi\n",req_ptr->req_data.do_dl_entry.backup_used, req_ptr->req_data.do_dl_entry.backup_used);
srd_send_to_arm9((void*)req_ptr, (void*)rsp_ptr);
return (rsp_ptr);
}
EXPORT_SYMBOL(LGF_SRD);
