[mirror_ubuntu-artful-kernel.git] / drivers / gpu / drm / drm_color_mgmt.c

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_color_mgmt.h>

#include "drm_crtc_internal.h"

/**
 * DOC: overview
 *
 * Color management or color space adjustments is supported through a set of 5
 * properties on the &drm_crtc object. They are set up by calling
 * drm_crtc_enable_color_mgmt().
 *
 * "DEGAMMA_LUT”:
 *	Blob property to set the degamma lookup table (LUT) mapping pixel data
 *	from the framebuffer before it is given to the transformation matrix.
 *	The data is interpreted as an array of struct &drm_color_lut elements.
 *	Hardware might choose not to use the full precision of the LUT elements
 *	nor use all the elements of the LUT (for example the hardware might
 *	choose to interpolate between LUT[0] and LUT[4]).
 *
 *	Setting this to NULL (blob property value set to 0) means a
 *	linear/pass-thru gamma table should be used. This is generally the
 *	driver boot-up state too.
 *
 * “DEGAMMA_LUT_SIZE”:
 *	Unsinged range property to give the size of the lookup table to be set
 *	on the DEGAMMA_LUT property (the size depends on the underlying
 *	hardware). If drivers support multiple LUT sizes then they should
 *	publish the largest size, and sub-sample smaller sized LUTs (e.g. for
 *	split-gamma modes) appropriately.
 *
 * “CTM”:
 *	Blob property to set the current transformation matrix (CTM) apply to
 *	pixel data after the lookup through the degamma LUT and before the
 *	lookup through the gamma LUT. The data is interpreted as a struct
 *	&drm_color_ctm.
 *
 *	Setting this to NULL (blob property value set to 0) means a
 *	unit/pass-thru matrix should be used. This is generally the driver
 *	boot-up state too.
 *
 * “GAMMA_LUT”:
 *	Blob property to set the gamma lookup table (LUT) mapping pixel data
 *	after the transformation matrix to data sent to the connector. The
 *	data is interpreted as an array of struct &drm_color_lut elements.
 *	Hardware might choose not to use the full precision of the LUT elements
 *	nor use all the elements of the LUT (for example the hardware might
 *	choose to interpolate between LUT[0] and LUT[4]).
 *
 *	Setting this to NULL (blob property value set to 0) means a
 *	linear/pass-thru gamma table should be used. This is generally the
 *	driver boot-up state too.
 *
 * “GAMMA_LUT_SIZE”:
 *	Unsigned range property to give the size of the lookup table to be set
 *	on the GAMMA_LUT property (the size depends on the underlying hardware).
 *	If drivers support multiple LUT sizes then they should publish the
 *	largest size, and sub-sample smaller sized LUTs (e.g. for split-gamma
 *	modes) appropriately.
 *
 * There is also support for a legacy gamma table, which is set up by calling
 * drm_mode_crtc_set_gamma_size(). Drivers which support both should use
 * drm_atomic_helper_legacy_gamma_set() to alias the legacy gamma ramp with the
 * "GAMMA_LUT" property above.
 */

/**
 * drm_crtc_enable_color_mgmt - enable color management properties
 * @crtc: DRM CRTC
 * @degamma_lut_size: the size of the degamma lut (before CSC)
 * @has_ctm: whether to attach ctm_property for CSC matrix
 * @gamma_lut_size: the size of the gamma lut (after CSC)
 *
 * This function lets the driver enable the color correction
 * properties on a CRTC. This includes 3 degamma, csc and gamma
 * properties that userspace can set and 2 size properties to inform
 * the userspace of the lut sizes. Each of the properties are
 * optional. The gamma and degamma properties are only attached if
 * their size is not 0 and ctm_property is only attached if has_ctm is
 * true.
 */
void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
				uint degamma_lut_size,
				bool has_ctm,
				uint gamma_lut_size)
{
	struct drm_device *dev = crtc->dev;
	struct drm_mode_config *config = &dev->mode_config;

	if (degamma_lut_size) {
		drm_object_attach_property(&crtc->base,
					   config->degamma_lut_property, 0);
		drm_object_attach_property(&crtc->base,
					   config->degamma_lut_size_property,
					   degamma_lut_size);
	}

	if (has_ctm)
		drm_object_attach_property(&crtc->base,
					   config->ctm_property, 0);

	if (gamma_lut_size) {
		drm_object_attach_property(&crtc->base,
					   config->gamma_lut_property, 0);
		drm_object_attach_property(&crtc->base,
					   config->gamma_lut_size_property,
					   gamma_lut_size);
	}
}
EXPORT_SYMBOL(drm_crtc_enable_color_mgmt);

