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 <linux/export.h> 24 #include <linux/uaccess.h> 25 26 #include <drm/drm_crtc.h> 27 #include <drm/drm_drv.h> 28 #include <drm/drm_file.h> 29 #include <drm/drm_framebuffer.h> 30 #include <drm/drm_print.h> 31 #include <drm/drm_property.h> 32 33 #include "drm_crtc_internal.h" 34 35 /** 36 * DOC: overview 37 * 38 * Properties as represented by &drm_property are used to extend the modeset 39 * interface exposed to userspace. For the atomic modeset IOCTL properties are 40 * even the only way to transport metadata about the desired new modeset 41 * configuration from userspace to the kernel. Properties have a well-defined 42 * value range, which is enforced by the drm core. See the documentation of the 43 * flags member of &struct drm_property for an overview of the different 44 * property types and ranges. 45 * 46 * Properties don't store the current value directly, but need to be 47 * instantiated by attaching them to a &drm_mode_object with 48 * drm_object_attach_property(). 49 * 50 * Property values are only 64bit. To support bigger piles of data (like gamma 51 * tables, color correction matrices or large structures) a property can instead 52 * point at a &drm_property_blob with that additional data. 53 * 54 * Properties are defined by their symbolic name, userspace must keep a 55 * per-object mapping from those names to the property ID used in the atomic 56 * IOCTL and in the get/set property IOCTL. 57 */ 58 59 static bool drm_property_flags_valid(u32 flags) 60 { 61 u32 legacy_type = flags & DRM_MODE_PROP_LEGACY_TYPE; 62 u32 ext_type = flags & DRM_MODE_PROP_EXTENDED_TYPE; 63 64 /* Reject undefined/deprecated flags */ 65 if (flags & ~(DRM_MODE_PROP_LEGACY_TYPE | 66 DRM_MODE_PROP_EXTENDED_TYPE | 67 DRM_MODE_PROP_IMMUTABLE | 68 DRM_MODE_PROP_ATOMIC)) 69 return false; 70 71 /* We want either a legacy type or an extended type, but not both */ 72 if (!legacy_type == !ext_type) 73 return false; 74 75 /* Only one legacy type at a time please */ 76 if (legacy_type && !is_power_of_2(legacy_type)) 77 return false; 78 79 return true; 80 } 81 82 /** 83 * drm_property_create - create a new property type 84 * @dev: drm device 85 * @flags: flags specifying the property type 86 * @name: name of the property 87 * @num_values: number of pre-defined values 88 * 89 * This creates a new generic drm property which can then be attached to a drm 90 * object with drm_object_attach_property(). The returned property object must 91 * be freed with drm_property_destroy(), which is done automatically when 92 * calling drm_mode_config_cleanup(). 93 * 94 * Returns: 95 * A pointer to the newly created property on success, NULL on failure. 96 */ 97 struct drm_property *drm_property_create(struct drm_device *dev, 98 u32 flags, const char *name, 99 int num_values) 100 { 101 struct drm_property *property = NULL; 102 int ret; 103 104 if (WARN_ON(!drm_property_flags_valid(flags))) 105 return NULL; 106 107 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN)) 108 return NULL; 109 110 property = kzalloc_obj(struct drm_property); 111 if (!property) 112 return NULL; 113 114 property->dev = dev; 115 116 if (num_values) { 117 property->values = kzalloc_objs(uint64_t, num_values); 118 if (!property->values) 119 goto fail; 120 } 121 122 ret = drm_mode_object_add(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); 123 if (ret) 124 goto fail; 125 126 property->flags = flags; 127 property->num_values = num_values; 128 INIT_LIST_HEAD(&property->enum_list); 129 130 strscpy_pad(property->name, name, DRM_PROP_NAME_LEN); 131 132 list_add_tail(&property->head, &dev->mode_config.property_list); 133 134 return property; 135 fail: 136 kfree(property->values); 137 kfree(property); 138 return NULL; 139 } 140 EXPORT_SYMBOL(drm_property_create); 141 142 /** 143 * drm_property_create_enum - create a new enumeration property type 144 * @dev: drm device 145 * @flags: flags specifying the property type 146 * @name: name of the property 147 * @props: enumeration lists with property values 148 * @num_values: number of pre-defined values 149 * 150 * This creates a new generic drm property which can then be attached to a drm 151 * object with drm_object_attach_property(). The returned property object must 152 * be freed with drm_property_destroy(), which is done automatically when 153 * calling drm_mode_config_cleanup(). 154 * 155 * Userspace is only allowed to set one of the predefined values for enumeration 156 * properties. 157 * 158 * Returns: 159 * A pointer to the newly created property on success, NULL on failure. 160 */ 161 struct drm_property *drm_property_create_enum(struct drm_device *dev, 162 u32 flags, const char *name, 163 const struct drm_prop_enum_list *props, 164 int num_values) 165 { 166 struct drm_property *property; 167 int i, ret; 168 169 flags |= DRM_MODE_PROP_ENUM; 170 171 property = drm_property_create(dev, flags, name, num_values); 172 if (!property) 173 return NULL; 174 175 for (i = 0; i < num_values; i++) { 176 ret = drm_property_add_enum(property, 177 props[i].type, 178 props[i].name); 179 if (ret) { 180 drm_property_destroy(dev, property); 181 return NULL; 182 } 183 } 184 185 return property; 186 } 187 EXPORT_SYMBOL(drm_property_create_enum); 188 189 /** 190 * drm_property_create_bitmask - create a new bitmask property type 191 * @dev: drm device 192 * @flags: flags specifying the property type 193 * @name: name of the property 194 * @props: enumeration lists with property bitflags 195 * @num_props: size of the @props array 196 * @supported_bits: bitmask of all supported enumeration values 197 * 198 * This creates a new bitmask drm property which can then be attached to a drm 199 * object with drm_object_attach_property(). The returned property object must 200 * be freed with drm_property_destroy(), which is done automatically when 201 * calling drm_mode_config_cleanup(). 202 * 203 * Compared to plain enumeration properties userspace is allowed to set any 204 * or'ed together combination of the predefined property bitflag values 205 * 206 * Returns: 207 * A pointer to the newly created property on success, NULL on failure. 208 */ 209 struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 210 u32 flags, const char *name, 211 const struct drm_prop_enum_list *props, 212 int num_props, 213 uint64_t supported_bits) 214 { 215 struct drm_property *property; 216 int i, ret; 217 int num_values = hweight64(supported_bits); 218 219 flags |= DRM_MODE_PROP_BITMASK; 220 221 property = drm_property_create(dev, flags, name, num_values); 222 if (!property) 223 return NULL; 224 for (i = 0; i < num_props; i++) { 225 if (!(supported_bits & (1ULL << props[i].type))) 226 continue; 227 228 ret = drm_property_add_enum(property, 229 props[i].type, 230 props[i].name); 231 if (ret) { 232 drm_property_destroy(dev, property); 233 return NULL; 234 } 235 } 236 237 return property; 238 } 239 EXPORT_SYMBOL(drm_property_create_bitmask); 240 241 static struct drm_property *property_create_range(struct drm_device *dev, 242 u32 flags, const char *name, 243 uint64_t min, uint64_t max) 244 { 245 struct drm_property *property; 246 247 property = drm_property_create(dev, flags, name, 2); 248 if (!property) 249 return NULL; 250 251 property->values[0] = min; 252 property->values[1] = max; 253 254 return property; 255 } 256 257 /** 258 * drm_property_create_range - create a new unsigned ranged property type 259 * @dev: drm device 260 * @flags: flags specifying the property type 261 * @name: name of the property 262 * @min: minimum value of the property 263 * @max: maximum value of the property 264 * 265 * This creates a new generic drm property which can then be attached to a drm 266 * object with drm_object_attach_property(). The returned property object must 267 * be freed with drm_property_destroy(), which is done automatically when 268 * calling drm_mode_config_cleanup(). 269 * 270 * Userspace is allowed to set any unsigned integer value in the (min, max) 271 * range inclusive. 272 * 273 * Returns: 274 * A pointer to the newly created property on success, NULL on failure. 275 */ 276 struct drm_property *drm_property_create_range(struct drm_device *dev, 277 u32 flags, const char *name, 278 uint64_t min, uint64_t max) 279 { 280 return property_create_range(dev, DRM_MODE_PROP_RANGE | flags, 281 name, min, max); 282 } 283 EXPORT_SYMBOL(drm_property_create_range); 284 285 /** 286 * drm_property_create_signed_range - create a new signed ranged property type 287 * @dev: drm device 288 * @flags: flags specifying the property type 289 * @name: name of the property 290 * @min: minimum value of the property 291 * @max: maximum value of the property 292 * 293 * This creates a new generic drm property which can then be attached to a drm 294 * object with drm_object_attach_property(). The returned property object must 295 * be freed with drm_property_destroy(), which is done automatically when 296 * calling drm_mode_config_cleanup(). 297 * 298 * Userspace is allowed to set any signed integer value in the (min, max) 299 * range inclusive. 300 * 301 * Returns: 302 * A pointer to the newly created property on success, NULL on failure. 303 */ 304 struct drm_property *drm_property_create_signed_range(struct drm_device *dev, 305 u32 flags, const char *name, 306 int64_t min, int64_t max) 307 { 308 return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags, 309 name, I642U64(min), I642U64(max)); 310 } 311 EXPORT_SYMBOL(drm_property_create_signed_range); 312 313 /** 314 * drm_property_create_object - create a new object property type 315 * @dev: drm device 316 * @flags: flags specifying the property type 317 * @name: name of the property 318 * @type: object type from DRM_MODE_OBJECT_* defines 319 * 320 * This creates a new generic drm property which can then be attached to a drm 321 * object with drm_object_attach_property(). The returned property object must 322 * be freed with drm_property_destroy(), which is done automatically when 323 * calling drm_mode_config_cleanup(). 324 * 325 * Userspace is only allowed to set this to any property value of the given 326 * @type. Only useful for atomic properties, which is enforced. 327 * 328 * Returns: 329 * A pointer to the newly created property on success, NULL on failure. 330 */ 331 struct drm_property *drm_property_create_object(struct drm_device *dev, 332 u32 flags, const char *name, 333 uint32_t type) 334 { 335 struct drm_property *property; 336 337 flags |= DRM_MODE_PROP_OBJECT; 338 339 if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC))) 340 return NULL; 341 342 property = drm_property_create(dev, flags, name, 1); 343 if (!property) 344 return NULL; 345 346 property->values[0] = type; 347 348 return property; 349 } 350 EXPORT_SYMBOL(drm_property_create_object); 351 352 /** 353 * drm_property_create_bool - create a new boolean property type 354 * @dev: drm device 355 * @flags: flags specifying the property type 356 * @name: name of the property 357 * 358 * This creates a new generic drm property which can then be attached to a drm 359 * object with drm_object_attach_property(). The returned property object must 360 * be freed with drm_property_destroy(), which is done automatically when 361 * calling drm_mode_config_cleanup(). 362 * 363 * This is implemented as a ranged property with only {0, 1} as valid values. 364 * 365 * Returns: 366 * A pointer to the newly created property on success, NULL on failure. 367 */ 368 struct drm_property *drm_property_create_bool(struct drm_device *dev, 369 u32 flags, const char *name) 370 { 371 return drm_property_create_range(dev, flags, name, 0, 1); 372 } 373 EXPORT_SYMBOL(drm_property_create_bool); 374 375 /** 376 * drm_property_add_enum - add a possible value to an enumeration property 377 * @property: enumeration property to change 378 * @value: value of the new enumeration 379 * @name: symbolic name of the new enumeration 380 * 381 * This functions adds enumerations to a property. 382 * 383 * It's use is deprecated, drivers should use one of the more specific helpers 384 * to directly create the property with all enumerations already attached. 385 * 386 * Returns: 387 * Zero on success, error code on failure. 388 */ 389 int drm_property_add_enum(struct drm_property *property, 390 uint64_t value, const char *name) 391 { 392 struct drm_property_enum *prop_enum; 393 int index = 0; 394 395 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN)) 396 return -EINVAL; 397 398 if (WARN_ON(!drm_property_type_is(property, DRM_MODE_PROP_ENUM) && 399 !drm_property_type_is(property, DRM_MODE_PROP_BITMASK))) 400 return -EINVAL; 401 402 /* 403 * Bitmask enum properties have the additional constraint of values 404 * from 0 to 63 405 */ 406 if (WARN_ON(drm_property_type_is(property, DRM_MODE_PROP_BITMASK) && 407 value > 63)) 408 return -EINVAL; 409 410 list_for_each_entry(prop_enum, &property->enum_list, head) { 411 if (WARN_ON(prop_enum->value == value)) 412 return -EINVAL; 413 index++; 414 } 415 416 if (WARN_ON(index >= property->num_values)) 417 return -EINVAL; 418 419 prop_enum = kzalloc_obj(struct drm_property_enum); 420 if (!prop_enum) 421 return -ENOMEM; 422 423 strscpy_pad(prop_enum->name, name, DRM_PROP_NAME_LEN); 424 prop_enum->value = value; 425 426 property->values[index] = value; 427 list_add_tail(&prop_enum->head, &property->enum_list); 428 return 0; 429 } 430 EXPORT_SYMBOL(drm_property_add_enum); 431 432 /** 433 * drm_property_destroy - destroy a drm property 434 * @dev: drm device 435 * @property: property to destroy 436 * 437 * This function frees a property including any attached resources like 438 * enumeration values. 439 */ 440 void drm_property_destroy(struct drm_device *dev, struct drm_property *property) 441 { 442 struct drm_property_enum *prop_enum, *pt; 443 444 list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) { 445 list_del(&prop_enum->head); 446 kfree(prop_enum); 447 } 448 449 if (property->num_values) 450 kfree(property->values); 451 drm_mode_object_unregister(dev, &property->base); 452 list_del(&property->head); 453 kfree(property); 454 } 455 EXPORT_SYMBOL(drm_property_destroy); 456 457 int drm_mode_getproperty_ioctl(struct drm_device *dev, 458 void *data, struct drm_file *file_priv) 459 { 460 struct drm_mode_get_property *out_resp = data; 461 struct drm_property *property; 462 int enum_count = 0; 463 int value_count = 0; 464 int i, copied; 465 struct drm_property_enum *prop_enum; 466 struct drm_mode_property_enum __user *enum_ptr; 467 uint64_t __user *values_ptr; 468 469 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 470 return -EOPNOTSUPP; 471 472 property = drm_property_find(dev, file_priv, out_resp->prop_id); 473 if (!property) 474 return -ENOENT; 475 476 strscpy_pad(out_resp->name, property->name, DRM_PROP_NAME_LEN); 477 out_resp->flags = property->flags; 478 479 value_count = property->num_values; 480 values_ptr = u64_to_user_ptr(out_resp->values_ptr); 481 482 for (i = 0; i < value_count; i++) { 483 if (i < out_resp->count_values && 484 put_user(property->values[i], values_ptr + i)) { 485 return -EFAULT; 486 } 487 } 488 out_resp->count_values = value_count; 489 490 copied = 0; 491 enum_ptr = u64_to_user_ptr(out_resp->enum_blob_ptr); 492 493 if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 494 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 495 list_for_each_entry(prop_enum, &property->enum_list, head) { 496 enum_count++; 497 if (out_resp->count_enum_blobs < enum_count) 498 continue; 499 500 if (copy_to_user(&enum_ptr[copied].value, 501 &prop_enum->value, sizeof(uint64_t))) 502 return -EFAULT; 503 504 if (copy_to_user(&enum_ptr[copied].name, 505 &prop_enum->name, DRM_PROP_NAME_LEN)) 506 return -EFAULT; 507 copied++; 508 } 509 out_resp->count_enum_blobs = enum_count; 510 } 511 512 /* 513 * NOTE: The idea seems to have been to use this to read all the blob 514 * property values. But nothing ever added them to the corresponding 515 * list, userspace always used the special-purpose get_blob ioctl to 516 * read the value for a blob property. It also doesn't make a lot of 517 * sense to return values here when everything else is just metadata for 518 * the property itself. 519 */ 520 if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) 521 out_resp->count_enum_blobs = 0; 522 523 return 0; 524 } 525 526 static void drm_property_free_blob(struct kref *kref) 527 { 528 struct drm_property_blob *blob = 529 container_of(kref, struct drm_property_blob, base.refcount); 530 531 mutex_lock(&blob->dev->mode_config.blob_lock); 532 list_del(&blob->head_global); 533 mutex_unlock(&blob->dev->mode_config.blob_lock); 534 535 drm_mode_object_unregister(blob->dev, &blob->base); 536 537 kvfree(blob); 538 } 539 540 /** 541 * drm_property_create_blob - Create new blob property 542 * @dev: DRM device to create property for 543 * @length: Length to allocate for blob data 544 * @data: If specified, copies data into blob 545 * 546 * Creates a new blob property for a specified DRM device, optionally 547 * copying data. Note that blob properties are meant to be invariant, hence the 548 * data must be filled out before the blob is used as the value of any property. 549 * 550 * Returns: 551 * New blob property with a single reference on success, or an ERR_PTR 552 * value on failure. 553 */ 554 struct drm_property_blob * 555 drm_property_create_blob(struct drm_device *dev, size_t length, 556 const void *data) 557 { 558 struct drm_property_blob *blob; 559 int ret; 560 561 if (!length || length > INT_MAX - sizeof(struct drm_property_blob)) 562 return ERR_PTR(-EINVAL); 563 564 blob = kvzalloc(sizeof(struct drm_property_blob) + length, GFP_KERNEL_ACCOUNT); 565 if (!blob) 566 return ERR_PTR(-ENOMEM); 567 568 /* This must be explicitly initialised, so we can safely call list_del 569 * on it in the removal handler, even if it isn't in a file list. */ 570 INIT_LIST_HEAD(&blob->head_file); 571 blob->data = (void *)blob + sizeof(*blob); 572 blob->length = length; 573 blob->dev = dev; 574 575 if (data) 576 memcpy(blob->data, data, length); 577 578 ret = __drm_mode_object_add(dev, &blob->base, DRM_MODE_OBJECT_BLOB, 579 true, drm_property_free_blob); 580 if (ret) { 581 kvfree(blob); 582 return ERR_PTR(-EINVAL); 583 } 584 585 mutex_lock(&dev->mode_config.blob_lock); 586 list_add_tail(&blob->head_global, 587 &dev->mode_config.property_blob_list); 588 mutex_unlock(&dev->mode_config.blob_lock); 589 590 return blob; 591 } 592 EXPORT_SYMBOL(drm_property_create_blob); 593 594 /** 595 * drm_property_blob_put - release a blob property reference 596 * @blob: DRM blob property 597 * 598 * Releases a reference to a blob property. May free the object. 599 */ 600 void drm_property_blob_put(struct drm_property_blob *blob) 601 { 602 if (!blob) 603 return; 604 605 drm_mode_object_put(&blob->base); 606 } 607 EXPORT_SYMBOL(drm_property_blob_put); 608 609 void drm_property_destroy_user_blobs(struct drm_device *dev, 610 struct drm_file *file_priv) 611 { 612 struct drm_property_blob *blob, *bt; 613 614 /* 615 * When the file gets released that means no one else can access the 616 * blob list any more, so no need to grab dev->blob_lock. 617 */ 618 list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) { 619 list_del_init(&blob->head_file); 620 drm_property_blob_put(blob); 621 } 622 } 623 624 /** 625 * drm_property_blob_get - acquire blob property reference 626 * @blob: DRM blob property 627 * 628 * Acquires a reference to an existing blob property. Returns @blob, which 629 * allows this to be used as a shorthand in assignments. 630 */ 631 struct drm_property_blob *drm_property_blob_get(struct drm_property_blob *blob) 632 { 633 drm_mode_object_get(&blob->base); 634 return blob; 635 } 636 EXPORT_SYMBOL(drm_property_blob_get); 637 638 /** 639 * drm_property_lookup_blob - look up a blob property and take a reference 640 * @dev: drm device 641 * @id: id of the blob property 642 * 643 * If successful, this takes an additional reference to the blob property. 644 * callers need to make sure to eventually unreferenced the returned property 645 * again, using drm_property_blob_put(). 646 * 647 * Return: 648 * NULL on failure, pointer to the blob on success. 649 */ 650 struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev, 651 uint32_t id) 652 { 653 struct drm_mode_object *obj; 654 struct drm_property_blob *blob = NULL; 655 656 obj = __drm_mode_object_find(dev, NULL, id, DRM_MODE_OBJECT_BLOB); 657 if (obj) 658 blob = obj_to_blob(obj); 659 return blob; 660 } 661 EXPORT_SYMBOL(drm_property_lookup_blob); 662 663 /** 664 * drm_property_replace_global_blob - replace existing blob property 665 * @dev: drm device 666 * @replace: location of blob property pointer to be replaced 667 * @length: length of data for new blob, or 0 for no data 668 * @data: content for new blob, or NULL for no data 669 * @obj_holds_id: optional object for property holding blob ID 670 * @prop_holds_id: optional property holding blob ID 671 * @return 0 on success or error on failure 672 * 673 * This function will replace a global property in the blob list, optionally 674 * updating a property which holds the ID of that property. 675 * 676 * If length is 0 or data is NULL, no new blob will be created, and the holding 677 * property, if specified, will be set to 0. 678 * 679 * Access to the replace pointer is assumed to be protected by the caller, e.g. 680 * by holding the relevant modesetting object lock for its parent. 681 * 682 * For example, a drm_connector has a 'PATH' property, which contains the ID 683 * of a blob property with the value of the MST path information. Calling this 684 * function with replace pointing to the connector's path_blob_ptr, length and 685 * data set for the new path information, obj_holds_id set to the connector's 686 * base object, and prop_holds_id set to the path property name, will perform 687 * a completely atomic update. The access to path_blob_ptr is protected by the 688 * caller holding a lock on the connector. 689 */ 690 int drm_property_replace_global_blob(struct drm_device *dev, 691 struct drm_property_blob **replace, 692 size_t length, 693 const void *data, 694 struct drm_mode_object *obj_holds_id, 695 struct drm_property *prop_holds_id) 696 { 697 struct drm_property_blob *new_blob = NULL; 698 struct drm_property_blob *old_blob = NULL; 699 int ret; 700 701 WARN_ON(replace == NULL); 702 703 old_blob = *replace; 704 705 if (length && data) { 706 new_blob = drm_property_create_blob(dev, length, data); 707 if (IS_ERR(new_blob)) 708 return PTR_ERR(new_blob); 709 } 710 711 if (obj_holds_id) { 712 ret = drm_object_property_set_value(obj_holds_id, 713 prop_holds_id, 714 new_blob ? 715 new_blob->base.id : 0); 716 if (ret != 0) 717 goto err_created; 718 } 719 720 drm_property_blob_put(old_blob); 721 *replace = new_blob; 722 723 return 0; 724 725 err_created: 726 drm_property_blob_put(new_blob); 727 return ret; 728 } 729 EXPORT_SYMBOL(drm_property_replace_global_blob); 730 731 /** 732 * drm_property_replace_blob - replace a blob property 733 * @blob: a pointer to the member blob to be replaced 734 * @new_blob: the new blob to replace with 735 * 736 * Return: true if the blob was in fact replaced. 737 */ 738 bool drm_property_replace_blob(struct drm_property_blob **blob, 739 struct drm_property_blob *new_blob) 740 { 741 struct drm_property_blob *old_blob = *blob; 742 743 if (old_blob == new_blob) 744 return false; 745 746 drm_property_blob_put(old_blob); 747 if (new_blob) 748 drm_property_blob_get(new_blob); 749 *blob = new_blob; 750 return true; 751 } 752 EXPORT_SYMBOL(drm_property_replace_blob); 753 754 /** 755 * drm_property_replace_blob_from_id - replace a blob property taking a reference 756 * @dev: DRM device 757 * @blob: a pointer to the member blob to be replaced 758 * @blob_id: the id of the new blob to replace with 759 * @max_size: the maximum size of the blob property for variable-size blobs 760 * @expected_size: expected size of the blob property 761 * @expected_elem_size: expected size of an element in the blob property 762 * @replaced: if the blob was in fact replaced 763 * 764 * Look up the new blob from id, take its reference, check expected sizes of 765 * the blob and its element and replace the old blob by the new one. Advertise 766 * if the replacement operation was successful. 767 * 768 * Return: true if the blob was in fact replaced. -EINVAL if the new blob was 769 * not found or sizes don't match. 770 */ 771 int drm_property_replace_blob_from_id(struct drm_device *dev, 772 struct drm_property_blob **blob, 773 uint64_t blob_id, 774 ssize_t max_size, 775 ssize_t expected_size, 776 ssize_t expected_elem_size, 777 bool *replaced) 778 { 779 struct drm_property_blob *new_blob = NULL; 780 781 if (blob_id != 0) { 782 new_blob = drm_property_lookup_blob(dev, blob_id); 783 if (new_blob == NULL) { 784 drm_dbg_atomic(dev, 785 "cannot find blob ID %llu\n", blob_id); 786 return -EINVAL; 787 } 788 789 if (max_size > 0 && 790 new_blob->length > max_size) { 791 drm_dbg_atomic(dev, 792 "[BLOB:%d] length %zu greater than max %zu\n", 793 new_blob->base.id, new_blob->length, max_size); 794 drm_property_blob_put(new_blob); 795 return -EINVAL; 796 } 797 798 if (expected_size > 0 && 799 new_blob->length != expected_size) { 800 drm_dbg_atomic(dev, 801 "[BLOB:%d] length %zu different from expected %zu\n", 802 new_blob->base.id, new_blob->length, expected_size); 803 drm_property_blob_put(new_blob); 804 return -EINVAL; 805 } 806 if (expected_elem_size > 0 && 807 new_blob->length % expected_elem_size != 0) { 808 drm_dbg_atomic(dev, 809 "[BLOB:%d] length %zu not divisible by element size %zu\n", 810 new_blob->base.id, new_blob->length, expected_elem_size); 811 drm_property_blob_put(new_blob); 812 return -EINVAL; 813 } 814 } 815 816 *replaced |= drm_property_replace_blob(blob, new_blob); 817 drm_property_blob_put(new_blob); 818 819 return 0; 820 } 821 EXPORT_SYMBOL(drm_property_replace_blob_from_id); 822 823 int drm_mode_getblob_ioctl(struct drm_device *dev, 824 void *data, struct drm_file *file_priv) 825 { 826 struct drm_mode_get_blob *out_resp = data; 827 struct drm_property_blob *blob; 828 int ret = 0; 829 830 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 831 return -EOPNOTSUPP; 832 833 blob = drm_property_lookup_blob(dev, out_resp->blob_id); 834 if (!blob) 835 return -ENOENT; 836 837 if (out_resp->length == blob->length) { 838 if (copy_to_user(u64_to_user_ptr(out_resp->data), 839 blob->data, 840 blob->length)) { 841 ret = -EFAULT; 842 goto unref; 843 } 844 } 845 out_resp->length = blob->length; 846 unref: 847 drm_property_blob_put(blob); 848 849 return ret; 850 } 851 852 int drm_mode_createblob_ioctl(struct drm_device *dev, 853 void *data, struct drm_file *file_priv) 854 { 855 struct drm_mode_create_blob *out_resp = data; 856 struct drm_property_blob *blob; 857 int ret = 0; 858 859 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 860 return -EOPNOTSUPP; 861 862 blob = drm_property_create_blob(dev, out_resp->length, NULL); 863 if (IS_ERR(blob)) 864 return PTR_ERR(blob); 865 866 if (copy_from_user(blob->data, 867 u64_to_user_ptr(out_resp->data), 868 out_resp->length)) { 869 ret = -EFAULT; 870 goto out_blob; 871 } 872 873 /* Dropping the lock between create_blob and our access here is safe 874 * as only the same file_priv can remove the blob; at this point, it is 875 * not associated with any file_priv. */ 876 mutex_lock(&dev->mode_config.blob_lock); 877 out_resp->blob_id = blob->base.id; 878 list_add_tail(&blob->head_file, &file_priv->blobs); 879 mutex_unlock(&dev->mode_config.blob_lock); 880 881 return 0; 882 883 out_blob: 884 drm_property_blob_put(blob); 885 return ret; 886 } 887 888 int drm_mode_destroyblob_ioctl(struct drm_device *dev, 889 void *data, struct drm_file *file_priv) 890 { 891 struct drm_mode_destroy_blob *out_resp = data; 892 struct drm_property_blob *blob = NULL, *bt; 893 bool found = false; 894 int ret = 0; 895 896 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 897 return -EOPNOTSUPP; 898 899 blob = drm_property_lookup_blob(dev, out_resp->blob_id); 900 if (!blob) 901 return -ENOENT; 902 903 mutex_lock(&dev->mode_config.blob_lock); 904 /* Ensure the property was actually created by this user. */ 905 list_for_each_entry(bt, &file_priv->blobs, head_file) { 906 if (bt == blob) { 907 found = true; 908 break; 909 } 910 } 911 912 if (!found) { 913 ret = -EPERM; 914 goto err; 915 } 916 917 /* We must drop head_file here, because we may not be the last 918 * reference on the blob. */ 919 list_del_init(&blob->head_file); 920 mutex_unlock(&dev->mode_config.blob_lock); 921 922 /* One reference from lookup, and one from the filp. */ 923 drm_property_blob_put(blob); 924 drm_property_blob_put(blob); 925 926 return 0; 927 928 err: 929 mutex_unlock(&dev->mode_config.blob_lock); 930 drm_property_blob_put(blob); 931 932 return ret; 933 } 934 935 /* Some properties could refer to dynamic refcnt'd objects, or things that 936 * need special locking to handle lifetime issues (ie. to ensure the prop 937 * value doesn't become invalid part way through the property update due to 938 * race). The value returned by reference via 'obj' should be passed back 939 * to drm_property_change_valid_put() after the property is set (and the 940 * object to which the property is attached has a chance to take its own 941 * reference). 942 */ 943 bool drm_property_change_valid_get(struct drm_property *property, 944 uint64_t value, struct drm_mode_object **ref) 945 { 946 int i; 947 948 if (property->flags & DRM_MODE_PROP_IMMUTABLE) 949 return false; 950 951 *ref = NULL; 952 953 if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) { 954 if (value < property->values[0] || value > property->values[1]) 955 return false; 956 return true; 957 } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) { 958 int64_t svalue = U642I64(value); 959 960 if (svalue < U642I64(property->values[0]) || 961 svalue > U642I64(property->values[1])) 962 return false; 963 return true; 964 } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 965 uint64_t valid_mask = 0; 966 967 for (i = 0; i < property->num_values; i++) 968 valid_mask |= (1ULL << property->values[i]); 969 return !(value & ~valid_mask); 970 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) { 971 struct drm_property_blob *blob; 972 973 if (value == 0) 974 return true; 975 976 blob = drm_property_lookup_blob(property->dev, value); 977 if (blob) { 978 *ref = &blob->base; 979 return true; 980 } else { 981 return false; 982 } 983 } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { 984 /* a zero value for an object property translates to null: */ 985 if (value == 0) 986 return true; 987 988 *ref = __drm_mode_object_find(property->dev, NULL, value, 989 property->values[0]); 990 return *ref != NULL; 991 } 992 993 for (i = 0; i < property->num_values; i++) 994 if (property->values[i] == value) 995 return true; 996 return false; 997 } 998 999 void drm_property_change_valid_put(struct drm_property *property, 1000 struct drm_mode_object *ref) 1001 { 1002 if (!ref) 1003 return; 1004 1005 if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { 1006 drm_mode_object_put(ref); 1007 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) 1008 drm_property_blob_put(obj_to_blob(ref)); 1009 } 1010