type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
includes | #include <linux/errno.h> |
includes | #include <linux/kernel.h> |
includes | #include <linux/major.h> |
includes | #include <linux/module.h> |
includes | #include <linux/pm_runtime.h> |
includes | #include <linux/uaccess.h> |
includes | #include <linux/delay.h> |
includes | #include <linux/msm_mdp.h> |
includes | #include <linux/memblock.h> |
includes | #include <linux/sw_sync.h> |
includes |
#include <mach/iommu_domains.h> |
includes | #include <mach/event_timer.h> |
includes | #include <mach/msm_bus.h> |
includes | #include <mach/scm.h> |
defines |
#define pr_fmt(fmt) "%s: " fmt, __func__ |
defines |
#define VSYNC_PERIOD 16 |
defines | #define BORDERFILL_NDX 0x0BF000BF |
defines | #define CHECK_BOUNDS(offset, size, max_size) \ |
defines |
#define PP_CLK_CFG_OFF 0 |
defines | #define PP_CLK_CFG_ON 1 |
defines |
#define MEM_PROTECT_SD_CTRL 0xF |
defines |
#define INVALID_PIPE_INDEX 0xFFFF |
defines | #define OVERLAY_MAX 10 |
functions | int mdss_mdp_overlay_sd_ctrl(struct msm_fb_data_type *mfd,
unsigned int enable)
{
struct sd_ctrl_req request;
unsigned int resp = -1;
int ret = 0;
pr_debug("sd_ctrl %u\n", enable);
request.enable = enable;
ret = scm_call(SCM_SVC_MP, MEM_PROTECT_SD_CTRL,
&request, sizeof(request), &resp, sizeof(resp));
p... |
functions | int mdss_mdp_overlay_get(struct msm_fb_data_type *mfd,
struct mdp_overlay *req)
{
struct mdss_mdp_pipe *pipe;
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
pipe = mdss_mdp_pipe_get(mdata, req->id);
if (IS_ERR_OR_NULL(pipe)) {
pr_err("invalid pipe ndx=%x\n", req->id);
return pipe ? PTR_ERR(pipe) : -ENOD... |
functions | int mdss_mdp_overlay_req_check(struct msm_fb_data_type *mfd,
struct mdp_overlay *req,
struct mdss_mdp_format_params *fmt)
{
u32 xres, yres;
u32 min_src_size, min_dst_size;
int content_secure;
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
xres = ... |
functions | else if (req->flags & MDP_BWC_EN) {
pr_err("Decimation can't be enabled with BWC\n");
return -EINVAL;
} |
functions | int __mdp_pipe_tune_perf(struct mdss_mdp_pipe *pipe)
{
struct mdss_data_type *mdata = pipe->mixer->ctl->mdata;
struct mdss_mdp_perf_params perf;
int rc;
for (;;) {
rc = mdss_mdp_perf_calc_pipe(pipe, &perf, NULL, true);
if (!rc && (perf.mdp_clk_rate <= mdata->max_mdp_clk_rate))
break;
/*
* if decimati... |
functions | int __mdss_mdp_overlay_setup_scaling(struct mdss_mdp_pipe *pipe)
{
u32 src;
int rc;
src = pipe->src.w >> pipe->horz_deci;
if (pipe->scale.enable_pxl_ext)
return 0;
memset(&pipe->scale, 0, sizeof(struct mdp_scale_data));
rc = mdss_mdp_calc_phase_step(src, pipe->dst.w,
&pipe->scale.phase_step_x[0]);
if (rc ... |
functions | else if (rc) {
pr_err("Horizontal scaling calculation failed=%d! %d->%d\n",
rc, src, pipe->dst.w);
return rc;
} |
functions | else if (rc) {
pr_err("Vertical scaling calculation failed=%d! %d->%d\n",
rc, src, pipe->dst.h);
return rc;
} |
functions | void __mdss_mdp_overlay_set_chroma_sample(
struct mdss_mdp_pipe *pipe)
{
pipe->chroma_sample_v = pipe->chroma_sample_h = 0;
switch (pipe->src_fmt->chroma_sample) {
case MDSS_MDP_CHROMA_H1V2:
pipe->chroma_sample_v = 1;
break;
case MDSS_MDP_CHROMA_H2V1:
pipe->chroma_sample_h = 1;
break;
case MDSS_MDP_CHROM... |
functions | int mdss_mdp_overlay_pipe_setup(struct msm_fb_data_type *mfd,
struct mdp_overlay *req,
struct mdss_mdp_pipe **ppipe)
{
struct mdss_mdp_format_params *fmt;
struct mdss_mdp_pipe *pipe;
struct mdss_mdp_mixer *mixer = NULL;
u32 pipe_type, mixer_mux, len;
struct mdss_overlay_private *mdp5_data = m... |
functions | else if (pipe->pp_cfg.hist_cfg.ops &
MDP_PP_OPS_DISABLE) {
mdss_mdp_hist_stop(pipe->pp_cfg.hist_cfg.block);
} |
functions | int mdss_mdp_overlay_set(struct msm_fb_data_type *mfd,
struct mdp_overlay *req)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int ret;
ret = mutex_lock_interruptible(&mdp5_data->ov_lock);
if (ret)
return ret;
if (!mfd->panel_power_on) {
mutex_unlock(&mdp5_data->ov_lock);
return -EPE... |
functions | else if (req->src.format == MDP_RGB_BORDERFILL) {
req->id = BORDERFILL_NDX;
} |
functions | int mdss_mdp_overlay_get_buf(struct msm_fb_data_type *mfd,
struct mdss_mdp_data *data,
struct msmfb_data *planes,
int num_planes,
u32 flags)
{
int i, rc = 0;
if ((num_planes <= 0) || (num_planes > MAX_PLANES))
return -EINVAL;
mdss_bus_bandwidth_ctrl(1);
memset(data, 0, sizeof(*da... |
functions | int mdss_mdp_overlay_free_buf(struct mdss_mdp_data *data)
{
int i;
mdss_bus_bandwidth_ctrl(1);
for (i = 0; i < data->num_planes && data->p[i].len; i++)
mdss_mdp_put_img(&data->p[i]);
mdss_bus_bandwidth_ctrl(0);
data->num_planes = 0;
return 0;
} |
functions | void __mdss_mdp_overlay_free_list_purge(struct msm_fb_data_type *mfd)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int i;
pr_debug("purging fb%d free list\n", mfd->index);
for (i = 0; i < mdp5_data->free_list_size; i++)
mdss_mdp_overlay_free_buf(&mdp5_data->free_list[i]);
mdp5_data->free_li... |
functions | void __mdss_mdp_overlay_free_list_add(struct msm_fb_data_type *mfd,
struct mdss_mdp_data *buf)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int i;
/* if holding too many buffers free current list */
if (mdp5_data->free_list_size >= MAX_FREE_LIST_SIZE) {
pr_warn("max free list size for fb%d... |
functions | void mdss_mdp_overlay_cleanup(struct msm_fb_data_type *mfd)
{
struct mdss_mdp_pipe *pipe, *tmp;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
bool recovery_mode = false;
LIST_HEAD(destroy_pipes);
mutex_lock(&mfd->lock);
list_for_each_entry_safe(pipe,... |
functions | void __mdss_mdp_handoff_cleanup_pipes(struct msm_fb_data_type *mfd,
u32 type)
{
u32 i, npipes;
struct mdss_mdp_pipe *pipes;
struct mdss_mdp_pipe *pipe;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
switch (type) {
case MDSS_MDP_PIPE_TYPE_VIG:
... |
functions | int mdss_mdp_overlay_start(struct msm_fb_data_type *mfd)
{
int rc;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_ctl *ctl = mdp5_data->ctl;
if (ctl->power_on) {
if (!mdp5_data->mdata->batfet)
mdss_mdp_batfet_ctrl(mdp5_data->mdata, true);
if (!mfd->panel_info->cont_splash_en... |
functions | void mdss_mdp_overlay_update_pm(struct mdss_overlay_private *mdp5_data)
{
ktime_t wakeup_time;
if (!mdp5_data->cpu_pm_hdl)
return;
if (mdss_mdp_display_wakeup_time(mdp5_data->ctl, &wakeup_time))
return;
activate_event_timer(mdp5_data->cpu_pm_hdl, wakeup_time);
} |
functions | int __overlay_queue_pipes(struct msm_fb_data_type *mfd)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_pipe *pipe;
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
struct mdss_mdp_ctl *tmp;
int ret = 0;
list_for_each_entry(pipe, &mdp5_data->pipes_used, used_list) {
struct mdss_mdp... |
functions | else if (ctl->play_cnt == 0 && pipe->front_buf.num_planes) {
pipe->params_changed++;
buf = &pipe->front_buf;
} |
functions | else if (!pipe->params_changed) {
continue;
} |
functions | else if (pipe->front_buf.num_planes) {
buf = &pipe->front_buf;
} |
functions | void __overlay_kickoff_requeue(struct msm_fb_data_type *mfd)
{
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
mdss_mdp_display_commit(ctl, NULL);
mdss_mdp_display_wait4comp(ctl);
__overlay_queue_pipes(mfd);
mdss_mdp_display_commit(ctl, NULL);
mdss_mdp_display_wait4comp(ctl);
} |
functions | int mdss_mdp_overlay_kickoff(struct msm_fb_data_type *mfd,
struct mdp_display_commit *data)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_pipe *pipe;
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
int ret = 0;
int sd_in_pipe = 0;
if (ctl->shared_lock)
mutex_lock(ctl->shared... |
functions | int mdss_mdp_overlay_release(struct msm_fb_data_type *mfd, int ndx)
{
struct mdss_mdp_pipe *pipe;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
u32 pipe_ndx, unset_ndx = 0;
int i, destroy_pipe;
for (i = 0; unset_ndx != ndx && i < MDSS_MDP_MAX_SSPP; i++) {
pipe_ndx = BIT(i);
if (pipe_ndx & nd... |
functions | int mdss_mdp_overlay_unset(struct msm_fb_data_type *mfd, int ndx)
{
int ret = 0;
struct mdss_overlay_private *mdp5_data;
if (!mfd)
return -ENODEV;
mdp5_data = mfd_to_mdp5_data(mfd);
if (!mdp5_data || !mdp5_data->ctl)
return -ENODEV;
ret = mutex_lock_interruptible(&mdp5_data->ov_lock);
if (ret)
return r... |
functions | int __mdss_mdp_overlay_release_all(struct msm_fb_data_type *mfd,
bool release_all)
{
struct mdss_mdp_pipe *pipe;
struct mdss_mdp_rotator_session *rot, *tmp;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
u32 unset_ndx = 0;
int cnt = 0;
int pid = current->tgid;
pr_debug("releasing all resources... |
functions | int mdss_mdp_overlay_play_wait(struct msm_fb_data_type *mfd,
struct msmfb_overlay_data *req)
{
int ret = 0;
if (!mfd)
return -ENODEV;
ret = mfd->mdp.kickoff_fnc(mfd, NULL);
if (!ret)
pr_err("error displaying\n");
return ret;
} |
functions | int mdss_mdp_overlay_queue(struct msm_fb_data_type *mfd,
struct msmfb_overlay_data *req)
{
struct mdss_mdp_pipe *pipe;
struct mdss_mdp_data *src_data;
int ret;
u32 flags;
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
pipe = mdss_mdp_pipe_get(mdata, req->id);
if (IS_ERR_OR_NULL(pipe)) {
pr_err("pipe ... |
functions | void mdss_mdp_overlay_force_cleanup(struct msm_fb_data_type *mfd)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_ctl *ctl = mdp5_data->ctl;
int ret;
pr_debug("forcing cleanup to unset dma pipes on fb%d\n", mfd->index);
/*
* video mode panels require the layer to be unstaged a... |
functions | void mdss_mdp_overlay_force_dma_cleanup(struct mdss_data_type *mdata)
{
struct mdss_mdp_pipe *pipe;
int i;
for (i = 0; i < mdata->ndma_pipes; i++) {
pipe = mdata->dma_pipes + i;
if (!mdss_mdp_pipe_map(pipe)) {
struct msm_fb_data_type *mfd = pipe->mfd;
mdss_mdp_pipe_unmap(pipe);
if (mfd)
mdss_mdp_o... |
functions | int mdss_mdp_overlay_play(struct msm_fb_data_type *mfd,
struct msmfb_overlay_data *req)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int ret = 0;
pr_debug("play req id=%x\n", req->id);
ret = mutex_lock_interruptible(&mdp5_data->ov_lock);
if (ret)
return ret;
if (!mfd->panel_power_on... |
functions | else if (req->id == BORDERFILL_NDX) {
pr_debug("borderfill enable\n");
mdp5_data->borderfill_enable = true;
ret = mdss_mdp_overlay_free_fb_pipe(mfd);
} |
functions | int mdss_mdp_overlay_free_fb_pipe(struct msm_fb_data_type *mfd)
{
struct mdss_mdp_pipe *pipe;
u32 fb_ndx = 0;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
pipe = mdss_mdp_mixer_stage_pipe(mdp5_data->ctl,
MDSS_MDP_MIXER_MUX_LEFT,
MDSS_MDP_STAGE_BASE);
if (pipe)
fb_ndx |= pipe->ndx;
... |
functions | int mdss_mdp_overlay_get_fb_pipe(struct msm_fb_data_type *mfd,
struct mdss_mdp_pipe **ppipe,
int mixer_mux,
struct mdp_overlay *req_ov)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_pipe *pipe;
int ret;
pipe = mdss_mdp_mixer_stage_pipe(mdp5_data->ctl, mixer_mux,
... |
functions | void mdss_mdp_overlay_pan_display(struct msm_fb_data_type *mfd,
struct mdp_overlay *req,
int image_size,
int *pipe_ndx)
{
struct mdss_mdp_data *buf;
struct mdss_mdp_pipe *pipe;
struct fb_info *fbi;
struct mdss_overlay_private *mdp5_data;
u32 offset;
int bpp, ret;
if (!mfd)
return;
fbi = mfd->... |
functions | void mdss_mdp_overlay_handle_vsync(struct mdss_mdp_ctl *ctl,
ktime_t t)
{
struct msm_fb_data_type *mfd = NULL;
struct mdss_overlay_private *mdp5_data = NULL;
if (!ctl) {
pr_err("ctl is NULL\n");
return;
} |
functions | int mdss_mdp_overlay_vsync_ctrl(struct msm_fb_data_type *mfd, int en)
{
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
int rc;
if (!ctl)
return -ENODEV;
if (!ctl->add_vsync_handler || !ctl->remove_vsync_handler)
return -EOPNOTSUPP;
if (!ctl->panel_data->panel_info.cont_splash_enabled
&& !ctl->power_on) {
pr... |
functions | ssize_t dynamic_fps_sysfs_rda_dfps(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t ret;
struct mdss_panel_data *pdata;
struct fb_info *fbi = dev_get_drvdata(dev);
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)fbi->par;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(m... |
functions | ssize_t dynamic_fps_sysfs_wta_dfps(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int dfps, rc = 0;
struct mdss_panel_data *pdata;
struct fb_info *fbi = dev_get_drvdata(dev);
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)fbi->par;
struct mdss_overlay_private *mdp5_... |
functions | else if (dfps > 60) {
pr_err("Unsupported FPS. Configuring to max_fps = 60\n");
dfps = 60;
rc = mdss_mdp_ctl_update_fps(mdp5_data->ctl, dfps);
} |
functions | ssize_t mdss_mdp_vsync_show_event(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *fbi = dev_get_drvdata(dev);
struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)fbi->par;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
u64 vsync_ticks;
int ret;
if (!mdp5_d... |
functions | int mdss_mdp_ad_is_supported(struct msm_fb_data_type *mfd)
{
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
struct mdss_mdp_mixer *mixer;
if (!ctl) {
pr_debug("there is no ctl attached to fb\n");
return 0;
} |
functions | ssize_t mdss_mdp_ad_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct fb_info *fbi = dev_get_drvdata(dev);
struct msm_fb_data_type *mfd = fbi->par;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int ret, state;
state = mdss_mdp_ad_is_supported(mfd) ? mdp5_data->ad_stat... |
functions | ssize_t mdss_mdp_ad_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct fb_info *fbi = dev_get_drvdata(dev);
struct msm_fb_data_type *mfd = fbi->par;
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int ret, ad;
ret = kstrtoint(buf, 10, &ad);
if (ret)... |
functions | int mdss_mdp_hw_cursor_update(struct msm_fb_data_type *mfd,
struct fb_cursor *cursor)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdss_mdp_mixer *mixer;
struct fb_image *img = &cursor->image;
u32 blendcfg;
int off, ret = 0;
if (!mfd->cursor_buf && (cursor->set & FB_CUR_SETIM... |
functions | int mdss_bl_scale_config(struct msm_fb_data_type *mfd,
struct mdp_bl_scale_data *data)
{
int ret = 0;
int curr_bl;
mutex_lock(&mfd->bl_lock);
curr_bl = mfd->bl_level;
mfd->bl_scale = data->scale;
mfd->bl_min_lvl = data->min_lvl;
pr_debug("update scale = %d, min_lvl = %d\n", mfd->bl_scale,
mfd->bl_mi... |
functions | int mdss_mdp_pp_ioctl(struct msm_fb_data_type *mfd,
void __user *argp)
{
int ret;
struct msmfb_mdp_pp mdp_pp;
u32 copyback = 0;
u32 copy_from_kernel = 0;
ret = copy_from_user(&mdp_pp, argp, sizeof(mdp_pp));
if (ret)
return ret;
/* Supprt only MDP register read/write and
exit_dcm in DCM state*/
if (mfd-... |
functions | int mdss_mdp_histo_ioctl(struct msm_fb_data_type *mfd, u32 cmd,
void __user *argp)
{
int ret = -ENOSYS;
struct mdp_histogram_data hist;
struct mdp_histogram_start_req hist_req;
u32 block;
u32 pp_bus_handle;
static int req = -1;
switch (cmd) {
case MSMFB_HISTOGRAM_START:
if (!mfd->panel_power_on)
retur... |
functions | int mdss_fb_set_metadata(struct msm_fb_data_type *mfd,
struct msmfb_metadata *metadata)
{
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
int ret = 0;
if (!ctl)
return -EPERM;
switch (metadata->op) {
case metadata_op_vic:
if (mfd->panel_info)
mfd->panel_in... |
functions | int mdss_fb_get_hw_caps(struct msm_fb_data_type *mfd,
struct mdss_hw_caps *caps)
{
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
caps->mdp_rev = mdata->mdp_rev;
caps->vig_pipes = mdata->nvig_pipes;
caps->rgb_pipes = mdata->nrgb_pipes;
caps->dma_pipes = mdata->ndma_pipes;
if (mdata->has_bwc)
caps->features... |
functions | int mdss_fb_get_metadata(struct msm_fb_data_type *mfd,
struct msmfb_metadata *metadata)
{
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);
int ret = 0;
if (!ctl)
return -EPERM;
switch (metadata->op) {
case metadata_op_frame_rate:
metadata->data.panel_frame_rate... |
functions | int __handle_overlay_prepare(struct msm_fb_data_type *mfd,
struct mdp_overlay_list *ovlist,
struct mdp_overlay *overlays)
{
struct mdss_mdp_pipe *right_plist[MDSS_MDP_MAX_STAGE] = { 0 } |
functions | int __handle_ioctl_overlay_prepare(struct msm_fb_data_type *mfd,
void __user *argp)
{
struct mdp_overlay_list ovlist;
struct mdp_overlay *req_list[OVERLAY_MAX];
struct mdp_overlay *overlays;
int i, ret;
if (copy_from_user(&ovlist, argp, sizeof(ovlist)))
return -EFAULT;
if (ovlist.num_overlays >= OVERLAY_MAX... |
functions | int mdss_mdp_overlay_ioctl_handler(struct msm_fb_data_type *mfd,
u32 cmd, void __user *argp)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
struct mdp_overlay *req = NULL;
int val, ret = -ENOSYS;
struct msmfb_metadata metadata;
switch (cmd) {
case MSMFB_MDP_PP:
ret = mdss_mdp_pp_ioctl... |
functions | int mdss_mdp_overlay_on(struct msm_fb_data_type *mfd)
{
int rc;
struct mdss_overlay_private *mdp5_data;
struct mdss_mdp_ctl *ctl = NULL;
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
mdp5_data = mfd_to_mdp5_data(mfd);
if (!mdp5_data)
return -EINVAL;
if (!mdp5_data->ctl) {
ctl = ... |
functions | int mdss_mdp_overlay_off(struct msm_fb_data_type *mfd)
{
int rc;
struct mdss_overlay_private *mdp5_data;
struct mdss_mdp_mixer *mixer;
int need_cleanup;
if (!mfd)
return -ENODEV;
if (mfd->key != MFD_KEY)
return -EINVAL;
mdp5_data = mfd_to_mdp5_data(mfd);
if (!mdp5_data || !mdp5_data->ctl) {
pr_err("ct... |
functions | int mdss_panel_register_done(struct mdss_panel_data *pdata)
{
if (pdata->panel_info.cont_splash_enabled)
mdss_mdp_footswitch_ctrl_splash(1);
return 0;
} |
functions | int mdss_mdp_overlay_handoff(struct msm_fb_data_type *mfd)
{
int rc = 0;
struct mdss_data_type *mdata = mfd_to_mdata(mfd);
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
int i, j;
u32 reg;
struct mdss_mdp_pipe *pipe = NULL;
struct mdss_mdp_ctl *ctl = NULL;
if (!mdp5_data->ctl) {
ctl = __mdss... |
functions | int mdss_mdp_overlay_splash_image(struct msm_fb_data_type *mfd,
int *pipe_ndx, int splash_event)
{
struct mdp_overlay req;
int rc = 0;
struct fb_info *fbi = NULL;
int image_len = 0;
if (!mfd || !mfd->fbi || !mfd->fbi->screen_base || !pipe_ndx) {
pr_err("Invalid input parameter\n");
return -EINVAL;
} |
functions | else if (splash_event == MDP_REMOVE_SPLASH_OV) {
if (pipe_ndx[0] != INVALID_PIPE_INDEX)
mdss_mdp_overlay_unset(mfd, pipe_ndx[0]);
if (pipe_ndx[1] != INVALID_PIPE_INDEX)
mdss_mdp_overlay_unset(mfd, pipe_ndx[1]);
} |
functions | void __vsync_retire_handle_vsync(struct mdss_mdp_ctl *ctl, ktime_t t)
{
struct msm_fb_data_type *mfd = ctl->mfd;
struct mdss_overlay_private *mdp5_data;
if (!mfd || !mfd->mdp.private1) {
pr_warn("Invalid handle for vsync\n");
return;
} |
functions | void __vsync_retire_work_handler(struct work_struct *work)
{
struct mdss_overlay_private *mdp5_data =
container_of(work, typeof(*mdp5_data), retire_work);
if (!mdp5_data->ctl || !mdp5_data->ctl->mfd)
return;
if (!mdp5_data->ctl->remove_vsync_handler)
return;
__vsync_retire_signal(mdp5_data->ctl->mfd, 1);
} |
functions | void __vsync_retire_signal(struct msm_fb_data_type *mfd, int val)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
mutex_lock(&mfd->mdp_sync_pt_data.sync_mutex);
if (mdp5_data->retire_cnt > 0) {
sw_sync_timeline_inc(mdp5_data->vsync_timeline, val);
mdp5_data->retire_cnt -= min(val, mdp5_data->... |
functions | int __vsync_retire_setup(struct msm_fb_data_type *mfd)
{
struct mdss_overlay_private *mdp5_data = mfd_to_mdp5_data(mfd);
char name[24];
snprintf(name, sizeof(name), "mdss_fb%d_retire", mfd->index);
mdp5_data->vsync_timeline = sw_sync_timeline_create(name);
if (mdp5_data->vsync_timeline == NULL) {
pr_err("cannot... |
functions | int mdss_mdp_overlay_init(struct msm_fb_data_type *mfd)
{
struct device *dev = mfd->fbi->dev;
struct msm_mdp_interface *mdp5_interface = &mfd->mdp;
struct mdss_overlay_private *mdp5_data = NULL;
int rc;
mdp5_interface->on_fnc = mdss_mdp_overlay_on;
mdp5_interface->off_fnc = mdss_mdp_overlay_off;
mdp5_interface-... |
functions | else if (mfd->panel_info->type == MIPI_CMD_PANEL) {
rc = __vsync_retire_setup(mfd);
if (IS_ERR_VALUE(rc)) {
pr_err("unable to create vsync timeline\n");
goto init_fail;
} |
functions | int mdss_mdp_overlay_splash_parse_dt(struct msm_fb_data_type *mfd)
{
struct platform_device *pdev = mfd->pdev;
struct mdss_overlay_private *mdp5_mdata = mfd_to_mdp5_data(mfd);
int len = 0, rc = 0;
u32 offsets[2];
of_find_property(pdev->dev.of_node, "qcom,memblock-reserve", &len);
if (len < 1) {
pr_debug("mem ... |
functions | int mdss_mdp_overlay_fb_parse_dt(struct msm_fb_data_type *mfd)
{
int rc = 0;
struct platform_device *pdev = mfd->pdev;
struct mdss_overlay_private *mdp5_mdata = mfd_to_mdp5_data(mfd);
mdp5_mdata->mixer_swap = of_property_read_bool(pdev->dev.of_node,
"qcom,mdss-mixer-swap");
if (mdp5_mdata->mixer_swap) {
... |
defines | #define MAX_CONSOLE_SAVE_BUFFER 1024 |
defines | #define CONSOLE_HISTORY_FILE "q3history" |
functions | void Field_VariableSizeDraw( field_t *edit, int x, int y, int width, int size, qboolean showCursor,
qboolean noColorEscape ) {
int len;
int drawLen;
int prestep;
int cursorChar;
char str[MAX_STRING_CHARS];
int i;
drawLen = edit->widthInChars - 1; // - 1 so there is always a space for the cursor
len = st... |
functions | it
if ( size == SMALLCHAR_WIDTH ) {
float color[4];
color[0] = color[1] = color[2] = color[3] = 1.0;
SCR_DrawSmallStringExt( x, y, str, color, qfalse, noColorEscape );
} |
functions | cursor
if ( showCursor ) {
if ( (int)( cls.realtime >> 8 ) & 1 ) {
return; // off blink
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.