/**
 * drm_mode_crtc_set_gamma_size - set the gamma table size
 * @crtc: CRTC to set the gamma table size for
 * @gamma_size: size of the gamma table
 *
 * Drivers which support gamma tables should set this to the supported gamma
 * table size when initializing the CRTC. Currently the drm core only supports a
 * fixed gamma table size.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
				 int gamma_size)
{
	uint16_t *r_base, *g_base, *b_base;
	int i;

	crtc->gamma_size = gamma_size;

	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
				    GFP_KERNEL);
	if (!crtc->gamma_store) {
		crtc->gamma_size = 0;
		return -ENOMEM;
	}

	r_base = crtc->gamma_store;
	g_base = r_base + gamma_size;
	b_base = g_base + gamma_size;
	for (i = 0; i < gamma_size; i++) {
		r_base[i] = i << 8;
		g_base[i] = i << 8;
		b_base[i] = i << 8;
	}


	return 0;
}
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);

/**
 * drm_mode_gamma_set_ioctl - set the gamma table
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
 * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_gamma_set_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc_lut *crtc_lut = data;
	struct drm_crtc *crtc;
	void *r_base, *g_base, *b_base;
	int size;
	int ret = 0;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

	drm_modeset_lock_all(dev);
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
		ret = -ENOENT;
		goto out;
	}

	if (crtc->funcs->gamma_set == NULL) {
		ret = -ENOSYS;
		goto out;
	}

	/* memcpy into gamma store */
	if (crtc_lut->gamma_size != crtc->gamma_size) {
		ret = -EINVAL;
		goto out;
	}

	size = crtc_lut->gamma_size * (sizeof(uint16_t));
	r_base = crtc->gamma_store;
	if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
		ret = -EFAULT;
		goto out;
	}

	g_base = r_base + size;
	if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
		ret = -EFAULT;
		goto out;
	}

	b_base = g_base + size;
	if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
		ret = -EFAULT;
		goto out;
	}

	ret = crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);

out:
	drm_modeset_unlock_all(dev);
	return ret;

}

/**
 * drm_mode_gamma_get_ioctl - get the gamma table
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Copy the current gamma table into the storage provided. This also provides
 * the gamma table size the driver expects, which can be used to size the
 * allocated storage.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_gamma_get_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc_lut *crtc_lut = data;
	struct drm_crtc *crtc;
	void *r_base, *g_base, *b_base;
	int size;
	int ret = 0;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

	drm_modeset_lock_all(dev);
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
		ret = -ENOENT;
		goto out;
	}

	/* memcpy into gamma store */
	if (crtc_lut->gamma_size != crtc->gamma_size) {
		ret = -EINVAL;
		goto out;
	}

	size = crtc_lut->gamma_size * (sizeof(uint16_t));
	r_base = crtc->gamma_store;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
		ret = -EFAULT;
		goto out;
	}

	g_base = r_base + size;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
		ret = -EFAULT;
		goto out;
	}

	b_base = g_base + size;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
		ret = -EFAULT;
		goto out;
	}
out:
	drm_modeset_unlock_all(dev);
	return ret;
}
Commit	Line	Data
f1e2f66c DV	1	/*
	2	* Copyright (c) 2016 Intel Corporation
	3	*
	4	* Permission to use, copy, modify, distribute, and sell this software and its
	5	* documentation for any purpose is hereby granted without fee, provided that
	6	* the above copyright notice appear in all copies and that both that copyright
	7	* notice and this permission notice appear in supporting documentation, and
	8	* that the name of the copyright holders not be used in advertising or
	9	* publicity pertaining to distribution of the software without specific,
	10	* written prior permission. The copyright holders make no representations
	11	* about the suitability of this software for any purpose. It is provided "as
	12	* is" without express or implied warranty.
	13	*
	14	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
	15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
	16	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
	17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
	18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
	19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	20	* OF THIS SOFTWARE.
	21	*/
	22
	23	#include <drm/drmP.h>
	24	#include <drm/drm_crtc.h>
	25	#include <drm/drm_color_mgmt.h>
	26
	27	#include "drm_crtc_internal.h"
	28
