type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | UINT32 DISP_GetActiveHeight(void)
{
disp_drv_init_context();
if(lcm_params)
{
printk("[wwy]lcm_parms->active_height = %d\n",lcm_params->active_height);
return lcm_params->active_height;
} |
functions | UINT32 DISP_GetActiveWidth(void)
{
disp_drv_init_context();
if(lcm_params)
{
printk("[wwy]lcm_parms->active_width = %d\n",lcm_params->active_width);
return lcm_params->active_width;
} |
functions | DISP_STATUS DISP_SetScreenBpp(UINT32 bpp)
{
ASSERT(bpp != 0);
if( bpp != 16 && \
bpp != 24 && \
bpp != 32 && \
1 )
{
DISP_LOG("DISP_SetScreenBpp error, not support %d bpp\n", bpp);
return DISP_STATUS_ERROR;
} |
functions | UINT32 DISP_GetScreenBpp(void)
{
return disp_fb_bpp;
} |
functions | DISP_STATUS DISP_SetPages(UINT32 pages)
{
ASSERT(pages != 0);
disp_fb_pages = pages;
DISP_LOG("DISP_SetPages %d pages\n", pages);
return DISP_STATUS_OK;
} |
functions | UINT32 DISP_GetPages(void)
{
u32 isHwSupportTripleBuffer = 0;
if(is_page_set==FALSE)
{
isHwSupportTripleBuffer = get_devinfo_with_index(3) & 0x00000007;
if(isHwSupportTripleBuffer == 0x1)
{
printk("[K]DISP_GetPages: hw support!\n");
disp_fb_pages = 3;
} |
functions | BOOL DISP_IsDirectLinkMode(void)
{
return (-1 != direct_link_layer) ? TRUE : FALSE;
} |
functions | BOOL DISP_IsInOverlayMode(void)
{
return is_overlaying;
} |
functions | UINT32 DISP_GetFBRamSize(void)
{
return ALIGN_TO(DISP_GetScreenWidth(), 32) *
ALIGN_TO(DISP_GetScreenHeight(), 32) *
((DISP_GetScreenBpp() + 7) >> 3) *
DISP_GetPages();
} |
functions | UINT32 DISP_GetVRamSize(void)
{
// Use a local static variable to cache the calculated vram size
//
static UINT32 vramSize = 0;
if (0 == vramSize)
{
disp_drv_init_context();
///get framebuffer size
vramSize = DISP_GetFBRamSize();
///get DXI working buffer size
vramSize += disp_drv->get... |
functions | UINT32 DISP_GetVRamSizeBoot(char *cmdline)
{
static UINT32 vramSize = 0;
if(vramSize)
{
return vramSize;
} |
functions | PANEL_COLOR_FORMAT DISP_GetPanelColorFormat(void)
{
disp_drv_init_context();
return (disp_drv->get_panel_color_format) ?
(disp_drv->get_panel_color_format()) :
DISP_STATUS_NOT_IMPLEMENTED;
} |
functions | UINT32 DISP_GetPanelBPP(void)
{
PANEL_COLOR_FORMAT fmt;
disp_drv_init_context();
if(disp_drv->get_panel_color_format == NULL)
{
return DISP_STATUS_NOT_IMPLEMENTED;
} |
functions | UINT32 DISP_GetOutputBPPforDithering(void)
{
disp_drv_init_context();
return (disp_drv->get_dithering_bpp) ?
(disp_drv->get_dithering_bpp()) :
DISP_STATUS_NOT_IMPLEMENTED;
} |
functions | DISP_STATUS DISP_Config_Overlay_to_Memory(unsigned int mva, int enable)
{
// int ret = 0;
// struct disp_path_config_mem_out_struct mem_out = {0} |
functions | DISP_STATUS DISP_Config_Wfd_Overlay_to_Memory(unsigned int mva, int enable)
{
// int ret = 0;
if(enable)
{
MemOutConfig.outFormat = WDMA_OUTPUT_FORMAT_UYVY;///WDMA_OUTPUT_FORMAT_YUY2;
MemOutConfig.enable = 1;
MemOutConfig.dstAddr = mva;
MemOutConfig.srcROI.x = 0;
MemOutConfig.srcROI.y = 0;
MemOutConfig.... |
functions | DISP_STATUS HDMI_Config_Overlay_to_Memory(unsigned int mva, int enable, unsigned int moutFormat)
{
// int ret = 0;
// struct disp_path_config_mem_out_struct mem_out = {0} |
functions | DISP_STATUS DISP_Capture_Framebuffer( unsigned int pvbuf, unsigned int bpp, unsigned int is_early_suspended )
{
unsigned int mva;
unsigned int ret = 0;
M4U_PORT_STRUCT portStruct;
DISP_FUNC();
disp_drv_init_context();
disp_module_clock_on(DISP_MODULE_WDMA1, "Screen Capture");
if (is_early_suspended)... |
functions | endif
if(deconfigWdma)
{
portStruct.ePortID = M4U_PORT_WDMA1; //hardware port ID, defined in M4U_PORT_ID_ENUM
portStruct.Virtuality = 0;
portStruct.Security = 0;
portStruct.domain = 0; //domain : 0 1 2 3
portStruct.Distance = 1;
portStruct.Direction = 0;
... |
functions | DISP_STATUS DISP_Capture_Videobuffer(unsigned int pvbuf, unsigned int bpp, unsigned int video_rotation)
{
DISP_FUNC();
if (down_interruptible(&sem_update_screen)) {
printk("ERROR: Can't get sem_update_screen in DISP_Capture_Videobuffer()\n");
return DISP_STATUS_ERROR;
} |
functions | DISP_STATUS DISP_ConfigImmediateUpdate(BOOL enable)
{
disp_drv_init_context();
if(enable == TRUE)
{
LCD_TE_Enable(FALSE);
} |
functions | BOOL DISP_IsImmediateUpdate(void)
{
return is_immediateupdate;
} |
functions | DISP_STATUS DISP_FMDesense_Query()
{
if(LCM_TYPE_DBI == lcm_params->type){//DBI
return (DISP_STATUS)LCD_FMDesense_Query();
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
return (DISP_STATUS)DPI_FMDesense_Query();
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
return (DISP_STATUS)DSI_FMDesense_Query();
} |
functions | DISP_STATUS DISP_FM_Desense(unsigned long freq)
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
DISP_LOG("ERROR: Can't get sem_update_screen in DISP_FM_Desense()\n");
return DISP_STATUS_ERROR;
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
DISP_LOG("DISP_FM_Desense():DPI interface\n");
DPI_CHECK_RET(DPI_FM_Desense(freq));
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
DISP_LOG("DISP_FM_Desense():DSI interface\n");
DSI_CHECK_RET(DSI_FM_Desense(freq));
} |
functions | DISP_STATUS DISP_Reset_Update()
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
DISP_LOG("ERROR: Can't get sem_update_screen in DISP_Reset_Update()\n");
return DISP_STATUS_ERROR;
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
DISP_LOG("DISP_Reset_Update():DPI interface\n");
DPI_CHECK_RET(DPI_Reset_CLK());
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
DISP_LOG("DISP_Reset_Update():DSI interface\n");
DSI_CHECK_RET(DSI_Reset_CLK());
} |
functions | DISP_STATUS DISP_Get_Default_UpdateSpeed(unsigned int *speed)
{
DISP_STATUS ret = DISP_STATUS_OK;
if(LCM_TYPE_DBI == lcm_params->type){//DBI
DISP_LOG("DISP_Get_Default_UpdateSpeed():DBI interface\n");
LCD_CHECK_RET(LCD_Get_Default_WriteCycle(ctrl_if, speed));
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
DISP_LOG("DISP_Get_Default_UpdateSpeed():DPI interface\n");
DPI_CHECK_RET(DPI_Get_Default_CLK(speed));
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
DISP_LOG("DISP_Get_Default_UpdateSpeed():DSI interface\n");
DSI_CHECK_RET(DSI_Get_Default_CLK(speed));
} |
functions | DISP_STATUS DISP_Get_Current_UpdateSpeed(unsigned int *speed)
{
DISP_STATUS ret = DISP_STATUS_OK;
if(LCM_TYPE_DBI == lcm_params->type){//DBI
DISP_LOG("DISP_Get_Current_UpdateSpeed():DBI interface\n");
LCD_CHECK_RET(LCD_Get_Current_WriteCycle(ctrl_if, speed));
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
DISP_LOG("DISP_Get_Current_UpdateSpeed():DPI interface\n");
DPI_CHECK_RET(DPI_Get_Current_CLK(speed));
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
DISP_LOG("DISP_Get_Current_UpdateSpeed():DSI interface\n");
DSI_CHECK_RET(DSI_Get_Current_CLK(speed));
} |
functions | DISP_STATUS DISP_Change_Update(unsigned int speed)
{
DISP_STATUS ret = DISP_STATUS_OK;
if (down_interruptible(&sem_update_screen)) {
DISP_LOG("ERROR: Can't get sem_update_screen in DISP_Change_Update()\n");
return DISP_STATUS_ERROR;
} |
functions | else if(LCM_TYPE_DPI == lcm_params->type){//DPI
DISP_LOG("DISP_Change_Update():DPI interface\n");
DPI_CHECK_RET(DPI_Change_CLK(speed));
} |
functions | else if(LCM_TYPE_DSI == lcm_params->type){// DSI
DISP_LOG("DISP_Change_Update():DSI interface\n");
DSI_CHECK_RET(DSI_Change_CLK(speed));
} |
functions | DISP_STATUS DISP_InitM4U()
{
LCD_InitM4U();
if(LCM_TYPE_DPI == lcm_params->type){
// DPI_InitM4U(); //DPI not use m4u currently
} |
functions | DISP_STATUS DISP_ConfigAssertLayerMva()
{
unsigned int mva;
ASSERT(dal_layerPA);
LCD_CHECK_RET(LCD_AllocUIMva(dal_layerPA, &mva, DAL_GetLayerSize()));
DISP_LOG("DAL Layer PA = DAL_layerPA = 0x%x, MVA = 0x%x\n", dal_layerPA, mva);
LCD_CHECK_RET(LCD_LayerSetAddress(ASSERT_LAYER, mva));
return DISP_STATUS_OK;... |
functions | DISP_STATUS DISP_AllocUILayerMva(unsigned int pa, unsigned int *mva, unsigned int size)
{
LCD_CHECK_RET(LCD_AllocUIMva(pa, mva, size));
DISP_LOG("UI Layer PA = 0x%x, MVA = 0x%x\n", pa, *mva);
if(LCM_TYPE_DPI == lcm_params->type){ //dpi buffer
unsigned int i,dpi_mva;
UINT32 dpi_size = DISP_GetScreenWidth()*DI... |
functions | DISP_STATUS DISP_AllocOverlayMva(unsigned int va, unsigned int *mva, unsigned int size)
{
LCD_CHECK_RET(LCD_AllocOverlayMva(va, mva, size));
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_DeallocMva(unsigned int va, unsigned int mva, unsigned int size)
{
LCD_DeallocMva(va, mva, size);
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_M4U_On(BOOL enable)
{
LCD_M4U_On(enable);
return DISP_STATUS_OK;
} |
functions | DISP_STATUS DISP_DumpM4U(void)
{
LCD_DumpM4U();
return DISP_STATUS_OK;
} |
functions | BOOL DISP_EsdCheck(void)
{
BOOL result = FALSE;
disp_drv_init_context();
MMProfileLogEx(MTKFB_MMP_Events.EsdCheck, MMProfileFlagPulse, 0x10, 0);
if(lcm_drv->esd_check == NULL && disp_drv->esd_check == NULL)
{
return FALSE;
} |
functions | BOOL DISP_EsdRecoverCapbility(void)
{
if(!disp_drv_init_context())
return FALSE;
if((lcm_drv->esd_check && lcm_drv->esd_recover) || (lcm_params->dsi.lcm_ext_te_monitor) || (lcm_params->dsi.lcm_int_te_monitor))
{
return TRUE;
} |
functions | BOOL DISP_EsdRecover(void)
{
BOOL result = FALSE;
DISP_LOG("DISP_EsdRecover enter");
if(lcm_drv->esd_recover == NULL)
{
return FALSE;
} |
functions | long DISP_GetLCMIndex(void)
{
return u4IndexOfLCMList;
} |
functions | DISP_STATUS DISP_PrepareSuspend(void)
{
if(lcm_params->type==LCM_TYPE_DSI && lcm_params->dsi.mode != CMD_MODE)
{
DSI_SetMode(CMD_MODE);
} |
functions | DISP_STATUS DISP_GetLayerInfo(DISP_LAYER_INFO *pLayer)
{
int id = pLayer->id;
mutex_lock(&OverlaySettingMutex);
pLayer->curr_en = captured_layer_config[id].layer_en;
pLayer->next_en = cached_layer_config[id].layer_en;
pLayer->hw_en = realtime_layer_config[id].layer_en;
pLayer->curr_idx = capture... |
includes |
#include <epan/packet.h> |
includes | #include <epan/exceptions.h> |
includes | #include <epan/prefs.h> |
includes | #include <epan/reassemble.h> |
includes | #include <epan/show_exception.h> |
functions | void
gssapi_reassembly_init(void)
{
reassembly_table_init(&gssapi_reassembly_table,
&addresses_reassembly_table_functions);
} |
functions | gint
gssapi_oid_equal(gconstpointer k1, gconstpointer k2)
{
const char *key1 = (const char *)k1;
const char *key2 = (const char *)k2;
return strcmp(key1, key2) == 0;
} |
functions | guint
gssapi_oid_hash(gconstpointer k)
{
const char *key = (const char *)k;
guint hash = 0, i;
for (i = 0; key[i]; i++)
hash += key[i];
return hash;
} |
functions | void
gssapi_init_oid(const char *oid, int proto, int ett, dissector_handle_t handle,
dissector_handle_t wrap_handle, const gchar *comment)
{
char *key = g_strdup(oid);
gssapi_oid_value *value = (gssapi_oid_value *)g_malloc(sizeof(*value));
value->proto = find_protocol_by_id(proto);
value->ett = ett;
value->hand... |
functions | int
dissect_gssapi_work(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
gboolean is_verifier)
{
proto_item *volatile item;
proto_tree *volatile subtree;
volatile int return_offset = 0;
gssapi_conv_info_t *volatile gss_info;
gssapi_oid_value *oidvalue;
dissector_handle_t handle;
conversation_t *convers... |
functions | else if( pinfo->gssapi_encrypted_tvb ) {
return_offset = call_dissector(ntlmssp_data_only_handle,
tvb_new_subset_remaining(pinfo->gssapi_encrypted_tvb, 0),
pinfo, subtree);
pinfo->gssapi_data_encrypted = TRUE;
} |
functions | void
dissect_gssapi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
dissect_gssapi_work(tvb, pinfo, tree, FALSE);
} |
functions | int
dissect_gssapi_verf(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
return dissect_gssapi_work(tvb, pinfo, tree, TRUE);
} |
functions | void
proto_register_gssapi(void)
{
static hf_register_info hf[] = {
{ &hf_gssapi_oid,
{ "OID", "gss-api.OID", FT_STRING, BASE_NONE,
NULL, 0, "This is a GSS-API Object Identifier", HFILL } |
functions | int
wrap_dissect_gssapi(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di _U_, guint8 *drep _U_)
{
tvbuff_t *auth_tvb;
auth_tvb = tvb_new_subset_remaining(tvb, offset);
dissect_gssapi(auth_tvb, pinfo, tree);
return tvb_length_remaining(tvb, offset);
} |
functions | int
wrap_dissect_gssapi_verf(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di _U_, guint8 *drep _U_)
{
tvbuff_t *auth_tvb;
auth_tvb = tvb_new_subset_remaining(tvb, offset);
return dissect_gssapi_verf(auth_tvb, pinfo, tree, NULL);
} |
functions | void
proto_reg_handoff_gssapi(void)
{
dissector_handle_t gssapi_handle;
ntlmssp_handle = find_dissector("ntlmssp");
ntlmssp_payload_handle = find_dissector("ntlmssp_payload");
ntlmssp_verf_handle = find_dissector("ntlmssp_verf");
ntlmssp_data_only_handle = find_dissector("ntlmssp_data_only");
spnego_krb5_wrap_ha... |
includes |
#include <bsp.h> |
includes | #include <page_table.h> |
functions | void page_table_init(
rtems_configuration_table *config_table
)
{
unsigned char j1; /* State of J1 jumpers */
register unsigned long dtt0; /* Content of dtt0 */
register unsigned long cacr; /* Content of cacr */
/*
* Logical base addr = 0x00 map starting at 0x00000000
* Logical... |
functions | void page_table_teardown( void )
{
__asm__ volatile ("movec %0,%%tc\n\t"
"movec %0,%%cacr\n\t"
"cpusha %%bc\n\t"
"movec %0,%%dtt0\n\t"
"movec %0,%%itt0\n\t"
"movec %0,%%dtt1\n\t"
"movec %0,%%itt1"
:: "d" (0) );
} |
includes |
#include <linux/kernel.h> |
includes | #include <linux/slab.h> |
includes | #include <linux/cpu.h> |
includes | #include <linux/sysfs.h> |
includes | #include <linux/cpufreq.h> |
includes | #include <linux/module.h> |
includes | #include <linux/jiffies.h> |
includes | #include <linux/percpu.h> |
includes | #include <linux/kobject.h> |
includes | #include <linux/spinlock.h> |
includes | #include <linux/notifier.h> |
includes | #include <linux/sort.h> |
includes | #include <linux/err.h> |
includes | #include <linux/of.h> |
includes | #include <linux/sched.h> |
includes | #include <asm/cputime.h> |
structs | struct cpufreq_stats {
unsigned int cpu;
unsigned int total_trans;
unsigned long long last_time;
unsigned int max_state;
unsigned int state_num;
unsigned int last_index;
u64 *time_in_state;
unsigned int *freq_table;
#ifdef CONFIG_CPU_FREQ_STAT_DETAILS
unsigned int *trans_table;
#endif
}; |
structs | struct all_cpufreq_stats {
unsigned int state_num;
cputime64_t *time_in_state;
unsigned int *freq_table;
}; |
structs | struct cpufreq_power_stats {
unsigned int state_num;
unsigned int *curr;
unsigned int *freq_table;
}; |
structs | struct all_freq_table {
unsigned int *freq_table;
unsigned int table_size;
}; |
structs | struct cpufreq_stats_attribute {
struct attribute attr;
ssize_t(*show) (struct cpufreq_stats *, char *);
}; |
functions | int cpufreq_stats_update(unsigned int cpu)
{
struct cpufreq_stats *stat;
struct all_cpufreq_stats *all_stat;
unsigned long long cur_time;
cur_time = get_jiffies_64();
spin_lock(&cpufreq_stats_lock);
stat = per_cpu(cpufreq_stats_table, cpu);
all_stat = per_cpu(all_cpufreq_stats, cpu);
if (!stat) {
spin_unlock... |
functions | ssize_t show_total_trans(struct cpufreq_policy *policy, char *buf)
{
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
if (!stat)
return 0;
return sprintf(buf, "%d\n",
per_cpu(cpufreq_stats_table, stat->cpu)->total_trans);
} |
functions | ssize_t show_time_in_state(struct cpufreq_policy *policy, char *buf)
{
ssize_t len = 0;
int i;
struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, policy->cpu);
if (!stat)
return 0;
cpufreq_stats_update(stat->cpu);
for (i = 0; i < stat->state_num; i++) {
len += sprintf(buf + len, "%u %llu\n", stat->freq... |
functions | int get_index_all_cpufreq_stat(struct all_cpufreq_stats *all_stat,
unsigned int freq)
{
int i;
if (!all_stat)
return -1;
for (i = 0; i < all_stat->state_num; i++) {
if (all_stat->freq_table[i] == freq)
return i;
} |
functions | void acct_update_power(struct task_struct *task, cputime_t cputime) {
struct cpufreq_power_stats *powerstats;
struct cpufreq_stats *stats;
unsigned int cpu_num, curr;
if (!task)
return;
cpu_num = task_cpu(task);
powerstats = per_cpu(cpufreq_power_stats, cpu_num);
stats = per_cpu(cpufreq_stats_table, cpu_num);... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.