1 // SPDX-License-Identifier: GPL-2.0-only
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.
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.
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>
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>
33 #include "drm_internal.h"
34 #include "drm_crtc_internal.h"
36 #define to_drm_minor(d) dev_get_drvdata(d)
37 #define to_drm_connector(d) dev_get_drvdata(d)
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.
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().
53 static struct device_type drm_sysfs_device_minor = {
57 static struct device_type drm_sysfs_device_connector = {
58 .name = "drm_connector",
61 struct class *drm_class;
64 static bool drm_connector_acpi_bus_match(struct device *dev)
66 return dev->type == &drm_sysfs_device_connector;
69 static struct acpi_device *drm_connector_acpi_find_companion(struct device *dev)
71 struct drm_connector *connector = to_drm_connector(dev);
73 return to_acpi_device_node(connector->fwnode);
76 static 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,
82 static void drm_sysfs_acpi_register(void)
84 register_acpi_bus_type(&drm_connector_acpi_bus);
87 static void drm_sysfs_acpi_unregister(void)
89 unregister_acpi_bus_type(&drm_connector_acpi_bus);
92 static void drm_sysfs_acpi_register(void) { }
93 static void drm_sysfs_acpi_unregister(void) { }
96 static char *drm_devnode(const struct device *dev, umode_t *mode)
98 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
101 static int typec_connector_bind(struct device *dev,
102 struct device *typec_connector, void *data)
106 ret = sysfs_create_link(&dev->kobj, &typec_connector->kobj, "typec_connector");
110 ret = sysfs_create_link(&typec_connector->kobj, &dev->kobj, "drm_connector");
112 sysfs_remove_link(&dev->kobj, "typec_connector");
117 static void typec_connector_unbind(struct device *dev,
118 struct device *typec_connector, void *data)
120 sysfs_remove_link(&typec_connector->kobj, "drm_connector");
121 sysfs_remove_link(&dev->kobj, "typec_connector");
124 static const struct component_ops typec_connector_ops = {
125 .bind = typec_connector_bind,
126 .unbind = typec_connector_unbind,
129 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810");
132 * drm_sysfs_init - initialize sysfs helpers
134 * This is used to create the DRM class, which is the implicit parent of any
135 * other top-level DRM sysfs objects.
137 * You must call drm_sysfs_destroy() to release the allocated resources.
139 * Return: 0 on success, negative error code on failure.
141 int drm_sysfs_init(void)
145 drm_class = class_create("drm");
146 if (IS_ERR(drm_class))
147 return PTR_ERR(drm_class);
149 err = class_create_file(drm_class, &class_attr_version.attr);
151 class_destroy(drm_class);
156 drm_class->devnode = drm_devnode;
158 drm_sysfs_acpi_register();
163 * drm_sysfs_destroy - destroys DRM class
165 * Destroy the DRM device class.
167 void drm_sysfs_destroy(void)
169 if (IS_ERR_OR_NULL(drm_class))
171 drm_sysfs_acpi_unregister();
172 class_remove_file(drm_class, &class_attr_version.attr);
173 class_destroy(drm_class);
177 static void drm_sysfs_release(struct device *dev)
183 * Connector properties
185 static ssize_t status_store(struct device *device,
186 struct device_attribute *attr,
187 const char *buf, size_t count)
189 struct drm_connector *connector = to_drm_connector(device);
190 struct drm_device *dev = connector->dev;
191 enum drm_connector_force old_force;
194 ret = mutex_lock_interruptible(&dev->mode_config.mutex);
198 old_force = connector->force;
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;
211 if (old_force != connector->force || !connector->force) {
212 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
215 old_force, connector->force);
217 connector->funcs->fill_modes(connector,
218 dev->mode_config.max_width,
219 dev->mode_config.max_height);
222 mutex_unlock(&dev->mode_config.mutex);
224 return ret ? ret : count;
227 static ssize_t status_show(struct device *device,
228 struct device_attribute *attr,
231 struct drm_connector *connector = to_drm_connector(device);
232 enum drm_connector_status status;
234 status = READ_ONCE(connector->status);
236 return sysfs_emit(buf, "%s\n",
237 drm_get_connector_status_name(status));
240 static ssize_t dpms_show(struct device *device,
241 struct device_attribute *attr,
244 struct drm_connector *connector = to_drm_connector(device);
247 dpms = READ_ONCE(connector->dpms);
249 return sysfs_emit(buf, "%s\n", drm_get_dpms_name(dpms));
252 static ssize_t enabled_show(struct device *device,
253 struct device_attribute *attr,
256 struct drm_connector *connector = to_drm_connector(device);
259 enabled = READ_ONCE(connector->encoder);
261 return sysfs_emit(buf, enabled ? "enabled\n" : "disabled\n");
264 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
265 struct bin_attribute *attr, char *buf, loff_t off,
268 struct device *connector_dev = kobj_to_dev(kobj);
269 struct drm_connector *connector = to_drm_connector(connector_dev);
274 mutex_lock(&connector->dev->mode_config.mutex);
275 if (!connector->edid_blob_ptr)
278 edid = connector->edid_blob_ptr->data;
279 size = connector->edid_blob_ptr->length;
286 if (off + count > size)
288 memcpy(buf, edid + off, count);
292 mutex_unlock(&connector->dev->mode_config.mutex);
297 static ssize_t modes_show(struct device *device,
298 struct device_attribute *attr,
301 struct drm_connector *connector = to_drm_connector(device);
302 struct drm_display_mode *mode;
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",
310 mutex_unlock(&connector->dev->mode_config.mutex);
315 static ssize_t connector_id_show(struct device *device,
316 struct device_attribute *attr,
319 struct drm_connector *connector = to_drm_connector(device);
321 return sysfs_emit(buf, "%d\n", connector->base.id);
324 static DEVICE_ATTR_RW(status);
325 static DEVICE_ATTR_RO(enabled);
326 static DEVICE_ATTR_RO(dpms);
327 static DEVICE_ATTR_RO(modes);
328 static DEVICE_ATTR_RO(connector_id);
330 static struct attribute *connector_dev_attrs[] = {
331 &dev_attr_status.attr,
332 &dev_attr_enabled.attr,
334 &dev_attr_modes.attr,
335 &dev_attr_connector_id.attr,
339 static struct bin_attribute edid_attr = {
346 static struct bin_attribute *connector_bin_attrs[] = {
351 static const struct attribute_group connector_dev_group = {
352 .attrs = connector_dev_attrs,
353 .bin_attrs = connector_bin_attrs,
356 static const struct attribute_group *connector_dev_groups[] = {
357 &connector_dev_group,
361 int drm_sysfs_connector_add(struct drm_connector *connector)
363 struct drm_device *dev = connector->dev;
370 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
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);
382 r = dev_set_name(kdev, "card%d-%s", dev->primary->index, connector->name);
386 DRM_DEBUG("adding \"%s\" to sysfs\n",
389 r = device_add(kdev);
391 drm_err(dev, "failed to register connector device: %d\n", r);
395 connector->kdev = kdev;
397 if (dev_fwnode(kdev)) {
398 r = component_add(kdev, &typec_connector_ops);
400 drm_err(dev, "failed to add component to create link to typec connector\n");
404 return sysfs_create_link(&connector->kdev->kobj,
405 &connector->ddc->dev.kobj, "ddc");
414 void drm_sysfs_connector_remove(struct drm_connector *connector)
416 if (!connector->kdev)
420 sysfs_remove_link(&connector->kdev->kobj, "ddc");
422 if (dev_fwnode(connector->kdev))
423 component_del(connector->kdev, &typec_connector_ops);
425 DRM_DEBUG("removing \"%s\" from sysfs\n",
428 device_unregister(connector->kdev);
429 connector->kdev = NULL;
432 void drm_sysfs_lease_event(struct drm_device *dev)
434 char *event_string = "LEASE=1";
435 char *envp[] = { event_string, NULL };
437 DRM_DEBUG("generating lease event\n");
439 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
443 * drm_sysfs_hotplug_event - generate a DRM uevent
446 * Send a uevent for the DRM device specified by @dev. Currently we only
447 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
448 * deal with other types of events.
450 * Any new uapi should be using the drm_sysfs_connector_status_event()
451 * for uevents on connector status change.
453 void drm_sysfs_hotplug_event(struct drm_device *dev)
455 char *event_string = "HOTPLUG=1";
456 char *envp[] = { event_string, NULL };
458 DRM_DEBUG("generating hotplug event\n");
460 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
462 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
465 * drm_sysfs_connector_hotplug_event - generate a DRM uevent for any connector
467 * @connector: connector which has changed
469 * Send a uevent for the DRM connector specified by @connector. This will send
470 * a uevent with the properties HOTPLUG=1 and CONNECTOR.
472 void drm_sysfs_connector_hotplug_event(struct drm_connector *connector)
474 struct drm_device *dev = connector->dev;
475 char hotplug_str[] = "HOTPLUG=1", conn_id[21];
476 char *envp[] = { hotplug_str, conn_id, NULL };
478 snprintf(conn_id, sizeof(conn_id),
479 "CONNECTOR=%u", connector->base.id);
481 drm_dbg_kms(connector->dev,
482 "[CONNECTOR:%d:%s] generating connector hotplug event\n",
483 connector->base.id, connector->name);
485 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
487 EXPORT_SYMBOL(drm_sysfs_connector_hotplug_event);
490 * drm_sysfs_connector_status_event - generate a DRM uevent for connector
491 * property status change
492 * @connector: connector on which property status changed
493 * @property: connector property whose status changed.
495 * Send a uevent for the DRM device specified by @dev. Currently we
496 * set HOTPLUG=1 and connector id along with the attached property id
497 * related to the status change.
499 void drm_sysfs_connector_status_event(struct drm_connector *connector,
500 struct drm_property *property)
502 struct drm_device *dev = connector->dev;
503 char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21];
504 char *envp[4] = { hotplug_str, conn_id, prop_id, NULL };
506 WARN_ON(!drm_mode_obj_find_prop_id(&connector->base,
509 snprintf(conn_id, ARRAY_SIZE(conn_id),
510 "CONNECTOR=%u", connector->base.id);
511 snprintf(prop_id, ARRAY_SIZE(prop_id),
512 "PROPERTY=%u", property->base.id);
514 DRM_DEBUG("generating connector status event\n");
516 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
518 EXPORT_SYMBOL(drm_sysfs_connector_status_event);
520 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
522 const char *minor_str;
526 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
528 return ERR_PTR(-ENOMEM);
530 device_initialize(kdev);
532 if (minor->type == DRM_MINOR_ACCEL) {
533 minor_str = "accel%d";
534 accel_set_device_instance_params(kdev, minor->index);
536 if (minor->type == DRM_MINOR_RENDER)
537 minor_str = "renderD%d";
539 minor_str = "card%d";
541 kdev->devt = MKDEV(DRM_MAJOR, minor->index);
542 kdev->class = drm_class;
543 kdev->type = &drm_sysfs_device_minor;
546 kdev->parent = minor->dev->dev;
547 kdev->release = drm_sysfs_release;
548 dev_set_drvdata(kdev, minor);
550 r = dev_set_name(kdev, minor_str, minor->index);
562 * drm_class_device_register - register new device with the DRM sysfs class
563 * @dev: device to register
565 * Registers a new &struct device within the DRM sysfs class. Essentially only
566 * used by ttm to have a place for its global settings. Drivers should never use
569 int drm_class_device_register(struct device *dev)
571 if (!drm_class || IS_ERR(drm_class))
574 dev->class = drm_class;
575 return device_register(dev);
577 EXPORT_SYMBOL_GPL(drm_class_device_register);
580 * drm_class_device_unregister - unregister device with the DRM sysfs class
581 * @dev: device to unregister
583 * Unregisters a &struct device from the DRM sysfs class. Essentially only used
584 * by ttm to have a place for its global settings. Drivers should never use
587 void drm_class_device_unregister(struct device *dev)
589 return device_unregister(dev);
591 EXPORT_SYMBOL_GPL(drm_class_device_unregister);