drm/vc4: Use the atomic state's commit workqueue. (cf1b372e) · Commits · 戴 / test

drivers/gpu/drm/vc4/vc4_kms.c

+13 −58

Original line number	Original line	Diff line number	Diff line
	@@ -29,16 +29,9 @@ static void vc4_output_poll_changed(struct drm_device *dev)
	drm_fbdev_cma_hotplug_event(vc4->fbdev);		drm_fbdev_cma_hotplug_event(vc4->fbdev);
	}		}

	struct vc4_commit {
	struct drm_device *dev;
	struct drm_atomic_state *state;
	struct vc4_seqno_cb cb;
	};

	static void		static void
	vc4_atomic_complete_commit(struct vc4_commit *c)		vc4_atomic_complete_commit(struct drm_atomic_state *state)
	{		{
	struct drm_atomic_state *state = c->state;
	struct drm_device *dev = state->dev;		struct drm_device *dev = state->dev;
	struct vc4_dev *vc4 = to_vc4_dev(dev);		struct vc4_dev *vc4 = to_vc4_dev(dev);

	@@ -72,28 +65,14 @@ vc4_atomic_complete_commit(struct vc4_commit *c)
	drm_atomic_state_put(state);		drm_atomic_state_put(state);

	up(&vc4->async_modeset);		up(&vc4->async_modeset);

	kfree(c);
	}		}

	static void		static void commit_work(struct work_struct *work)
	vc4_atomic_complete_commit_seqno_cb(struct vc4_seqno_cb *cb)
	{		{
	struct vc4_commit *c = container_of(cb, struct vc4_commit, cb);		struct drm_atomic_state *state = container_of(work,
			struct drm_atomic_state,
	vc4_atomic_complete_commit(c);		commit_work);
	}		vc4_atomic_complete_commit(state);

	static struct vc4_commit commit_init(struct drm_atomic_state state)
	{
	struct vc4_commit c = kzalloc(sizeof(c), GFP_KERNEL);

	if (!c)
	return NULL;
	c->dev = state->dev;
	c->state = state;

	return c;
	}		}

	/**		/**
	@@ -115,29 +94,19 @@ static int vc4_atomic_commit(struct drm_device *dev,
	{		{
	struct vc4_dev *vc4 = to_vc4_dev(dev);		struct vc4_dev *vc4 = to_vc4_dev(dev);
	int ret;		int ret;
	int i;
	uint64_t wait_seqno = 0;
	struct vc4_commit *c;
	struct drm_plane *plane;
	struct drm_plane_state *new_state;

	c = commit_init(state);
	if (!c)
	return -ENOMEM;

	ret = drm_atomic_helper_setup_commit(state, nonblock);		ret = drm_atomic_helper_setup_commit(state, nonblock);
	if (ret)		if (ret)
	return ret;		return ret;

			INIT_WORK(&state->commit_work, commit_work);

	ret = down_interruptible(&vc4->async_modeset);		ret = down_interruptible(&vc4->async_modeset);
	if (ret) {		if (ret)
	kfree(c);
	return ret;		return ret;
	}

	ret = drm_atomic_helper_prepare_planes(dev, state);		ret = drm_atomic_helper_prepare_planes(dev, state);
	if (ret) {		if (ret) {
	kfree(c);
	up(&vc4->async_modeset);		up(&vc4->async_modeset);
	return ret;		return ret;
	}		}
	@@ -146,22 +115,11 @@ static int vc4_atomic_commit(struct drm_device *dev,
	ret = drm_atomic_helper_wait_for_fences(dev, state, true);		ret = drm_atomic_helper_wait_for_fences(dev, state, true);
	if (ret) {		if (ret) {
	drm_atomic_helper_cleanup_planes(dev, state);		drm_atomic_helper_cleanup_planes(dev, state);
	kfree(c);
	up(&vc4->async_modeset);		up(&vc4->async_modeset);
	return ret;		return ret;
	}		}
	}		}

	for_each_plane_in_state(state, plane, new_state, i) {
	if ((plane->state->fb != new_state->fb) && new_state->fb) {
	struct drm_gem_cma_object *cma_bo =
	drm_fb_cma_get_gem_obj(new_state->fb, 0);
	struct vc4_bo *bo = to_vc4_bo(&cma_bo->base);

	wait_seqno = max(bo->seqno, wait_seqno);
	}
	}

	/*		/*
	* This is the point of no return - everything below never fails except		* This is the point of no return - everything below never fails except
	* when the hw goes bonghits. Which means we can commit the new state on		* when the hw goes bonghits. Which means we can commit the new state on
	@@ -187,13 +145,10 @@ static int vc4_atomic_commit(struct drm_device *dev,
	*/		*/

	drm_atomic_state_get(state);		drm_atomic_state_get(state);
	if (nonblock) {		if (nonblock)
	vc4_queue_seqno_cb(dev, &c->cb, wait_seqno,		queue_work(system_unbound_wq, &state->commit_work);
	vc4_atomic_complete_commit_seqno_cb);		else
	} else {		vc4_atomic_complete_commit(state);
	vc4_wait_for_seqno(dev, wait_seqno, ~0ull, false);
	vc4_atomic_complete_commit(c);
	}

	return 0;		return 0;
	}		}

Admin message