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 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 * 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. Drivers can access this blob through 47 * &drm_crtc_state.degamma_lut. 48 * 49 * “DEGAMMA_LUT_SIZE”: 50 * Unsinged range property to give the size of the lookup table to be set 51 * on the DEGAMMA_LUT property (the size depends on the underlying 52 * hardware). If drivers support multiple LUT sizes then they should 53 * publish the largest size, and sub-sample smaller sized LUTs (e.g. for 54 * split-gamma modes) appropriately. 55 * 56 * “CTM”: 57 * Blob property to set the current transformation matrix (CTM) apply to 58 * pixel data after the lookup through the degamma LUT and before the 59 * lookup through the gamma LUT. The data is interpreted as a struct 60 * &drm_color_ctm. 61 * 62 * Setting this to NULL (blob property value set to 0) means a 63 * unit/pass-thru matrix should be used. This is generally the driver 64 * boot-up state too. Drivers can access the blob for the color conversion 65 * matrix through &drm_crtc_state.ctm. 66 * 67 * “GAMMA_LUT”: 68 * Blob property to set the gamma lookup table (LUT) mapping pixel data 69 * after the transformation matrix to data sent to the connector. The 70 * data is interpreted as an array of &struct drm_color_lut elements. 71 * Hardware might choose not to use the full precision of the LUT elements 72 * nor use all the elements of the LUT (for example the hardware might 73 * choose to interpolate between LUT[0] and LUT[4]). 74 * 75 * Setting this to NULL (blob property value set to 0) means a 76 * linear/pass-thru gamma table should be used. This is generally the 77 * driver boot-up state too. Drivers can access this blob through 78 * &drm_crtc_state.gamma_lut. 79 * 80 * “GAMMA_LUT_SIZE”: 81 * Unsigned range property to give the size of the lookup table to be set 82 * on the GAMMA_LUT property (the size depends on the underlying hardware). 83 * If drivers support multiple LUT sizes then they should publish the 84 * largest size, and sub-sample smaller sized LUTs (e.g. for split-gamma 85 * modes) appropriately. 86 * 87 * There is also support for a legacy gamma table, which is set up by calling 88 * drm_mode_crtc_set_gamma_size(). Drivers which support both should use 89 * drm_atomic_helper_legacy_gamma_set() to alias the legacy gamma ramp with the 90 * "GAMMA_LUT" property above. 91 */ 92 93 /** 94 * drm_color_lut_extract - clamp and round LUT entries 95 * @user_input: input value 96 * @bit_precision: number of bits the hw LUT supports 97 * 98 * Extract a degamma/gamma LUT value provided by user (in the form of 99 * &drm_color_lut entries) and round it to the precision supported by the 100 * hardware. 101 */ 102 uint32_t drm_color_lut_extract(uint32_t user_input, uint32_t bit_precision) 103 { 104 uint32_t val = user_input; 105 uint32_t max = 0xffff >> (16 - bit_precision); 106 107 /* Round only if we're not using full precision. */ 108 if (bit_precision < 16) { 109 val += 1UL << (16 - bit_precision - 1); 110 val >>= 16 - bit_precision; 111 } 112 113 return clamp_val(val, 0, max); 114 } 115 EXPORT_SYMBOL(drm_color_lut_extract); 116 117 /** 118 * drm_crtc_enable_color_mgmt - enable color management properties 119 * @crtc: DRM CRTC 120 * @degamma_lut_size: the size of the degamma lut (before CSC) 121 * @has_ctm: whether to attach ctm_property for CSC matrix 122 * @gamma_lut_size: the size of the gamma lut (after CSC) 123 * 124 * This function lets the driver enable the color correction 125 * properties on a CRTC. This includes 3 degamma, csc and gamma 126 * properties that userspace can set and 2 size properties to inform 127 * the userspace of the lut sizes. Each of the properties are 128 * optional. The gamma and degamma properties are only attached if 129 * their size is not 0 and ctm_property is only attached if has_ctm is 130 * true. 131 * 132 * Drivers should use drm_atomic_helper_legacy_gamma_set() to implement the 133 * legacy &drm_crtc_funcs.gamma_set callback. 134 */ 135 void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc, 136 uint degamma_lut_size, 137 bool has_ctm, 138 uint gamma_lut_size) 139 { 140 struct drm_device *dev = crtc->dev; 141 struct drm_mode_config *config = &dev->mode_config; 142 143 if (degamma_lut_size) { 144 drm_object_attach_property(&crtc->base, 145 config->degamma_lut_property, 0); 146 drm_object_attach_property(&crtc->base, 147 config->degamma_lut_size_property, 148 degamma_lut_size); 149 } 150 151 if (has_ctm) 152 drm_object_attach_property(&crtc->base, 153 config->ctm_property, 0); 154 155 if (gamma_lut_size) { 156 drm_object_attach_property(&crtc->base, 157 config->gamma_lut_property, 0); 158 drm_object_attach_property(&crtc->base, 159 config->gamma_lut_size_property, 160 gamma_lut_size); 161 } 162 } 163 EXPORT_SYMBOL(drm_crtc_enable_color_mgmt); 164 165 /** 166 * drm_mode_crtc_set_gamma_size - set the gamma table size 167 * @crtc: CRTC to set the gamma table size for 168 * @gamma_size: size of the gamma table 169 * 170 * Drivers which support gamma tables should set this to the supported gamma 171 * table size when initializing the CRTC. Currently the drm core only supports a 172 * fixed gamma table size. 173 * 174 * Returns: 175 * Zero on success, negative errno on failure. 176 */ 177 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 178 int gamma_size) 179 { 180 uint16_t *r_base, *g_base, *b_base; 181 int i; 182 183 crtc->gamma_size = gamma_size; 184 185 crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3, 186 GFP_KERNEL); 187 if (!crtc->gamma_store) { 188 crtc->gamma_size = 0; 189 return -ENOMEM; 190 } 191 192 r_base = crtc->gamma_store; 193 g_base = r_base + gamma_size; 194 b_base = g_base + gamma_size; 195 for (i = 0; i < gamma_size; i++) { 196 r_base[i] = i << 8; 197 g_base[i] = i << 8; 198 b_base[i] = i << 8; 199 } 200 201 202 return 0; 203 } 204 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size); 205 206 /** 207 * drm_mode_gamma_set_ioctl - set the gamma table 208 * @dev: DRM device 209 * @data: ioctl data 210 * @file_priv: DRM file info 211 * 212 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can 213 * inquire the required gamma table size through drm_mode_gamma_get_ioctl. 214 * 215 * Called by the user via ioctl. 216 * 217 * Returns: 218 * Zero on success, negative errno on failure. 219 */ 220 int drm_mode_gamma_set_ioctl(struct drm_device *dev, 221 void *data, struct drm_file *file_priv) 222 { 223 struct drm_mode_crtc_lut *crtc_lut = data; 224 struct drm_crtc *crtc; 225 void *r_base, *g_base, *b_base; 226 int size; 227 struct drm_modeset_acquire_ctx ctx; 228 int ret = 0; 229 230 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 231 return -EINVAL; 232 233 crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id); 234 if (!crtc) 235 return -ENOENT; 236 237 if (crtc->funcs->gamma_set == NULL) 238 return -ENOSYS; 239 240 /* memcpy into gamma store */ 241 if (crtc_lut->gamma_size != crtc->gamma_size) 242 return -EINVAL; 243 244 drm_modeset_acquire_init(&ctx, 0); 245 retry: 246 ret = drm_modeset_lock_all_ctx(dev, &ctx); 247 if (ret) 248 goto out; 249 250 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 251 r_base = crtc->gamma_store; 252 if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) { 253 ret = -EFAULT; 254 goto out; 255 } 256 257 g_base = r_base + size; 258 if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) { 259 ret = -EFAULT; 260 goto out; 261 } 262 263 b_base = g_base + size; 264 if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) { 265 ret = -EFAULT; 266 goto out; 267 } 268 269 ret = crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 270 crtc->gamma_size, &ctx); 271 272 out: 273 if (ret == -EDEADLK) { 274 drm_modeset_backoff(&ctx); 275 goto retry; 276 } 277 drm_modeset_drop_locks(&ctx); 278 drm_modeset_acquire_fini(&ctx); 279 280 return ret; 281 282 } 283 284 /** 285 * drm_mode_gamma_get_ioctl - get the gamma table 286 * @dev: DRM device 287 * @data: ioctl data 288 * @file_priv: DRM file info 289 * 290 * Copy the current gamma table into the storage provided. This also provides 291 * the gamma table size the driver expects, which can be used to size the 292 * allocated storage. 293 * 294 * Called by the user via ioctl. 295 * 296 * Returns: 297 * Zero on success, negative errno on failure. 298 */ 299 int drm_mode_gamma_get_ioctl(struct drm_device *dev, 300 void *data, struct drm_file *file_priv) 301 { 302 struct drm_mode_crtc_lut *crtc_lut = data; 303 struct drm_crtc *crtc; 304 void *r_base, *g_base, *b_base; 305 int size; 306 int ret = 0; 307 308 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 309 return -EINVAL; 310 311 crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id); 312 if (!crtc) 313 return -ENOENT; 314 315 /* memcpy into gamma store */ 316 if (crtc_lut->gamma_size != crtc->gamma_size) 317 return -EINVAL; 318 319 drm_modeset_lock(&crtc->mutex, NULL); 320 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 321 r_base = crtc->gamma_store; 322 if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) { 323 ret = -EFAULT; 324 goto out; 325 } 326 327 g_base = r_base + size; 328 if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) { 329 ret = -EFAULT; 330 goto out; 331 } 332 333 b_base = g_base + size; 334 if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) { 335 ret = -EFAULT; 336 goto out; 337 } 338 out: 339 drm_modeset_unlock(&crtc->mutex); 340 return ret; 341 } 342