int test_fence_multi_timeline_wait(void)
{
int timelineA, timelineB, timelineC;
int fenceA, fenceB, fenceC, merged;
int valid, active, signaled, ret;
timelineA = sw_sync_timeline_create();
timelineB = sw_sync_timeline_create();
timelineC = sw_sync_timeline_create();
fenceA = sw_sync_fence_create(timelineA, "fenceA", 5);
fenceB = sw_sync_fence_create(timelineB, "fenceB", 5);
fenceC = sw_sync_fence_create(timelineC, "fenceC", 5);
merged = sync_merge("mergeFence", fenceB, fenceA);
merged = sync_merge("mergeFence", fenceC, merged);
valid = sw_sync_fence_is_valid(merged);
ASSERT(valid, "Failure merging fence from various timelines\n");
/* Confirm fence isn't signaled */
active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE);
ASSERT(active == 3, "Fence signaled too early!\n");
ret = sync_wait(merged, 0);
ASSERT(ret == 0,
"Failure waiting on fence until timeout\n");
ret = sw_sync_timeline_inc(timelineA, 5);
active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE);
signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED);
ASSERT(active == 2 && signaled == 1,
"Fence did not signal properly!\n");
ret = sw_sync_timeline_inc(timelineB, 5);
active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE);
signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED);
ASSERT(active == 1 && signaled == 2,
"Fence did not signal properly!\n");
ret = sw_sync_timeline_inc(timelineC, 5);
active = sync_fence_count_with_status(merged, FENCE_STATUS_ACTIVE);
signaled = sync_fence_count_with_status(merged, FENCE_STATUS_SIGNALED);
ASSERT(active == 0 && signaled == 3,
"Fence did not signal properly!\n");
/* confirm you can successfully wait */
ret = sync_wait(merged, 100);
ASSERT(ret > 0, "Failure waiting on signaled fence\n");
sw_sync_fence_destroy(merged);
sw_sync_fence_destroy(fenceC);
sw_sync_fence_destroy(fenceB);
sw_sync_fence_destroy(fenceA);
sw_sync_timeline_destroy(timelineC);
sw_sync_timeline_destroy(timelineB);
sw_sync_timeline_destroy(timelineA);
return 0;
}
int test_consumer_stress_multi_producer_single_consumer(void)
{
int iterations = 1 << 12;
int n = 5;
long i, ret;
int producer_timelines[n];
int consumer_timeline;
pthread_t threads[n];
consumer_timeline = sw_sync_timeline_create();
for (i = 0; i < n; i++)
producer_timelines[i] = sw_sync_timeline_create();
test_data_mpsc.producer_timelines = producer_timelines;
test_data_mpsc.consumer_timeline = consumer_timeline;
test_data_mpsc.iterations = iterations;
test_data_mpsc.threads = n;
test_data_mpsc.counter = 0;
pthread_mutex_init(&test_data_mpsc.lock, NULL);
for (i = 0; i < n; i++) {
pthread_create(&threads[i], NULL, (void * (*)(void *))
mpsc_producer_thread, (void *)i);
}
/* Consumer thread runs here */
ret = mpcs_consumer_thread();
for (i = 0; i < n; i++)
pthread_join(threads[i], NULL);
return ret;
}
static struct sync_fence *adf_sw_complete_fence(struct adf_device *dev)
{
struct sync_pt *pt;
struct sync_fence *complete_fence;
if (!dev->timeline) {
dev->timeline = sw_sync_timeline_create(dev->base.name);
if (!dev->timeline)
return ERR_PTR(-ENOMEM);
dev->timeline_max = 1;
}
dev->timeline_max++;
pt = sw_sync_pt_create(dev->timeline, dev->timeline_max);
if (!pt)
goto err_pt_create;
complete_fence = sync_fence_create(dev->base.name, pt);
if (!complete_fence)
goto err_fence_create;
return complete_fence;
err_fence_create:
sync_pt_free(pt);
err_pt_create:
dev->timeline_max--;
return ERR_PTR(-ENOSYS);
}
int sde_fence_init(void *dev,
struct sde_fence *fence,
const char *name,
int offset)
{
if (!fence) {
SDE_ERROR("invalid argument(s)\n");
return -EINVAL;
}
fence->timeline = sw_sync_timeline_create(name ? name : "sde");
if (!fence->timeline) {
SDE_ERROR("failed to create timeline\n");
return -ENOMEM;
}
fence->dev = dev;
/*
* Allow created fences to have a constant offset with respect
* to the timeline. This allows us to delay the fence signalling
* w.r.t. the commit completion (e.g., an offset of +1 would
* cause fences returned during a particular commit to signal
* after an additional delay of one commit, rather than at the
* end of the current one.
*/
fence->offset = (int32_t)offset;
fence->commit_count = 0;
fence->done_count = 0;
mutex_init(&fence->fence_lock);
return 0;
}
int VirtualCompositorWorker::Init() {
int ret = sw_sync_timeline_create();
if (ret < 0) {
ALOGE("Failed to create sw sync timeline %d", ret);
return ret;
}
timeline_fd_ = ret;
return InitWorker();
}
/* opening sw_sync create a new sync obj */
static int sw_sync_open(struct inode *inode, struct file *file)
{
struct sw_sync_timeline *obj;
char task_comm[TASK_COMM_LEN];
get_task_comm(task_comm, current);
obj = sw_sync_timeline_create(task_comm);
if (obj == NULL)
return -ENOMEM;
file->private_data = obj;
return 0;
}
void k3fb_buf_sync_register(struct platform_device *pdev)
{
struct k3_fb_data_type *k3fd = NULL;
BUG_ON(pdev == NULL);
k3fd = platform_get_drvdata(pdev);
BUG_ON(k3fd == NULL);
K3_FB_DEBUG("fb%d, +.\n", k3fd->index);
spin_lock_init(&k3fd->buf_sync_ctrl.refresh_lock);
k3fd->buf_sync_ctrl.refresh = 0;
k3fd->buf_sync_ctrl.timeline_max = 1;
k3fd->buf_sync_ctrl.timeline =
sw_sync_timeline_create(BUF_SYNC_TIMELINE_NAME);
if (k3fd->buf_sync_ctrl.timeline == NULL) {
K3_FB_ERR("cannot create time line!");
return; /* -ENOMEM */
}
K3_FB_DEBUG("fb%d, -.\n", k3fd->index);
}
struct sw_sync_timeline *timeline_create(const char *name)
{
return sw_sync_timeline_create(name);
}
static int mdss_fb_probe(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd = NULL;
struct mdss_panel_data *pdata;
struct mdss_panel_common_pdata *panel_data;
struct fb_info *fbi;
int rc;
if (fbi_list_index >= MAX_FBI_LIST)
return -ENOMEM;
pdata = dev_get_platdata(&pdev->dev);
if (!pdata)
return -EPROBE_DEFER;
/*
* alloc framebuffer info + par data
*/
fbi = framebuffer_alloc(sizeof(struct msm_fb_data_type), NULL);
if (fbi == NULL) {
pr_err("can't allocate framebuffer info data!\n");
return -ENOMEM;
}
mfd = (struct msm_fb_data_type *)fbi->par;
mfd->key = MFD_KEY;
mfd->fbi = fbi;
mfd->panel_info = &pdata->panel_info;
mfd->panel.type = pdata->panel_info.type;
mfd->panel.id = mfd->index;
mfd->fb_page = MDSS_FB_NUM;
mfd->index = fbi_list_index;
mfd->mdp_fb_page_protection = MDP_FB_PAGE_PROTECTION_WRITECOMBINE;
mfd->bl_level = 0;
mfd->bl_scale = 1024;
mfd->bl_min_lvl = 30;
mfd->fb_imgType = MDP_RGBA_8888;
mfd->pdev = pdev;
if (pdata->next)
mfd->split_display = true;
mfd->mdp = *mdp_instance;
mutex_init(&mfd->lock);
mutex_init(&mfd->bl_lock);
fbi_list[fbi_list_index++] = fbi;
platform_set_drvdata(pdev, mfd);
rc = mdss_fb_register(mfd);
if (rc)
return rc;
if (mfd->mdp.init_fnc) {
rc = mfd->mdp.init_fnc(mfd);
if (rc) {
pr_err("init_fnc failed\n");
return rc;
}
}
rc = pm_runtime_set_active(mfd->fbi->dev);
if (rc < 0)
pr_err("pm_runtime: fail to set active.\n");
pm_runtime_enable(mfd->fbi->dev);
/* android supports only one lcd-backlight/lcd for now */
if (!lcd_backlight_registered) {
if (led_classdev_register(&pdev->dev, &backlight_led))
pr_err("led_classdev_register failed\n");
else
lcd_backlight_registered = 1;
}
mdss_fb_create_sysfs(mfd);
mdss_fb_send_panel_event(mfd, MDSS_EVENT_FB_REGISTERED, fbi);
if (mfd->timeline == NULL) {
char timeline_name[16];
snprintf(timeline_name, sizeof(timeline_name),
"mdss_fb_%d", mfd->index);
mfd->timeline = sw_sync_timeline_create(timeline_name);
if (mfd->timeline == NULL) {
pr_err("%s: cannot create time line", __func__);
return -ENOMEM;
} else {
mfd->timeline_value = 0;
}
}
#ifdef CONFIG_DEBUG_FS
if ((mfd->panel_info->type == MIPI_VIDEO_PANEL) ||
(mfd->panel_info->type == MIPI_CMD_PANEL))
mipi_dsi_panel_create_debugfs(mfd);
#endif
if (mfd->index == 0) {
panel_data = dev_get_platdata(&pdata->panel_pdev->dev);
if (panel_data) {
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
if (!ctrl) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
if (panel_data->panel_detect) {
mdss_fb_blank_sub(FB_BLANK_UNBLANK, mfd->fbi,
mfd->op_enable);
if (pdata->detect)
pdata->detect(pdata);
if (panel_data && panel_data->pcc_setup)
panel_data->pcc_setup(mfd);
mdss_fb_blank_sub(FB_BLANK_POWERDOWN, mfd->fbi,
mfd->op_enable);
if (pdata->update_panel)
pdata->update_panel(pdata);
} else {
ctrl->spec_pdata->detected = true;
}
}
}
