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; } } }