1// SPDX-License-Identifier: GPL-2.0-only 2 3/* 4 * drm_sysfs.c - Modifications to drm_sysfs_class.c to support 5 * extra sysfs attribute from DRM. Normal drm_sysfs_class 6 * does not allow adding attributes. 7 * 8 * Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com> 9 * Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com> 10 * Copyright (c) 2003-2004 IBM Corp. 11 */ 12 13#include <linux/acpi.h> 14#include <linux/component.h> 15#include <linux/device.h> 16#include <linux/err.h> 17#include <linux/export.h> 18#include <linux/gfp.h> 19#include <linux/i2c.h> 20#include <linux/kdev_t.h> 21#include <linux/property.h> 22#include <linux/slab.h> 23 24#include <drm/drm_accel.h> 25#include <drm/drm_connector.h> 26#include <drm/drm_device.h> 27#include <drm/drm_file.h> 28#include <drm/drm_modes.h> 29#include <drm/drm_print.h> 30#include <drm/drm_property.h> 31#include <drm/drm_sysfs.h> 32 33#include "drm_internal.h" 34#include "drm_crtc_internal.h" 35 36#define to_drm_minor(d) dev_get_drvdata(d) 37#define to_drm_connector(d) dev_get_drvdata(d) 38 39/** 40 * DOC: overview 41 * 42 * DRM provides very little additional support to drivers for sysfs 43 * interactions, beyond just all the standard stuff. Drivers who want to expose 44 * additional sysfs properties and property groups can attach them at either 45 * &drm_device.dev or &drm_connector.kdev. 46 * 47 * Registration is automatically handled when calling drm_dev_register(), or 48 * drm_connector_register() in case of hot-plugged connectors. Unregistration is 49 * also automatically handled by drm_dev_unregister() and 50 * drm_connector_unregister(). 51 */ 52 53static struct device_type drm_sysfs_device_minor = { 54 .name = "drm_minor" 55}; 56 57static struct device_type drm_sysfs_device_connector = { 58 .name = "drm_connector", 59}; 60 61struct class *drm_class; 62 63#ifdef CONFIG_ACPI 64static bool drm_connector_acpi_bus_match(struct device *dev) 65{ 66 return dev->type == &drm_sysfs_device_connector; 67} 68 69static struct acpi_device *drm_connector_acpi_find_companion(struct device *dev) 70{ 71 struct drm_connector *connector = to_drm_connector(dev); 72 73 return to_acpi_device_node(connector->fwnode); 74} 75 76static struct acpi_bus_type drm_connector_acpi_bus = { 77 .name = "drm_connector", 78 .match = drm_connector_acpi_bus_match, 79 .find_companion = drm_connector_acpi_find_companion, 80}; 81 82static void drm_sysfs_acpi_register(void) 83{ 84 register_acpi_bus_type(&drm_connector_acpi_bus); 85} 86 87static void drm_sysfs_acpi_unregister(void) 88{ 89 unregister_acpi_bus_type(&drm_connector_acpi_bus); 90} 91#else 92static void drm_sysfs_acpi_register(void) { } 93static void drm_sysfs_acpi_unregister(void) { } 94#endif 95 96static char *drm_devnode(const struct device *dev, umode_t *mode) 97{ 98 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); 99} 100 101static int typec_connector_bind(struct device *dev, 102 struct device *typec_connector, void *data) 103{ 104 int ret; 105 106 ret = sysfs_create_link(&dev->kobj, &typec_connector->kobj, "typec_connector"); 107 if (ret) 108 return ret; 109 110 ret = sysfs_create_link(&typec_connector->kobj, &dev->kobj, "drm_connector"); 111 if (ret) 112 sysfs_remove_link(&dev->kobj, "typec_connector"); 113 114 return ret; 115} 116 117static void typec_connector_unbind(struct device *dev, 118 struct device *typec_connector, void *data) 119{ 120 sysfs_remove_link(&typec_connector->kobj, "drm_connector"); 121 sysfs_remove_link(&dev->kobj, "typec_connector"); 122} 123 124static const struct component_ops typec_connector_ops = { 125 .bind = typec_connector_bind, 126 .unbind = typec_connector_unbind, 127}; 128 129static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810"); 130 131/** 132 * drm_sysfs_init - initialize sysfs helpers 133 * 134 * This is used to create the DRM class, which is the implicit parent of any 135 * other top-level DRM sysfs objects. 136 * 137 * You must call drm_sysfs_destroy() to release the allocated resources. 138 * 139 * Return: 0 on success, negative error code on failure. 140 */ 141int drm_sysfs_init(void) 142{ 143 int err; 144 145 drm_class = class_create("drm"); 146 if (IS_ERR(drm_class)) 147 return PTR_ERR(drm_class); 148 149 err = class_create_file(drm_class, &class_attr_version.attr); 150 if (err) { 151 class_destroy(drm_class); 152 drm_class = NULL; 153 return err; 154 } 155 156 drm_class->devnode = drm_devnode; 157 158 drm_sysfs_acpi_register(); 159 return 0; 160} 161 162/** 163 * drm_sysfs_destroy - destroys DRM class 164 * 165 * Destroy the DRM device class. 166 */ 167void drm_sysfs_destroy(void) 168{ 169 if (IS_ERR_OR_NULL(drm_class)) 170 return; 171 drm_sysfs_acpi_unregister(); 172 class_remove_file(drm_class, &class_attr_version.attr); 173 class_destroy(drm_class); 174 drm_class = NULL; 175} 176 177static void drm_sysfs_release(struct device *dev) 178{ 179 kfree(dev); 180} 181 182/* 183 * Connector properties 184 */ 185static ssize_t status_store(struct device *device, 186 struct device_attribute *attr, 187 const char *buf, size_t count) 188{ 189 struct drm_connector *connector = to_drm_connector(device); 190 struct drm_device *dev = connector->dev; 191 enum drm_connector_force old_force; 192 int ret; 193 194 ret = mutex_lock_interruptible(&dev->mode_config.mutex); 195 if (ret) 196 return ret; 197 198 old_force = connector->force; 199 200 if (sysfs_streq(buf, "detect")) 201 connector->force = 0; 202 else if (sysfs_streq(buf, "on")) 203 connector->force = DRM_FORCE_ON; 204 else if (sysfs_streq(buf, "on-digital")) 205 connector->force = DRM_FORCE_ON_DIGITAL; 206 else if (sysfs_streq(buf, "off")) 207 connector->force = DRM_FORCE_OFF; 208 else 209 ret = -EINVAL; 210 211 if (old_force != connector->force || !connector->force) { 212 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n", 213 connector->base.id, 214 connector->name, 215 old_force, connector->force); 216 217 connector->funcs->fill_modes(connector, 218 dev->mode_config.max_width, 219 dev->mode_config.max_height); 220 } 221 222 mutex_unlock(&dev->mode_config.mutex); 223 224 return ret ? ret : count; 225} 226 227static ssize_t status_show(struct device *device, 228 struct device_attribute *attr, 229 char *buf) 230{ 231 struct drm_connector *connector = to_drm_connector(device); 232 enum drm_connector_status status; 233 234 status = READ_ONCE(connector->status); 235 236 return sysfs_emit(buf, "%s\n", 237 drm_get_connector_status_name(status)); 238} 239 240static ssize_t dpms_show(struct device *device, 241 struct device_attribute *attr, 242 char *buf) 243{ 244 struct drm_connector *connector = to_drm_connector(device); 245 int dpms; 246 247 dpms = READ_ONCE(connector->dpms); 248 249 return sysfs_emit(buf, "%s\n", drm_get_dpms_name(dpms)); 250} 251 252static ssize_t enabled_show(struct device *device, 253 struct device_attribute *attr, 254 char *buf) 255{ 256 struct drm_connector *connector = to_drm_connector(device); 257 bool enabled; 258 259 enabled = READ_ONCE(connector->encoder); 260 261 return sysfs_emit(buf, enabled ? "enabled\n" : "disabled\n"); 262} 263 264static ssize_t edid_show(struct file *filp, struct kobject *kobj, 265 struct bin_attribute *attr, char *buf, loff_t off, 266 size_t count) 267{ 268 struct device *connector_dev = kobj_to_dev(kobj); 269 struct drm_connector *connector = to_drm_connector(connector_dev); 270 unsigned char *edid; 271 size_t size; 272 ssize_t ret = 0; 273 274 mutex_lock(&connector->dev->mode_config.mutex); 275 if (!connector->edid_blob_ptr) 276 goto unlock; 277 278 edid = connector->edid_blob_ptr->data; 279 size = connector->edid_blob_ptr->length; 280 if (!edid) 281 goto unlock; 282 283 if (off >= size) 284 goto unlock; 285 286 if (off + count > size) 287 count = size - off; 288 memcpy(buf, edid + off, count); 289 290 ret = count; 291unlock: 292 mutex_unlock(&connector->dev->mode_config.mutex); 293 294 return ret; 295} 296 297static ssize_t modes_show(struct device *device, 298 struct device_attribute *attr, 299 char *buf) 300{ 301 struct drm_connector *connector = to_drm_connector(device); 302 struct drm_display_mode *mode; 303 int written = 0; 304 305 mutex_lock(&connector->dev->mode_config.mutex); 306 list_for_each_entry(mode, &connector->modes, head) { 307 written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n", 308 mode->name); 309 } 310 mutex_unlock(&connector->dev->mode_config.mutex); 311 312 return written; 313} 314 315static ssize_t connector_id_show(struct device *device, 316 struct device_attribute *attr, 317 char *buf) 318{ 319 struct drm_connector *connector = to_drm_connector(device); 320 321 return sysfs_emit(buf, "%d\n", connector->base.id); 322} 323 324static DEVICE_ATTR_RW(status); 325static DEVICE_ATTR_RO(enabled); 326static DEVICE_ATTR_RO(dpms); 327static DEVICE_ATTR_RO(modes); 328static DEVICE_ATTR_RO(connector_id); 329 330static struct attribute *connector_dev_attrs[] = { 331 &dev_attr_status.attr, 332 &dev_attr_enabled.attr, 333 &dev_attr_dpms.attr, 334 &dev_attr_modes.attr, 335 &dev_attr_connector_id.attr, 336 NULL 337}; 338 339static struct bin_attribute edid_attr = { 340 .attr.name = "edid", 341 .attr.mode = 0444, 342 .size = 0, 343 .read = edid_show, 344}; 345 346static struct bin_attribute *connector_bin_attrs[] = { 347 &edid_attr, 348 NULL 349}; 350 351static const struct attribute_group connector_dev_group = { 352 .attrs = connector_dev_attrs, 353 .bin_attrs = connector_bin_attrs, 354}; 355 356static const struct attribute_group *connector_dev_groups[] = { 357 &connector_dev_group, 358 NULL 359}; 360 361int drm_sysfs_connector_add(struct drm_connector *connector) 362{ 363 struct drm_device *dev = connector->dev; 364 struct device *kdev; 365 int r; 366 367 if (connector->kdev) 368 return 0; 369 370 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); 371 if (!kdev) 372 return -ENOMEM; 373 374 device_initialize(kdev); 375 kdev->class = drm_class; 376 kdev->type = &drm_sysfs_device_connector; 377 kdev->parent = dev->primary->kdev; 378 kdev->groups = connector_dev_groups; 379 kdev->release = drm_sysfs_release; 380 dev_set_drvdata(kdev, connector); 381 382 r = dev_set_name(kdev, "card%d-%s", dev->primary->index, connector->name); 383 if (r) 384 goto err_free; 385 386 DRM_DEBUG("adding \"%s\" to sysfs\n", 387 connector->name); 388 389 r = device_add(kdev); 390 if (r) { 391 drm_err(dev, "failed to register connector device: %d\n", r); 392 goto err_free; 393 } 394 395 connector->kdev = kdev; 396 397 if (dev_fwnode(kdev)) { 398 r = component_add(kdev, &typec_connector_ops); 399 if (r) 400 drm_err(dev, "failed to add component to create link to typec connector\n"); 401 } 402 403 return 0; 404 405err_free: 406 put_device(kdev); 407 return r; 408} 409 410int drm_sysfs_connector_add_late(struct drm_connector *connector) 411{ 412 if (connector->ddc) 413 return sysfs_create_link(&connector->kdev->kobj, 414 &connector->ddc->dev.kobj, "ddc"); 415 416 return 0; 417} 418 419void drm_sysfs_connector_remove_early(struct drm_connector *connector) 420{ 421 if (connector->ddc) 422 sysfs_remove_link(&connector->kdev->kobj, "ddc"); 423} 424 425void drm_sysfs_connector_remove(struct drm_connector *connector) 426{ 427 if (!connector->kdev) 428 return; 429 430 if (dev_fwnode(connector->kdev)) 431 component_del(connector->kdev, &typec_connector_ops); 432 433 DRM_DEBUG("removing \"%s\" from sysfs\n", 434 connector->name); 435 436 device_unregister(connector->kdev); 437 connector->kdev = NULL; 438} 439 440void drm_sysfs_lease_event(struct drm_device *dev) 441{ 442 char *event_string = "LEASE=1"; 443 char *envp[] = { event_string, NULL }; 444 445 DRM_DEBUG("generating lease event\n"); 446 447 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 448} 449 450/** 451 * drm_sysfs_hotplug_event - generate a DRM uevent 452 * @dev: DRM device 453 * 454 * Send a uevent for the DRM device specified by @dev. Currently we only 455 * set HOTPLUG=1 in the uevent environment, but this could be expanded to 456 * deal with other types of events. 457 * 458 * Any new uapi should be using the drm_sysfs_connector_status_event() 459 * for uevents on connector status change. 460 */ 461void drm_sysfs_hotplug_event(struct drm_device *dev) 462{ 463 char *event_string = "HOTPLUG=1"; 464 char *envp[] = { event_string, NULL }; 465 466 DRM_DEBUG("generating hotplug event\n"); 467 468 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 469} 470EXPORT_SYMBOL(drm_sysfs_hotplug_event); 471 472/** 473 * drm_sysfs_connector_hotplug_event - generate a DRM uevent for any connector 474 * change 475 * @connector: connector which has changed 476 * 477 * Send a uevent for the DRM connector specified by @connector. This will send 478 * a uevent with the properties HOTPLUG=1 and CONNECTOR. 479 */ 480void drm_sysfs_connector_hotplug_event(struct drm_connector *connector) 481{ 482 struct drm_device *dev = connector->dev; 483 char hotplug_str[] = "HOTPLUG=1", conn_id[21]; 484 char *envp[] = { hotplug_str, conn_id, NULL }; 485 486 snprintf(conn_id, sizeof(conn_id), 487 "CONNECTOR=%u", connector->base.id); 488 489 drm_dbg_kms(connector->dev, 490 "[CONNECTOR:%d:%s] generating connector hotplug event\n", 491 connector->base.id, connector->name); 492 493 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 494} 495EXPORT_SYMBOL(drm_sysfs_connector_hotplug_event); 496 497/** 498 * drm_sysfs_connector_property_event - generate a DRM uevent for connector 499 * property change 500 * @connector: connector on which property changed 501 * @property: connector property which has changed. 502 * 503 * Send a uevent for the specified DRM connector and property. Currently we 504 * set HOTPLUG=1 and connector id along with the attached property id 505 * related to the change. 506 */ 507void drm_sysfs_connector_property_event(struct drm_connector *connector, 508 struct drm_property *property) 509{ 510 struct drm_device *dev = connector->dev; 511 char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21]; 512 char *envp[4] = { hotplug_str, conn_id, prop_id, NULL }; 513 514 WARN_ON(!drm_mode_obj_find_prop_id(&connector->base, 515 property->base.id)); 516 517 snprintf(conn_id, ARRAY_SIZE(conn_id), 518 "CONNECTOR=%u", connector->base.id); 519 snprintf(prop_id, ARRAY_SIZE(prop_id), 520 "PROPERTY=%u", property->base.id); 521 522 drm_dbg_kms(connector->dev, 523 "[CONNECTOR:%d:%s] generating connector property event for [PROP:%d:%s]\n", 524 connector->base.id, connector->name, 525 property->base.id, property->name); 526 527 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 528} 529EXPORT_SYMBOL(drm_sysfs_connector_property_event); 530 531struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) 532{ 533 const char *minor_str; 534 struct device *kdev; 535 int r; 536 537 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); 538 if (!kdev) 539 return ERR_PTR(-ENOMEM); 540 541 device_initialize(kdev); 542 543 if (minor->type == DRM_MINOR_ACCEL) { 544 minor_str = "accel%d"; 545 accel_set_device_instance_params(kdev, minor->index); 546 } else { 547 if (minor->type == DRM_MINOR_RENDER) 548 minor_str = "renderD%d"; 549 else 550 minor_str = "card%d"; 551 552 kdev->devt = MKDEV(DRM_MAJOR, minor->index); 553 kdev->class = drm_class; 554 kdev->type = &drm_sysfs_device_minor; 555 } 556 557 kdev->parent = minor->dev->dev; 558 kdev->release = drm_sysfs_release; 559 dev_set_drvdata(kdev, minor); 560 561 r = dev_set_name(kdev, minor_str, minor->index); 562 if (r < 0) 563 goto err_free; 564 565 return kdev; 566 567err_free: 568 put_device(kdev); 569 return ERR_PTR(r); 570} 571 572/** 573 * drm_class_device_register - register new device with the DRM sysfs class 574 * @dev: device to register 575 * 576 * Registers a new &struct device within the DRM sysfs class. Essentially only 577 * used by ttm to have a place for its global settings. Drivers should never use 578 * this. 579 */ 580int drm_class_device_register(struct device *dev) 581{ 582 if (!drm_class || IS_ERR(drm_class)) 583 return -ENOENT; 584 585 dev->class = drm_class; 586 return device_register(dev); 587} 588EXPORT_SYMBOL_GPL(drm_class_device_register); 589 590/** 591 * drm_class_device_unregister - unregister device with the DRM sysfs class 592 * @dev: device to unregister 593 * 594 * Unregisters a &struct device from the DRM sysfs class. Essentially only used 595 * by ttm to have a place for its global settings. Drivers should never use 596 * this. 597 */ 598void drm_class_device_unregister(struct device *dev) 599{ 600 return device_unregister(dev); 601} 602EXPORT_SYMBOL_GPL(drm_class_device_unregister); 603