type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | int mdss_mdp_parse_dt_video_intf(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
u32 count;
u32 *offsets;
int rc;
count = mdss_mdp_parse_dt_prop_len(pdev, "qcom,mdss-intf-off");
if (count == 0)
return -EINVAL;
offsets = kzalloc(sizeof(u32) * count, GFP_KERNEL);
if... |
functions | int mdss_mdp_update_smp_map(struct platform_device *pdev,
const u32 *data, int len, int pipe_cnt,
struct mdss_mdp_pipe *pipes)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
int i, j, k;
u32 cnt, mmb;
len /= sizeof(u32);
for (i = 0, k = 0; i < len; k++) {
struct mdss_mdp_pipe *pipe = NULL;
... |
functions | int mdss_mdp_parse_dt_smp(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
u32 num;
u32 data[2];
int rc, len;
const u32 *arr;
num = mdss_mdp_parse_dt_prop_len(pdev, "qcom,mdss-smp-data");
/*
* This property is optional for targets with fix pixel ram. Rest
* must pro... |
functions | void mdss_mdp_parse_dt_fudge_factors(struct platform_device *pdev,
char *prop_name, struct mdss_fudge_factor *ff)
{
int rc;
u32 data[2] = {1, 1} |
functions | int mdss_mdp_parse_dt_prefill(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
struct mdss_prefill_data *prefill = &mdata->prefill_data;
int rc;
rc = of_property_read_u32(pdev->dev.of_node,
"qcom,mdss-prefill-outstanding-buffer-bytes",
&prefill->ot_bytes);
if (rc) {
... |
functions | void mdss_mdp_parse_vbif_qos(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
int rc;
mdata->npriority_lvl = mdss_mdp_parse_dt_prop_len(pdev,
"qcom,mdss-vbif-qos-rt-setting");
if (mdata->npriority_lvl == MDSS_VBIF_QOS_REMAP_ENTRIES) {
mdata->vbif_rt_qos = kzalloc(size... |
functions | void mdss_mdp_parse_max_bw_array(const u32 *arr,
struct mdss_max_bw_settings *max_bw_settings, int count)
{
int i;
for (i = 0; i < count; i++) {
max_bw_settings->mdss_max_bw_mode = be32_to_cpu(arr[i*2]);
max_bw_settings->mdss_max_bw_val = be32_to_cpu(arr[(i*2)+1]);
max_bw_settings++;
} |
functions | void mdss_mdp_parse_max_bandwidth(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
struct mdss_max_bw_settings *max_bw_settings;
int max_bw_settings_cnt = 0;
const u32 *max_bw;
max_bw = of_get_property(pdev->dev.of_node, "qcom,max-bw-settings",
&max_bw_settings_cnt);
... |
functions | int mdss_mdp_parse_dt_misc(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
u32 data, slave_pingpong_off;
const char *wfd_data;
int rc;
struct property *prop = NULL;
rc = of_property_read_u32(pdev->dev.of_node, "qcom,mdss-rot-block-size",
&data);
mdata->rot_block_size... |
functions | int mdss_mdp_parse_dt_ad_cfg(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
u32 *ad_offsets = NULL;
int rc;
mdata->nad_cfgs = mdss_mdp_parse_dt_prop_len(pdev, "qcom,mdss-ad-off");
if (mdata->nad_cfgs == 0) {
mdata->ad_cfgs = NULL;
return 0;
} |
functions | int mdss_mdp_parse_dt_ppb_off(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
u32 len, index;
const u32 *arr;
arr = of_get_property(pdev->dev.of_node, "qcom,mdss-ppb-off", &len);
if (arr) {
mdata->nppb = len / sizeof(u32);
mdata->ppb = devm_kzalloc(&mdata->pdev->dev,
... |
functions | int mdss_mdp_parse_dt_bus_scale(struct platform_device *pdev)
{
int rc;
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
rc = of_property_read_u32(pdev->dev.of_node, "qcom,msm-bus,num-paths",
&mdata->axi_port_cnt);
if (rc) {
pr_err("Error. qcom,msm-bus,num-paths prop not found.rc=%d\n",
rc);
ret... |
functions | int mdss_mdp_parse_dt_handler(struct platform_device *pdev,
char *prop_name, u32 *offsets, int len)
{
int rc;
rc = of_property_read_u32_array(pdev->dev.of_node, prop_name,
offsets, len);
if (rc) {
pr_err("Error from prop %s : u32 array read\n", prop_name);
return -EINVAL;
} |
functions | int mdss_mdp_parse_dt_prop_len(struct platform_device *pdev,
char *prop_name)
{
int len = 0;
of_find_property(pdev->dev.of_node, prop_name, &len);
if (len < 1) {
pr_info("prop %s : doesn't exist in device tree\n",
prop_name);
return 0;
} |
functions | void mdss_mdp_batfet_ctrl(struct mdss_data_type *mdata, int enable)
{
int ret;
if (!mdata->batfet_required)
return;
if (!mdata->batfet) {
if (enable) {
mdata->batfet = devm_regulator_get(&mdata->pdev->dev,
"batfet");
if (IS_ERR_OR_NULL(mdata->batfet)) {
pr_debug("unable to get batfet reg. rc=%d\n... |
functions | bool mdss_is_ready(void)
{
return mdss_mdp_get_mdata() ? true : false;
} |
functions | int mdss_panel_get_boot_cfg(void)
{
int rc;
if (!mdss_res || !mdss_res->pan_cfg.init_done)
return -EPROBE_DEFER;
if (mdss_res->pan_cfg.lk_cfg)
rc = 1;
else
rc = 0;
return rc;
} |
functions | int mdss_mdp_wait_for_xin_halt(u32 xin_id, bool is_vbif_nrt)
{
void __iomem *vbif_base;
u32 status;
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
u32 idle_mask = BIT(xin_id);
int rc;
vbif_base = is_vbif_nrt ? mdata->vbif_nrt_io.base :
mdata->vbif_io.base;
rc = readl_poll_timeout(vbif_base + MMSS_VBI... |
functions | bool force_on_xin_clk(u32 bit_off, u32 clk_ctl_reg_off, bool enable)
{
u32 val;
u32 force_on_mask;
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
bool clk_forced_on = false;
force_on_mask = BIT(bit_off);
val = readl_relaxed(mdata->mdp_base + clk_ctl_reg_off);
clk_forced_on = !(force_on_mask & val);
if ... |
functions | void apply_dynamic_ot_limit(u32 *ot_lim,
struct mdss_mdp_set_ot_params *params)
{
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
u32 res;
if (!is_dynamic_ot_limit_required(mdata->mdp_rev))
return;
res = params->width * params->height;
pr_debug("w:%d h:%d rot:%d yuv:%d wb:%d res:%d\n",
params->width, ... |
functions | else if (res <= 3840 * 2160) {
if (params->is_rot && params->is_yuv)
*ot_lim = 8;
else
*ot_lim = 16;
} |
functions | u32 get_ot_limit(u32 reg_off, u32 bit_off,
struct mdss_mdp_set_ot_params *params)
{
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
u32 ot_lim = 0;
u32 is_vbif_nrt, val;
if (mdata->default_ot_wr_limit &&
(params->reg_off_vbif_lim_conf == MMSS_VBIF_WR_LIM_CONF))
ot_lim = mdata->default_ot_wr_limit;
else ... |
functions | void mdss_mdp_set_ot_limit(struct mdss_mdp_set_ot_params *params)
{
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
u32 ot_lim;
u32 reg_off_vbif_lim_conf = (params->xin_id / 4) * 4 +
params->reg_off_vbif_lim_conf;
u32 bit_off_vbif_lim_conf = (params->xin_id % 4) * 8;
bool is_vbif_nrt = mdss_mdp_is_vbif_nrt(... |
functions | int mdss_mdp_cx_ctrl(struct mdss_data_type *mdata, int enable)
{
int rc = 0;
if (!mdata->vdd_cx)
return rc;
if (enable && !mdata->vdd_cx_en) {
rc = regulator_set_voltage(
mdata->vdd_cx,
RPM_REGULATOR_CORNER_SVS_SOC,
RPM_REGULATOR_CORNER_SUPER_TURBO);
if (rc < 0)
goto vreg_set_voltage_fail;
... |
functions | else if (!enable && mdata->vdd_cx_en) {
pr_debug("Disabling CX power rail\n");
rc = regulator_disable(mdata->vdd_cx);
if (rc) {
pr_err("Failed to disable regulator.\n");
return rc;
} |
functions | void mdss_mdp_footswitch_ctrl(struct mdss_data_type *mdata, int on)
{
int ret;
int active_cnt = 0;
bool disable_cx = false;
if (!mdata->fs)
return;
if (on) {
if (!mdata->fs_ena) {
pr_debug("Enable MDP FS\n");
ret = regulator_enable(mdata->fs);
if (ret)
pr_warn("Footswitch failed to enable\n");
... |
functions | int mdss_mdp_secure_display_ctrl(unsigned int enable)
{
struct sd_ctrl_req {
unsigned int enable;
} |
functions | int mdss_mdp_suspend_sub(struct mdss_data_type *mdata)
{
mdata->suspend_fs_ena = mdata->fs_ena;
mdss_mdp_footswitch_ctrl(mdata, false);
pr_debug("suspend done fs=%d\n", mdata->suspend_fs_ena);
return 0;
} |
functions | int mdss_mdp_resume_sub(struct mdss_data_type *mdata)
{
if (mdata->suspend_fs_ena)
mdss_mdp_footswitch_ctrl(mdata, true);
pr_debug("resume done fs=%d\n", mdata->suspend_fs_ena);
return 0;
} |
functions | int mdss_mdp_pm_suspend(struct device *dev)
{
struct mdss_data_type *mdata;
mdata = dev_get_drvdata(dev);
if (!mdata)
return -ENODEV;
dev_dbg(dev, "display pm suspend\n");
return mdss_mdp_suspend_sub(mdata);
} |
functions | int mdss_mdp_pm_resume(struct device *dev)
{
struct mdss_data_type *mdata;
mdata = dev_get_drvdata(dev);
if (!mdata)
return -ENODEV;
dev_dbg(dev, "display pm resume\n");
/*
* It is possible that the runtime status of the mdp device may
* have been active when the system was suspended. Reset the runtime
... |
functions | int mdss_mdp_suspend(struct platform_device *pdev, pm_message_t state)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
if (!mdata)
return -ENODEV;
dev_dbg(&pdev->dev, "display suspend\n");
return mdss_mdp_suspend_sub(mdata);
} |
functions | int mdss_mdp_resume(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
if (!mdata)
return -ENODEV;
dev_dbg(&pdev->dev, "display resume\n");
return mdss_mdp_resume_sub(mdata);
} |
functions | int mdss_mdp_runtime_resume(struct device *dev)
{
struct mdss_data_type *mdata = dev_get_drvdata(dev);
bool device_on = true;
if (!mdata)
return -ENODEV;
dev_dbg(dev, "pm_runtime: resuming. active overlay cnt=%d\n",
atomic_read(&mdata->active_intf_cnt));
/* do not resume panels when coming out of idle power ... |
functions | int mdss_mdp_runtime_idle(struct device *dev)
{
struct mdss_data_type *mdata = dev_get_drvdata(dev);
if (!mdata)
return -ENODEV;
dev_dbg(dev, "pm_runtime: idling...\n");
return 0;
} |
functions | void mdss_mdp_hist_irq_set_mask(u32 irq)
{
u32 mask, enabled_irq;
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
unsigned long flag;
spin_lock_irqsave(&mdata->hist_intr.lock, flag);
enabled_irq = mdata->hist_intr.curr;
/* Do not enable irq for which hist_enable not called */
if (!(enabled_irq & irq)) {
... |
functions | void mdss_mdp_hist_irq_unset_mask(u32 irq)
{
u32 mask, enabled_irq;
struct mdss_data_type *mdata = mdss_mdp_get_mdata();
unsigned long flag;
spin_lock_irqsave(&mdata->hist_intr.lock, flag);
enabled_irq = mdata->hist_intr.curr;
/* Do not disable irq for which hist_enable not called */
if (!(enabled_irq & irq)) ... |
functions | int mdss_mdp_runtime_suspend(struct device *dev)
{
struct mdss_data_type *mdata = dev_get_drvdata(dev);
bool device_on = false;
if (!mdata)
return -ENODEV;
dev_dbg(dev, "pm_runtime: suspending. active overlay cnt=%d\n",
atomic_read(&mdata->active_intf_cnt));
if (mdata->clk_ena) {
pr_err("MDP suspend failed\... |
functions | int mdss_mdp_remove(struct platform_device *pdev)
{
struct mdss_data_type *mdata = platform_get_drvdata(pdev);
if (!mdata)
return -ENODEV;
pm_runtime_disable(&pdev->dev);
mdss_mdp_pp_term(&pdev->dev);
mdss_mdp_bus_scale_unregister(mdata);
mdss_debugfs_remove(mdata);
if (mdata->regulator_notif_register)
regul... |
functions | int mdss_mdp_register_driver(void)
{
return platform_driver_register(&mdss_mdp_driver);
} |
functions | __init mdss_mdp_driver_init(void)
{
int ret;
ret = mdss_mdp_register_driver();
if (ret) {
pr_err("mdp_register_driver() failed!\n");
return ret;
} |
includes | #include <stdlib.h> |
includes | #include <stdio.h> |
includes | #include <stdarg.h> |
includes | #include <unistd.h> |
includes | #include <string.h> |
includes | #include <errno.h> |
includes |
#include <osmocom/core/utils.h> |
includes | #include <osmocom/core/select.h> |
includes | #include <osmocom/core/logging.h> |
includes | #include <osmocom/core/fsm.h> |
includes | #include <osmocom/ctrl/control_if.h> |
defines | #define assert_name(expected_name) \ |
defines | #define assert_id(expected_id) \ |
defines | #define test_id(new_id, expect_rc, expect_name_suffix) do { \ |
defines | #define change_id(new_id) \ |
defines | #define test_id_f(expect_rc, expect_name_suffix, new_id_fmt, args...) do { \ |
defines |
#define fake_time_passes(secs, usecs) do \ |
functions | int safe_strcmp(const char *a, const char *b)
{
if (!a || !b)
return a == b ? 0 : 1;
return strcmp(a, b);
} |
functions | void test_fsm_null(struct osmo_fsm_inst *fi, uint32_t event, void *data)
{
switch (event) {
case EV_A:
OSMO_ASSERT(data == (void *) 23);
osmo_fsm_inst_state_chg(fi, ST_ONE, 0, 0);
break;
default:
OSMO_ASSERT(0);
break;
} |
functions | void test_fsm_one(struct osmo_fsm_inst *fi, uint32_t event, void *data)
{
switch (event) {
case EV_B:
OSMO_ASSERT(data == (void *) 42);
osmo_fsm_inst_state_chg(fi,ST_TWO, 1, 2342);
break;
default:
OSMO_ASSERT(0);
break;
} |
functions | int test_fsm_tmr_cb(struct osmo_fsm_inst *fi)
{
OSMO_ASSERT(fi->T == 2342);
OSMO_ASSERT(fi->state == ST_TWO);
LOGP(DMAIN, LOGL_INFO, "Timer\n");
main_loop_run = false;
return 0;
} |
functions | void assert_cmd_reply(const char *cmdstr, const char *expres)
{
struct ctrl_cmd *cmd;
cmd = exec_ctrl_cmd(cmdstr);
if (safe_strcmp(cmd->reply, expres)) {
fprintf(stderr, "Reply '%s' doesn't match expected '%s'\n", cmd->reply, expres);
OSMO_ASSERT(0);
} |
functions | void test_id_api()
{
struct osmo_fsm_inst *fi;
fprintf(stderr, "\n--- %s()\n", __func__);
/* Assert the instance has this name and can be looked up by it */
do { \
const char *name = osmo_fsm_inst_name(fi); \
fprintf(stderr, " osmo_fsm_inst_name() == %s\n", osmo_quote_str(name, -1)); \
if (safe_strcmp(name, ex... |
functions | void fake_time_start()
{
struct timespec *clock_override;
osmo_gettimeofday_override_time = fake_time_start_time;
osmo_gettimeofday_override = true;
clock_override = osmo_clock_override_gettimespec(CLOCK_MONOTONIC);
OSMO_ASSERT(clock_override);
clock_override->tv_sec = fake_time_start_time.tv_sec;
clock_overrid... |
functions | int timer_cb(struct osmo_fsm_inst *fi)
{
timeout_fired = fi->T;
return 0;
} |
functions | void test_state_chg_keep_timer()
{
struct osmo_fsm_inst *fi;
fprintf(stderr, "\n--- %s()\n", __func__);
fsm.timer_cb = timer_cb;
/* Test that no timer remains no timer */
fi = osmo_fsm_inst_alloc(&fsm, g_ctx, NULL, LOGL_DEBUG, NULL);
OSMO_ASSERT(fi);
osmo_fsm_inst_state_chg(fi, ST_ONE, 0, 0);
timeout_fired ... |
functions | void test_state_chg_T()
{
struct osmo_fsm_inst *fi;
fprintf(stderr, "\n--- %s()\n", __func__);
fsm.timer_cb = NULL;
/* Test setting to timeout_secs = 0, T = 0 */
fi = osmo_fsm_inst_alloc(&fsm, g_ctx, NULL, LOGL_DEBUG, NULL);
OSMO_ASSERT(fi);
osmo_fsm_inst_state_chg(fi, ST_ONE, 23, 42);
printf("T = %d\n", fi... |
main | int main(int argc, char **argv)
{
struct log_target *stderr_target;
struct osmo_fsm_inst *finst;
osmo_fsm_log_addr(false);
/* Using fake time to get deterministic timeout logging */
osmo_fsm_log_timeouts(true);
log_init(&log_info, NULL);
stderr_target = log_target_create_stderr();
log_add_target(stderr_targe... |
includes |
#include <epan/packet.h> |
includes | #include <epan/prefs.h> |
includes | #include <epan/tap.h> |
defines |
#define TCP_PORT_SKINNY 2000 |
defines | #define SSL_PORT_SKINNY 2443 /* IANA assigned to PowerClient Central Storage Facility */ |
defines |
#define SKINNY_SOFTKEY0 0x01 |
defines | #define SKINNY_SOFTKEY1 0x02 |
defines | #define SKINNY_SOFTKEY2 0x04 |
defines | #define SKINNY_SOFTKEY3 0x08 |
defines | #define SKINNY_SOFTKEY4 0x10 |
defines | #define SKINNY_SOFTKEY5 0x20 |
defines | #define SKINNY_SOFTKEY6 0x40 |
defines | #define SKINNY_SOFTKEY7 0x80 |
defines | #define SKINNY_SOFTKEY8 0x100 |
defines | #define SKINNY_SOFTKEY9 0x200 |
defines | #define SKINNY_SOFTKEY10 0x400 |
defines | #define SKINNY_SOFTKEY11 0x800 |
defines | #define SKINNY_SOFTKEY12 0x1000 |
defines | #define SKINNY_SOFTKEY13 0x2000 |
defines | #define SKINNY_SOFTKEY14 0x4000 |
defines | #define SKINNY_SOFTKEY15 0x8000 |
defines |
#define BASIC_MSG_TYPE 0x00 |
defines | #define CM7_MSG_TYPE_A 0x12 |
defines | #define CM7_MSG_TYPE_B 0x11 |
defines | #define CM7_MSG_TYPE_C 0x14 |
defines | #define DeviceMaxCapabilities 18 /* max capabilities allowed in Cap response message */ |
defines |
#define SkMaxSoftKeyCount 18 /* this value should be the same as the max soft key value */ |
defines |
#define StationTotalSoftKeySets 10 /* total number of the soft key sets */ |
defines |
#define StationMaxDirnumSize 24 /* max size of calling or called party dirnum */ |
defines | #define StationMaxNameSize 40 /* max size of calling party's name */ |
defines | #define StationMaxDisplayNameSize 44 /* max size of display name */ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.