a6acccf8 DV	29	/**
	30	* DOC: overview
	31	*
	32	* Color management or color space adjustments is supported through a set of 5
	33	* properties on the &drm_crtc object. They are set up by calling
	34	* drm_crtc_enable_color_mgmt().
	35	*
	36	* "DEGAMMA_LUT”:
	37	* Blob property to set the degamma lookup table (LUT) mapping pixel data
	38	* from the framebuffer before it is given to the transformation matrix.
	39	* The data is interpreted as an array of struct &drm_color_lut elements.
	40	* Hardware might choose not to use the full precision of the LUT elements
	41	* nor use all the elements of the LUT (for example the hardware might
	42	* choose to interpolate between LUT[0] and LUT[4]).
	43	*
717fd813 DV	44	* Setting this to NULL (blob property value set to 0) means a
	45	* linear/pass-thru gamma table should be used. This is generally the
	46	* driver boot-up state too.
	47	*
a6acccf8 DV	48	* “DEGAMMA_LUT_SIZE”:
	49	* Unsinged range property to give the size of the lookup table to be set
	50	* on the DEGAMMA_LUT property (the size depends on the underlying
	51	* hardware). If drivers support multiple LUT sizes then they should
	52	* publish the largest size, and sub-sample smaller sized LUTs (e.g. for
	53	* split-gamma modes) appropriately.
	54	*
	55	* “CTM”:
	56	* Blob property to set the current transformation matrix (CTM) apply to
	57	* pixel data after the lookup through the degamma LUT and before the
	58	* lookup through the gamma LUT. The data is interpreted as a struct
	59	* &drm_color_ctm.
	60	*
717fd813 DV	61	* Setting this to NULL (blob property value set to 0) means a
	62	* unit/pass-thru matrix should be used. This is generally the driver
	63	* boot-up state too.
	64	*
a6acccf8 DV	65	* “GAMMA_LUT”:
	66	* Blob property to set the gamma lookup table (LUT) mapping pixel data
	67	* after the transformation matrix to data sent to the connector. The
	68	* data is interpreted as an array of struct &drm_color_lut elements.
	69	* Hardware might choose not to use the full precision of the LUT elements
	70	* nor use all the elements of the LUT (for example the hardware might
	71	* choose to interpolate between LUT[0] and LUT[4]).
	72	*
717fd813 DV	73	* Setting this to NULL (blob property value set to 0) means a
	74	* linear/pass-thru gamma table should be used. This is generally the
	75	* driver boot-up state too.
	76	*
a6acccf8 DV	77	* “GAMMA_LUT_SIZE”:
	78	* Unsigned range property to give the size of the lookup table to be set
	79	* on the GAMMA_LUT property (the size depends on the underlying hardware).
	80	* If drivers support multiple LUT sizes then they should publish the
	81	* largest size, and sub-sample smaller sized LUTs (e.g. for split-gamma
	82	* modes) appropriately.
	83	*
	84	* There is also support for a legacy gamma table, which is set up by calling
	85	* drm_mode_crtc_set_gamma_size(). Drivers which support both should use
	86	* drm_atomic_helper_legacy_gamma_set() to alias the legacy gamma ramp with the
	87	* "GAMMA_LUT" property above.
	88	*/
