static int rkusb_read_log( struct rkusb_dev *dev )
{
switch ( DEV_FUNC(dev) ) {
case FUNC_LOG_GETLUNS: /* first int:luns , next int:sizeof log_buffer */
{
int num_size[2];
check_xtranfs_len( 8 );
num_size[0] = dev->luns;
num_size[1] = sizeof(struct log_buffer );
rkusb_normal_data_xfer_onetime( dev , num_size );
}
return 0;
case FUNC_LOG_GETSTRUCT: /* report all log info */
{
// check_xtranfs_len( sizeof dev->log ); sizeof dev->log may change.
if( !check_log_valid( dev ) )
break;
rkusb_normal_data_xfer_onetime( dev , dev->log );
}
return 0;
case FUNC_LOG_INIT:
{
int i = DEV_LUN( dev );
#if (LOG_NUM>2)
static int rkusb_shell_initlog( struct log_buffer *p );
if( i == LUN_SHELL ) {
if( rkusb_shell_initlog( &dev->log[i] ) ) {
return RKUSB_CB_FAILD_CSW;
}
}
#endif
dev->log[i].getlog(&dev->log[i].va_start , &dev->log[i].offset , &dev->log[i].total_len);
}
return RKUSB_CB_OK_CSW;
case FUNC_LOG_UNINIT:
{
if( DEV_LUN(dev) == LUN_SHELL ){
dev->log[DEV_LUN(dev)].property &= ~LOG_PROT_MAYWRITE;
}
}
return RKUSB_CB_OK_CSW;
case FUNC_LOG_OFFLEN: /* read new log info , first int=start offset , next int=len */
{
int offset_len[2];
if( !check_log_valid( dev ) )
break;
check_xtranfs_len( 8 );
dev->log[DEV_LUN(dev)].getlog_start_length( &dev->log[DEV_LUN(dev)].offset , &dev->log[DEV_LUN(dev)].len );
offset_len[0] = dev->log[DEV_LUN(dev)].offset;
offset_len[1] = dev->log[DEV_LUN(dev)].len;
rkusb_normal_data_xfer_onetime( dev , offset_len );
}
return 0;
default:
break;
}
return -1;
}
static int rkusb_read_sdram( struct rkusb_dev *dev )
{
int pid;
if( __rkusb_read_enable() ) {
if( DEV_OFFSET(dev) >= 0xc0000000 ) {
rkusb_normal_data_xfer( dev , NULL );
return RKUSB_CB_OK_NONE;
}
pid = DEV_PID( dev );
if( pid ) {
dev->slave_task = find_task_by_pid( pid );
if(!dev->slave_task )
return RKUSB_CB_FAILD;
//rk28printk("%s::pid=%d,task=%s\n" , __func__ , pid , dev->slave_task->comm );
} else {
dev->slave_task = current ;
}
if( dev->slave_task == current ){
char *dest = __rkusb_rwbuffer_start( dev );
int n = copy_from_user((void*)dest, (const void __user*)DEV_OFFSET(dev), DEV_LENGTH(dev));
if( !n ) {
rkusb_normal_data_xfer_onetime( dev , dest );
return RKUSB_CB_OK_NONE;
} else
return RKUSB_CB_FAILD;
}
rkusb_wakeup_thread( dev );
return RKUSB_CB_OK_NONE;
}
return RKUSB_CB_FAILD;
}
static int rkusb_get_lastcmd_result( struct rkusb_dev *dev )
{
if( DEV_LENGTH(dev) != RKUSB_RESULT_LEN )
return RKUSB_CB_FAILD;
rkusb_normal_data_xfer_onetime( dev , &dev->cr );
return RKUSB_CB_OK_NONE;
}
static int rkusb_get_symbol( struct rkusb_dev *dev )
{
switch ( DEV_FUNC(dev) ) {
case FUNC_GSYM_KERNEL:
return rkusb_get_kernel_symbols( dev );
case FUNC_GSYM_GETTASKS:
return rksub_get_sym_tasks( dev );
case FUNC_GSYM_GETTASKVM:
return rkusb_get_task_mm( dev );
case FUNC_GSYM_PROFILE:
{
char * buf = __rkusb_rwbuffer_start(dev);
PROFILE_INFO pe;
pe.size = sizeof( pe );
pe.npc = profile_check( buf );
pe.buf = (unsigned long)buf;
pe.now = ktime_to_ns( ktime_get() );
rk28printk("%s::profile n=%ld\n" , __func__ , pe.npc );
rkusb_normal_data_xfer_onetime( dev , &pe );
return 0;
}
default:
break;
}
return RKUSB_CB_FAILD;
}
static int rkusb_get_kernel_symbols( struct rkusb_dev *dev )
{
struct __kernel_symbol ks;
ks.size = sizeof( ks );
ks._stext = _stext;
ks._text = _text;
ks._etext = _etext;
ks._data = __data_start ; //_data;
ks._edata = _edata;
ks.__bss_start = __bss_start;
ks._end = _end;
ks.kallsyms_start = (unsigned char*)kallsyms_addresses;
ks.total_syms_size = (unsigned char*)__start_rodata - ks.kallsyms_start;
ks._kallsyms_num_syms = kallsyms_num_syms;
ks._kallsyms_addresses = (unsigned long*)kallsyms_addresses;
ks._kallsyms_markers = (unsigned long*)kallsyms_markers;
ks._kallsyms_names = (unsigned char*)kallsyms_names;
ks._kallsyms_token_index = (unsigned short*)kallsyms_token_index;
ks._kallsyms_token_table = (unsigned char*)kallsyms_token_table;
rkusb_normal_data_xfer_onetime( dev , &ks );
rk28printk("symbols addres=0x%p,names=0x%p,syms=0x%lx\n",
ks._kallsyms_addresses,ks._kallsyms_names,ks._kallsyms_num_syms);
return RKUSB_CB_OK_NONE;
}
/* get verion , return size and sdram addr(lba) */
static int rkusb_ucmd_get_version( struct rkusb_dev *dev )
{
int r = RKUSB_CB_OK_NONE;
unsigned int off_len[2];
switch( DEV_LUN(dev) ) {
case LUN_USCM_VER_LOADER:
{
off_len[1] = kld_get_tag_data( 0X524B0002 , (void**)&off_len );
}
break;
case LUN_USCM_VER_KERNEL:
off_len[0] = (unsigned int)linux_banner;
off_len[1] = strlen(linux_banner)+1;
break;
case LUN_USCM_VER_ANDROID:
off_len[0] = (unsigned int)rockchip_version;
off_len[1] = strlen(rockchip_version)+1;
break;
case LUN_USCM_VER_OPENCORE:
default:
r = RKUSB_CB_FAILD;
break;
}
if( r == RKUSB_CB_OK_NONE )
rkusb_normal_data_xfer_onetime(dev , off_len );
return r;
}
static int rkusb_xfer_read_filesize( struct rkusb_dev *dev )
{
FILE_INFO *fi = rkusb_xfer_cmd_valid( dev );
if( !fi || DEV_LENGTH(dev) < sizeof(unsigned long ) ) {
rkusb_xfer_error( fi , dev , -FI_ERR_CLEAR);
return RKUSB_CB_FAILD;
}
rk28printk("read file size =0x%lx,trans len=%d\n" , fi->file_size , DEV_LENGTH(dev))
rkusb_normal_data_xfer_onetime(dev , &fi->file_size);
return RKUSB_CB_OK_NONE;
}
/* lab : = pid .*/
static int rkusb_get_task_mm( struct rkusb_dev *dev )
{
TASK_VAM tm;
struct task_struct *p;
int pid = DEV_OFFSET(dev);
if( pid == 0 )
p = current ;
else {
p = find_task_by_pid( pid );
if( !p )
return RKUSB_CB_FAILD;
}
__rksub_copy_task_vma( dev , &tm , p , __rkusb_rwbuffer_start( dev ));
rkusb_normal_data_xfer_onetime( dev , &tm );
return RKUSB_CB_OK_NONE;
}
/*
* 20100108,HSL@RK,new r/w sdram code. if not kernel space,read at thread one time.
*/
static int rkusb_do_read_sdram( struct rkusb_dev *dev )
{
int r;
char *dest = __rkusb_rwbuffer_start( dev );
#if 0
r= copy_from_user(dest , (void __user *) DEV_OFFSET( dev ),
DEV_LENGTH(dev) );
#else
r = access_process_vm(dev->slave_task, DEV_OFFSET( dev ), dest , DEV_LENGTH(dev) , 0);
#endif
rk28printk("%s::read task=%s,lba=0x%x,len=%d\n" , __func__ , dev->slave_task->comm,
DEV_OFFSET( dev ) , DEV_LENGTH(dev));
if( r != DEV_LENGTH(dev)) {
rk28printk("get user data error,task=%s,lba=0x%x,r=0x%x\n" , dev->slave_task->comm,DEV_OFFSET( dev ) , r);
}
rkusb_normal_data_xfer_onetime( dev , dest );
return RKUSB_CB_OK_NONE;
}
static int rksub_get_sym_tasks( struct rkusb_dev *dev )
{
ALL_TASK at;
TASK_INFO *ti;
struct task_struct *g, *p;
int buf_full = 0;
int tn , tntoal;
ti = (TASK_INFO*)__rkusb_rwbuffer_start( dev );
at.size = sizeof( at );
at.start_ts = ti;
at.ti_size = sizeof(*ti);
tntoal = 0;
tn = 0;
read_lock(&tasklist_lock);
do_each_thread(g, p) {
if( !buf_full ) {
if( ti+1 > (TASK_INFO*)__rkusb_rwbuffer_end( dev ) ) {
buf_full = 1;
tn = tntoal;
} else {
__rksub_copy_task_info( ti , p );
ti++;
}
}
tntoal ++;
} while_each_thread(g, p);
read_unlock(&tasklist_lock);
if( !tn )
tn = tntoal;
at.task_num = tn;
at.task_total_num = tntoal;
at.now = ktime_to_ns(ktime_get() );
rkusb_normal_data_xfer_onetime( dev , &at );
return RKUSB_CB_OK_NONE;
}
static int rkusb_usb_command( struct rkusb_dev *dev )
{
int r = RKUSB_CB_FAILD;
rk28printk("%s::func=%d,len=%d\n" , __func__ , DEV_FUNC(dev),DEV_LENGTH(dev));
switch( DEV_FUNC(dev) ) {
case FUNC_UCMD_DEVREADY:
r = RKUSB_CB_OK_CSW;
break;
case FUNC_UCMD_DISCONNECTMSC:
rk28_msc_switch( 0 );
r = RKUSB_CB_OK_CSW;
break;
case FUNC_UCMD_SYSTEMINFO:
{
unsigned int off_len[2];
off_len[0] = (unsigned int)system_type;
off_len[1] = strlen(system_type)+1;
rkusb_normal_data_xfer_onetime(dev , off_len );
r = RKUSB_CB_OK_NONE;
}
break;
case FUNC_UCMD_RESTART:
rk28printk("get restart cmd,lun=%d\n" , DEV_LUN(dev));
if( DEV_LUN(dev) == 0 ) { /* normal restart */
rk28_restart(0);
} else if( DEV_LUN(dev) == 1 ) { /* to loader rkusb */
rk28_restart(1);
}
break;
case FUNC_UCMD_GETVERSION:
r = rkusb_ucmd_get_version( dev );
break;
case FUNC_UCMD_GETCHIPINFO:
{
unsigned int off_len[2];
off_len[1] = kld_get_tag_data( 0X524B0000 , (void**)&off_len );
rkusb_normal_data_xfer_onetime(dev , off_len );
r = RKUSB_CB_OK_NONE;
}
break;
case FUNC_UCMD_GETSN:
{
unsigned int off_len[2];
off_len[1] = kld_get_tag_data( 0X524B0006 , (void**)&off_len );
rkusb_normal_data_xfer_onetime(dev , off_len );
r = RKUSB_CB_OK_NONE;
}
break;
case FUNC_UCMD_DEBUGINFO:
{
RKDEBUG_INFO *dbi = DEV_FAST_ALLOC(dev,RKDEBUG_INFO);
dbi->size = sizeof(RKDEBUG_INFO);
dbi->adb_support = adb_support;
dbi->dbg_level = __rkusb_write_enable(dev)?2:(__rkusb_read_enable(dev)?1:0);
dbi->tr_length = dev->req_buf_length;
dbi->save_length = dev->buf_length;
dbi->save_buf = (unsigned long)__rkusb_rwbuffer_start(dev);
if( dev->fsg )
strcpy(dbi->cur_device,"msc");
else
strcpy(dbi->cur_device,"adb");
strcpy( dbi->cur_version,RKUSB_KVERSION);
#if 0
dbi->cmds[0]=K_FW_SDRAM_READ_10;
dbi->cmds[1]=K_FW_SDRAM_WRITE_10;
dbi->cmds[2]=K_FW_TRACE;
dbi->cmds[3]=K_FW_GETLOG;
dbi->cmds[4]=K_FW_FUNCALL;
dbi->cmds[5]=K_FW_GETSYMB;
dbi->cmds[6]=K_FW_GETRESULT;
dbi->cmds[7]=K_FW_USBCMD;
#endif
rkusb_normal_data_xfer_onetime(dev , dbi );
r = RKUSB_CB_OK_NONE;
}
break;
case FUNC_UCMD_OPENADB:
{
/* lun:0 close,1: open */
adb_function_enable(DEV_LUN(dev));
usb_vbus_status = 0; /* force to reconnect! */
r = RKUSB_CB_OK_CSW;
}
break;
default:
break ;
}
return r;
}
