Re: [PATCH 1/5] drm: add plane support

[Joonyoung Shim <jy0922.shim@samsung.com>]

11/03/2011 05:03 AM, Jesse Barnes 쓴 글:
> Planes are a bit like half-CRTCs.  They have a location and fb, but
> don't drive outputs directly.  Add support for handling them to the core
> KMS code.
>
> Signed-off-by: Jesse Barnes<jbarnes@virtuousgeek.org>
> ---
>   drivers/gpu/drm/drm_crtc.c |  236 +++++++++++++++++++++++++++++++++++++++++++-
>   drivers/gpu/drm/drm_drv.c  |    3 +
>   include/drm/drm.h          |    3 +
>   include/drm/drm_crtc.h     |   76 ++++++++++++++-
>   include/drm/drm_mode.h     |   33 ++++++
>   5 files changed, 348 insertions(+), 3 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
> index fe738f0..0e129b1 100644
> --- a/drivers/gpu/drm/drm_crtc.c
> +++ b/drivers/gpu/drm/drm_crtc.c
> @@ -535,6 +535,48 @@ void drm_encoder_cleanup(struct drm_encoder *encoder)
>   }
>   EXPORT_SYMBOL(drm_encoder_cleanup);
>
> +void drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
> +		    unsigned long possible_crtcs,
> +		    const struct drm_plane_funcs *funcs,
> +		    uint32_t *formats, uint32_t format_count)
> +{
> +	mutex_lock(&dev->mode_config.mutex);
> +
> +	plane->dev = dev;
> +	drm_mode_object_get(dev,&plane->base, DRM_MODE_OBJECT_PLANE);
> +	plane->funcs = funcs;
> +	plane->format_types = kmalloc(sizeof(uint32_t) * format_count,
> +				      GFP_KERNEL);
> +	if (!plane->format_types) {
> +		DRM_DEBUG_KMS("out of memory when allocating plane\n");
> +		drm_mode_object_put(dev,&plane->base);
> +		return;
> +	}
> +
> +	memcpy(plane->format_types, formats, format_count);
> +	plane->format_count = format_count;
> +	plane->possible_crtcs = possible_crtcs;
> +
> +	list_add_tail(&plane->head,&dev->mode_config.plane_list);
> +	dev->mode_config.num_plane++;
> +
> +	mutex_unlock(&dev->mode_config.mutex);
> +}
> +EXPORT_SYMBOL(drm_plane_init);
> +
> +void drm_plane_cleanup(struct drm_plane *plane)
> +{
> +	struct drm_device *dev = plane->dev;
> +
> +	mutex_lock(&dev->mode_config.mutex);
> +	kfree(plane->format_types);
> +	drm_mode_object_put(dev,&plane->base);
> +	list_del(&plane->head);
> +	dev->mode_config.num_plane--;
> +	mutex_unlock(&dev->mode_config.mutex);
> +}
> +EXPORT_SYMBOL(drm_plane_cleanup);
> +
>   /**
>    * drm_mode_create - create a new display mode
>    * @dev: DRM device
> @@ -866,6 +908,7 @@ void drm_mode_config_init(struct drm_device *dev)
>   	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
>   	INIT_LIST_HEAD(&dev->mode_config.property_list);
>   	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
> +	INIT_LIST_HEAD(&dev->mode_config.plane_list);
>   	idr_init(&dev->mode_config.crtc_idr);
>
>   	mutex_lock(&dev->mode_config.mutex);
> @@ -1466,6 +1509,193 @@ out:
>   }
>
>   /**
> + * drm_mode_getplane_res - get plane info
> + * @dev: DRM device
> + * @data: ioctl data
> + * @file_priv: DRM file info
> + *
> + * Return an plane count and set of IDs.
> + */
> +int drm_mode_getplane_res(struct drm_device *dev, void *data,
> +			    struct drm_file *file_priv)
> +{
> +	struct drm_mode_get_plane_res *plane_resp = data;
> +	struct drm_mode_config *config;
> +	struct drm_plane *plane;
> +	uint32_t __user *plane_ptr;
> +	int copied = 0, ret = 0;
> +
> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
> +		return -EINVAL;
> +
> +	mutex_lock(&dev->mode_config.mutex);
> +	config =&dev->mode_config;
> +
> +	/*
> +	 * This ioctl is called twice, once to determine how much space is
> +	 * needed, and the 2nd time to fill it.
> +	 */
> +	if (config->num_plane&&
> +	    (plane_resp->count_planes>= config->num_plane)) {
> +		plane_ptr = (uint32_t *)(unsigned long)plane_resp->plane_id_ptr;
> +
> +		list_for_each_entry(plane,&config->plane_list, head) {
> +			if (put_user(plane->base.id, plane_ptr + copied)) {
> +				ret = -EFAULT;
> +				goto out;
> +			}
> +			copied++;
> +		}
> +	}
> +	plane_resp->count_planes = config->num_plane;
> +
> +out:
> +	mutex_unlock(&dev->mode_config.mutex);
> +	return ret;
> +}
> +
> +/**
> + * drm_mode_getplane - get plane info
> + * @dev: DRM device
> + * @data: ioctl data
> + * @file_priv: DRM file info
> + *
> + * Return plane info, including formats supported, gamma size, any
> + * current fb, etc.
> + */
> +int drm_mode_getplane(struct drm_device *dev, void *data,
> +			struct drm_file *file_priv)
> +{
> +	struct drm_mode_get_plane *plane_resp = data;
> +	struct drm_mode_object *obj;
> +	struct drm_plane *plane;
> +	uint32_t __user *format_ptr;
> +	int ret = 0;
> +
> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
> +		return -EINVAL;
> +
> +	mutex_lock(&dev->mode_config.mutex);
> +	obj = drm_mode_object_find(dev, plane_resp->plane_id,
> +				   DRM_MODE_OBJECT_PLANE);
> +	if (!obj) {
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +	plane = obj_to_plane(obj);
> +
> +	if (plane->crtc)
> +		plane_resp->crtc_id = plane->crtc->base.id;
> +	else
> +		plane_resp->crtc_id = 0;
> +
> +	if (plane->fb)
> +		plane_resp->fb_id = plane->fb->base.id;
> +	else
> +		plane_resp->fb_id = 0;
> +
> +	plane_resp->plane_id = plane->base.id;
> +	plane_resp->possible_crtcs = plane->possible_crtcs;
> +	plane_resp->gamma_size = plane->gamma_size;
> +
> +	/*
> +	 * This ioctl is called twice, once to determine how much space is
> +	 * needed, and the 2nd time to fill it.
> +	 */
> +	if (plane->format_count&&
> +	    (plane_resp->count_format_types>= plane->format_count)) {
> +		format_ptr = (uint32_t *)(unsigned long)plane_resp->format_type_ptr;
> +		if (copy_to_user(format_ptr,
> +				 plane->format_types,
> +				 sizeof(uint32_t) * plane->format_count)) {
> +			ret = -EFAULT;
> +			goto out;
> +		}
> +	}
> +	plane_resp->count_format_types = plane->format_count;
> +
> +out:
> +	mutex_unlock(&dev->mode_config.mutex);
> +	return ret;
> +}
> +
> +/**
> + * drm_mode_setplane - set up or tear down an plane
> + * @dev: DRM device
> + * @data: ioctl data*
> + * @file_prive: DRM file info
> + *
> + * Set plane info, including placement, fb, scaling, and other factors.
> + * Or pass a NULL fb to disable.
> + */
> +int drm_mode_setplane(struct drm_device *dev, void *data,
> +			struct drm_file *file_priv)
> +{
> +	struct drm_mode_set_plane *plane_req = data;
> +	struct drm_mode_object *obj;
> +	struct drm_plane *plane;
> +	struct drm_crtc *crtc;
> +	struct drm_framebuffer *fb;
> +	int ret = 0;
> +
> +	if (!drm_core_check_feature(dev, DRIVER_MODESET))
> +		return -EINVAL;
> +
> +	mutex_lock(&dev->mode_config.mutex);
> +
> +	/*
> +	 * First, find the plane, crtc, and fb objects.  If not available,
> +	 * we don't bother to call the driver.
> +	 */
> +	obj = drm_mode_object_find(dev, plane_req->plane_id,
> +				   DRM_MODE_OBJECT_PLANE);
> +	if (!obj) {
> +		DRM_DEBUG_KMS("Unknown plane ID %d\n",
> +			      plane_req->plane_id);
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +	plane = obj_to_plane(obj);
> +
> +	/* No fb means shut it down */
> +	if (!plane_req->fb_id) {
> +		plane->funcs->disable_plane(plane);
> +		goto out;
> +	}
> +
> +	obj = drm_mode_object_find(dev, plane_req->crtc_id,
> +				   DRM_MODE_OBJECT_CRTC);
> +	if (!obj) {
> +		DRM_DEBUG_KMS("Unknown crtc ID %d\n",
> +			      plane_req->crtc_id);
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +	crtc = obj_to_crtc(obj);
> +
> +	obj = drm_mode_object_find(dev, plane_req->fb_id,
> +				   DRM_MODE_OBJECT_FB);
> +	if (!obj) {
> +		DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
> +			      plane_req->fb_id);
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +	fb = obj_to_fb(obj);
> +
> +	ret = plane->funcs->update_plane(plane, crtc, fb,
> +					 plane_req->crtc_x, plane_req->crtc_y,
> +					 plane_req->crtc_w, plane_req->crtc_h,
> +					 plane_req->src_x, plane_req->src_y,
> +					 plane_req->src_h, plane_req->src_w);
> +
> +out:
> +	mutex_unlock(&dev->mode_config.mutex);
> +
> +	return ret;
> +}
> +
> +/**
>    * drm_mode_setcrtc - set CRTC configuration
>    * @inode: inode from the ioctl
>    * @filp: file * from the ioctl
> @@ -1688,11 +1918,13 @@ int drm_mode_addfb(struct drm_device *dev,
>   		return -EINVAL;
>
>   	if ((config->min_width>  r->width) || (r->width>  config->max_width)) {
> -		DRM_ERROR("mode new framebuffer width not within limits\n");
> +		DRM_ERROR("bad framebuffer width %d, should be>= %d&&  <= %d\n",
> +			  r->width, config->min_width, config->max_width);
>   		return -EINVAL;
>   	}
>   	if ((config->min_height>  r->height) || (r->height>  config->max_height)) {
> -		DRM_ERROR("mode new framebuffer height not within limits\n");
> +		DRM_ERROR("bad framebuffer height %d, should be>= %d&&  <= %d\n",
> +			  r->height, config->min_height, config->max_height);
>   		return -EINVAL;
>   	}
>
> diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
> index 93a112d..15da618 100644
> --- a/drivers/gpu/drm/drm_drv.c
> +++ b/drivers/gpu/drm/drm_drv.c
> @@ -135,8 +135,11 @@ static struct drm_ioctl_desc drm_ioctls[] = {
>   	DRM_IOCTL_DEF(DRM_IOCTL_GEM_OPEN, drm_gem_open_ioctl, DRM_AUTH|DRM_UNLOCKED),
>
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETRESOURCES, drm_mode_getresources, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
> +	DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANERESOURCES, drm_mode_getplane_res, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETCRTC, drm_mode_getcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETCRTC, drm_mode_setcrtc, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
> +	DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETPLANE, drm_mode_getplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
> +	DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETPLANE, drm_mode_setplane, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_CURSOR, drm_mode_cursor_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_GETGAMMA, drm_mode_gamma_get_ioctl, DRM_MASTER|DRM_UNLOCKED),
>   	DRM_IOCTL_DEF(DRM_IOCTL_MODE_SETGAMMA, drm_mode_gamma_set_ioctl, DRM_MASTER|DRM_UNLOCKED),
> diff --git a/include/drm/drm.h b/include/drm/drm.h
> index 4be33b4..2897967 100644
> --- a/include/drm/drm.h
> +++ b/include/drm/drm.h
> @@ -714,6 +714,9 @@ struct drm_get_cap {
>   #define DRM_IOCTL_MODE_CREATE_DUMB DRM_IOWR(0xB2, struct drm_mode_create_dumb)
>   #define DRM_IOCTL_MODE_MAP_DUMB    DRM_IOWR(0xB3, struct drm_mode_map_dumb)
>   #define DRM_IOCTL_MODE_DESTROY_DUMB    DRM_IOWR(0xB4, struct drm_mode_destroy_dumb)
> +#define DRM_IOCTL_MODE_GETPLANERESOURCES DRM_IOWR(0xB5, struct drm_mode_get_plane_res)
> +#define DRM_IOCTL_MODE_GETPLANE	DRM_IOWR(0xB6, struct drm_mode_get_plane)
> +#define DRM_IOCTL_MODE_SETPLANE	DRM_IOWR(0xB7, struct drm_mode_set_plane)
>
>   /**
>    * Device specific ioctls should only be in their respective headers
> diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
> index 8020798..b4519f8 100644
> --- a/include/drm/drm_crtc.h
> +++ b/include/drm/drm_crtc.h
> @@ -44,6 +44,7 @@ struct drm_framebuffer;
>   #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
>   #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
>   #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
> +#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
>
>   struct drm_mode_object {
>   	uint32_t id;
> @@ -278,6 +279,7 @@ struct drm_crtc;
>   struct drm_connector;
>   struct drm_encoder;
>   struct drm_pending_vblank_event;
> +struct drm_plane;
>
>   /**
>    * drm_crtc_funcs - control CRTCs for a given device
> @@ -536,6 +538,63 @@ struct drm_connector {
>   };
>
>   /**
> + * drm_plane_funcs - driver plane control functions
> + * @update_plane: update the plane configuration
> + */
> +struct drm_plane_funcs {
> +	int (*update_plane)(struct drm_plane *plane,
> +			    struct drm_crtc *crtc, struct drm_framebuffer *fb,
> +			    int crtc_x, int crtc_y,
> +			    unsigned int crtc_w, unsigned int crtc_h,
> +			    uint32_t src_x, uint32_t src_y,
> +			    uint32_t src_w, uint32_t src_h);
> +	int (*disable_plane)(struct drm_plane *plane);
> +};
> +
> +/**
> + * drm_plane - central DRM plane control structure
> + * @dev: DRM device this plane belongs to
> + * @kdev: kernel device
> + * @attr: kdev attributes
> + * @head: for list management
> + * @base: base mode object
> + * @possible_crtcs: pipes this plane can be bound to
> + * @format_types: array of formats supported by this plane
> + * @format_count: number of formats supported
> + * @crtc: currently bound CRTC
> + * @fb: currently bound fb
> + * @gamma_size: size of gamma table
> + * @gamma_store: gamma correction table
> + * @enabled: enabled flag
> + * @funcs: helper functions
> + * @helper_private: storage for drver layer
> + */
> +struct drm_plane {
> +	struct drm_device *dev;
> +	struct device kdev;
> +	struct device_attribute *attr;
> +	struct list_head head;
> +
> +	struct drm_mode_object base;
> +
> +	uint32_t possible_crtcs;
> +	uint32_t *format_types;
> +	uint32_t format_count;
> +
> +	struct drm_crtc *crtc;
> +	struct drm_framebuffer *fb;

Where are crtc and fb of struct drm_plane assigned?
First, i did it in device specific update_plane, but can do in
drm_mode_setplane?

_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/dri-devel