f1e2f66c DV	89
	90	/**
	91	* drm_crtc_enable_color_mgmt - enable color management properties
	92	* @crtc: DRM CRTC
	93	* @degamma_lut_size: the size of the degamma lut (before CSC)
	94	* @has_ctm: whether to attach ctm_property for CSC matrix
	95	* @gamma_lut_size: the size of the gamma lut (after CSC)
	96	*
	97	* This function lets the driver enable the color correction
	98	* properties on a CRTC. This includes 3 degamma, csc and gamma
	99	* properties that userspace can set and 2 size properties to inform
	100	* the userspace of the lut sizes. Each of the properties are
	101	* optional. The gamma and degamma properties are only attached if
	102	* their size is not 0 and ctm_property is only attached if has_ctm is
	103	* true.
	104	*/
	105	void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
	106	uint degamma_lut_size,
	107	bool has_ctm,
	108	uint gamma_lut_size)
	109	{
	110	struct drm_device *dev = crtc->dev;
	111	struct drm_mode_config *config = &dev->mode_config;
	112
	113	if (degamma_lut_size) {
	114	drm_object_attach_property(&crtc->base,
	115	config->degamma_lut_property, 0);
	116	drm_object_attach_property(&crtc->base,
	117	config->degamma_lut_size_property,
	118	degamma_lut_size);
	119	}
	120
	121	if (has_ctm)
	122	drm_object_attach_property(&crtc->base,
	123	config->ctm_property, 0);
	124
	125	if (gamma_lut_size) {
	126	drm_object_attach_property(&crtc->base,
	127	config->gamma_lut_property, 0);
	128	drm_object_attach_property(&crtc->base,
	129	config->gamma_lut_size_property,
	130	gamma_lut_size);
	131	}
	132	}
	133	EXPORT_SYMBOL(drm_crtc_enable_color_mgmt);
	134
	135	/**
	136	* drm_mode_crtc_set_gamma_size - set the gamma table size
	137	* @crtc: CRTC to set the gamma table size for
	138	* @gamma_size: size of the gamma table
	139	*
	140	* Drivers which support gamma tables should set this to the supported gamma
	141	* table size when initializing the CRTC. Currently the drm core only supports a
	142	* fixed gamma table size.
	143	*
	144	* Returns:
	145	* Zero on success, negative errno on failure.
	146	*/
	147	int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
	148	int gamma_size)
	149	{
	150	uint16_t r_base, g_base, *b_base;
	151	int i;
	152
153	crtc->gamma_size = gamma_size;
154
155	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
156	GFP_KERNEL);
157	if (!crtc->gamma_store) {
158	crtc->gamma_size = 0;
159	return -ENOMEM;
160	}
161
162	r_base = crtc->gamma_store;
163	g_base = r_base + gamma_size;
164	b_base = g_base + gamma_size;
165	for (i = 0; i < gamma_size; i++) {
166	r_base[i] = i << 8;
167	g_base[i] = i << 8;
168	b_base[i] = i << 8;
169	}
170
171
172	return 0;
173	}
174	EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
175
176	/**
177	* drm_mode_gamma_set_ioctl - set the gamma table
178	* @dev: DRM device
179	* @data: ioctl data
180	* @file_priv: DRM file info
181	*
182	* Set the gamma table of a CRTC to the one passed in by the user. Userspace can
183	* inquire the required gamma table size through drm_mode_gamma_get_ioctl.
184	*
185	* Called by the user via ioctl.
186	*
187	* Returns:
188	* Zero on success, negative errno on failure.
189	*/
190	int drm_mode_gamma_set_ioctl(struct drm_device *dev,
191	void data, struct drm_file file_priv)
192	{
193	struct drm_mode_crtc_lut *crtc_lut = data;
194	struct drm_crtc *crtc;
195	void r_base, g_base, *b_base;
196	int size;
197	int ret = 0;
198
199	if (!drm_core_check_feature(dev, DRIVER_MODESET))
200	return -EINVAL;
201
202	drm_modeset_lock_all(dev);
203	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
204	if (!crtc) {
205	ret = -ENOENT;
206	goto out;
207	}
208
209	if (crtc->funcs->gamma_set == NULL) {
210	ret = -ENOSYS;
211	goto out;
212	}
213
214	/* memcpy into gamma store */
215	if (crtc_lut->gamma_size != crtc->gamma_size) {
216	ret = -EINVAL;
217	goto out;
218	}
219
220	size = crtc_lut->gamma_size * (sizeof(uint16_t));
221	r_base = crtc->gamma_store;
222	if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
223	ret = -EFAULT;
224	goto out;
225	}
226
227	g_base = r_base + size;
228	if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
229	ret = -EFAULT;
230	goto out;
231	}
232
233	b_base = g_base + size;
234	if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
235	ret = -EFAULT;
236	goto out;
237	}
238
239	ret = crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
240
241	out:
242	drm_modeset_unlock_all(dev);
243	return ret;
244
245	}
246
247	/**
248	* drm_mode_gamma_get_ioctl - get the gamma table
249	* @dev: DRM device
250	* @data: ioctl data
251	* @file_priv: DRM file info
252	*
253	* Copy the current gamma table into the storage provided. This also provides
254	* the gamma table size the driver expects, which can be used to size the
255	* allocated storage.
256	*
257	* Called by the user via ioctl.
258	*
259	* Returns:
260	* Zero on success, negative errno on failure.
261	*/
262	int drm_mode_gamma_get_ioctl(struct drm_device *dev,
263	void data, struct drm_file file_priv)
264	{
265	struct drm_mode_crtc_lut *crtc_lut = data;
266	struct drm_crtc *crtc;
267	void r_base, g_base, *b_base;
268	int size;
269	int ret = 0;
270
271	if (!drm_core_check_feature(dev, DRIVER_MODESET))
272	return -EINVAL;
273
274	drm_modeset_lock_all(dev);
275	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
276	if (!crtc) {
277	ret = -ENOENT;
278	goto out;
279	}
280
281	/* memcpy into gamma store */
282	if (crtc_lut->gamma_size != crtc->gamma_size) {
283	ret = -EINVAL;
284	goto out;
285	}
286
287	size = crtc_lut->gamma_size * (sizeof(uint16_t));
288	r_base = crtc->gamma_store;
289	if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
290	ret = -EFAULT;
291	goto out;
292	}
293
294	g_base = r_base + size;
295	if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
296	ret = -EFAULT;
297	goto out;
298	}
299
300	b_base = g_base + size;
301	if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
302	ret = -EFAULT;
303	goto out;
304	}
305	out:
306	drm_modeset_unlock_all(dev);
307	return ret;
308	}