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/device.h>
15 #include <linux/err.h>
16 #include <linux/export.h>
17 #include <linux/gfp.h>
18 #include <linux/i2c.h>
19 #include <linux/kdev_t.h>
20 #include <linux/slab.h>
22 #include <drm/drm_connector.h>
23 #include <drm/drm_device.h>
24 #include <drm/drm_file.h>
25 #include <drm/drm_modes.h>
26 #include <drm/drm_print.h>
27 #include <drm/drm_property.h>
28 #include <drm/drm_sysfs.h>
30 #include "drm_internal.h"
31 #include "drm_crtc_internal.h"
33 #define to_drm_minor(d) dev_get_drvdata(d)
34 #define to_drm_connector(d) dev_get_drvdata(d)
39 * DRM provides very little additional support to drivers for sysfs
40 * interactions, beyond just all the standard stuff. Drivers who want to expose
41 * additional sysfs properties and property groups can attach them at either
42 * &drm_device.dev or &drm_connector.kdev.
44 * Registration is automatically handled when calling drm_dev_register(), or
45 * drm_connector_register() in case of hot-plugged connectors. Unregistration is
46 * also automatically handled by drm_dev_unregister() and
47 * drm_connector_unregister().
50 static struct device_type drm_sysfs_device_minor = {
54 static struct device_type drm_sysfs_device_connector = {
55 .name = "drm_connector",
58 struct class *drm_class;
61 static bool drm_connector_acpi_bus_match(struct device *dev)
63 return dev->type == &drm_sysfs_device_connector;
66 static struct acpi_device *drm_connector_acpi_find_companion(struct device *dev)
68 struct drm_connector *connector = to_drm_connector(dev);
70 return to_acpi_device_node(connector->fwnode);
73 static struct acpi_bus_type drm_connector_acpi_bus = {
74 .name = "drm_connector",
75 .match = drm_connector_acpi_bus_match,
76 .find_companion = drm_connector_acpi_find_companion,
79 static void drm_sysfs_acpi_register(void)
81 register_acpi_bus_type(&drm_connector_acpi_bus);
84 static void drm_sysfs_acpi_unregister(void)
86 unregister_acpi_bus_type(&drm_connector_acpi_bus);
89 static void drm_sysfs_acpi_register(void) { }
90 static void drm_sysfs_acpi_unregister(void) { }
93 static char *drm_devnode(struct device *dev, umode_t *mode)
95 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
98 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810");
101 * drm_sysfs_init - initialize sysfs helpers
103 * This is used to create the DRM class, which is the implicit parent of any
104 * other top-level DRM sysfs objects.
106 * You must call drm_sysfs_destroy() to release the allocated resources.
108 * Return: 0 on success, negative error code on failure.
110 int drm_sysfs_init(void)
114 drm_class = class_create(THIS_MODULE, "drm");
115 if (IS_ERR(drm_class))
116 return PTR_ERR(drm_class);
118 err = class_create_file(drm_class, &class_attr_version.attr);
120 class_destroy(drm_class);
125 drm_class->devnode = drm_devnode;
127 drm_sysfs_acpi_register();
132 * drm_sysfs_destroy - destroys DRM class
134 * Destroy the DRM device class.
136 void drm_sysfs_destroy(void)
138 if (IS_ERR_OR_NULL(drm_class))
140 drm_sysfs_acpi_unregister();
141 class_remove_file(drm_class, &class_attr_version.attr);
142 class_destroy(drm_class);
146 static void drm_sysfs_release(struct device *dev)
152 * Connector properties
154 static ssize_t status_store(struct device *device,
155 struct device_attribute *attr,
156 const char *buf, size_t count)
158 struct drm_connector *connector = to_drm_connector(device);
159 struct drm_device *dev = connector->dev;
160 enum drm_connector_force old_force;
163 ret = mutex_lock_interruptible(&dev->mode_config.mutex);
167 old_force = connector->force;
169 if (sysfs_streq(buf, "detect"))
170 connector->force = 0;
171 else if (sysfs_streq(buf, "on"))
172 connector->force = DRM_FORCE_ON;
173 else if (sysfs_streq(buf, "on-digital"))
174 connector->force = DRM_FORCE_ON_DIGITAL;
175 else if (sysfs_streq(buf, "off"))
176 connector->force = DRM_FORCE_OFF;
180 if (old_force != connector->force || !connector->force) {
181 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
184 old_force, connector->force);
186 connector->funcs->fill_modes(connector,
187 dev->mode_config.max_width,
188 dev->mode_config.max_height);
191 mutex_unlock(&dev->mode_config.mutex);
193 return ret ? ret : count;
196 static ssize_t status_show(struct device *device,
197 struct device_attribute *attr,
200 struct drm_connector *connector = to_drm_connector(device);
201 enum drm_connector_status status;
203 status = READ_ONCE(connector->status);
205 return snprintf(buf, PAGE_SIZE, "%s\n",
206 drm_get_connector_status_name(status));
209 static ssize_t dpms_show(struct device *device,
210 struct device_attribute *attr,
213 struct drm_connector *connector = to_drm_connector(device);
216 dpms = READ_ONCE(connector->dpms);
218 return snprintf(buf, PAGE_SIZE, "%s\n",
219 drm_get_dpms_name(dpms));
222 static ssize_t enabled_show(struct device *device,
223 struct device_attribute *attr,
226 struct drm_connector *connector = to_drm_connector(device);
229 enabled = READ_ONCE(connector->encoder);
231 return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n");
234 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
235 struct bin_attribute *attr, char *buf, loff_t off,
238 struct device *connector_dev = kobj_to_dev(kobj);
239 struct drm_connector *connector = to_drm_connector(connector_dev);
244 mutex_lock(&connector->dev->mode_config.mutex);
245 if (!connector->edid_blob_ptr)
248 edid = connector->edid_blob_ptr->data;
249 size = connector->edid_blob_ptr->length;
256 if (off + count > size)
258 memcpy(buf, edid + off, count);
262 mutex_unlock(&connector->dev->mode_config.mutex);
267 static ssize_t modes_show(struct device *device,
268 struct device_attribute *attr,
271 struct drm_connector *connector = to_drm_connector(device);
272 struct drm_display_mode *mode;
275 mutex_lock(&connector->dev->mode_config.mutex);
276 list_for_each_entry(mode, &connector->modes, head) {
277 written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n",
280 mutex_unlock(&connector->dev->mode_config.mutex);
285 static DEVICE_ATTR_RW(status);
286 static DEVICE_ATTR_RO(enabled);
287 static DEVICE_ATTR_RO(dpms);
288 static DEVICE_ATTR_RO(modes);
290 static struct attribute *connector_dev_attrs[] = {
291 &dev_attr_status.attr,
292 &dev_attr_enabled.attr,
294 &dev_attr_modes.attr,
298 static struct bin_attribute edid_attr = {
305 static struct bin_attribute *connector_bin_attrs[] = {
310 static const struct attribute_group connector_dev_group = {
311 .attrs = connector_dev_attrs,
312 .bin_attrs = connector_bin_attrs,
315 static const struct attribute_group *connector_dev_groups[] = {
316 &connector_dev_group,
320 int drm_sysfs_connector_add(struct drm_connector *connector)
322 struct drm_device *dev = connector->dev;
329 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
333 device_initialize(kdev);
334 kdev->class = drm_class;
335 kdev->type = &drm_sysfs_device_connector;
336 kdev->parent = dev->primary->kdev;
337 kdev->groups = connector_dev_groups;
338 kdev->release = drm_sysfs_release;
339 dev_set_drvdata(kdev, connector);
341 r = dev_set_name(kdev, "card%d-%s", dev->primary->index, connector->name);
345 DRM_DEBUG("adding \"%s\" to sysfs\n",
348 r = device_add(kdev);
350 drm_err(dev, "failed to register connector device: %d\n", r);
354 connector->kdev = kdev;
357 return sysfs_create_link(&connector->kdev->kobj,
358 &connector->ddc->dev.kobj, "ddc");
366 void drm_sysfs_connector_remove(struct drm_connector *connector)
368 if (!connector->kdev)
372 sysfs_remove_link(&connector->kdev->kobj, "ddc");
374 DRM_DEBUG("removing \"%s\" from sysfs\n",
377 device_unregister(connector->kdev);
378 connector->kdev = NULL;
381 void drm_sysfs_lease_event(struct drm_device *dev)
383 char *event_string = "LEASE=1";
384 char *envp[] = { event_string, NULL };
386 DRM_DEBUG("generating lease event\n");
388 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
392 * drm_sysfs_hotplug_event - generate a DRM uevent
395 * Send a uevent for the DRM device specified by @dev. Currently we only
396 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
397 * deal with other types of events.
399 * Any new uapi should be using the drm_sysfs_connector_status_event()
400 * for uevents on connector status change.
402 void drm_sysfs_hotplug_event(struct drm_device *dev)
404 char *event_string = "HOTPLUG=1";
405 char *envp[] = { event_string, NULL };
407 DRM_DEBUG("generating hotplug event\n");
409 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
411 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
414 * drm_sysfs_connector_status_event - generate a DRM uevent for connector
415 * property status change
416 * @connector: connector on which property status changed
417 * @property: connector property whose status changed.
419 * Send a uevent for the DRM device specified by @dev. Currently we
420 * set HOTPLUG=1 and connector id along with the attached property id
421 * related to the status change.
423 void drm_sysfs_connector_status_event(struct drm_connector *connector,
424 struct drm_property *property)
426 struct drm_device *dev = connector->dev;
427 char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21];
428 char *envp[4] = { hotplug_str, conn_id, prop_id, NULL };
430 WARN_ON(!drm_mode_obj_find_prop_id(&connector->base,
433 snprintf(conn_id, ARRAY_SIZE(conn_id),
434 "CONNECTOR=%u", connector->base.id);
435 snprintf(prop_id, ARRAY_SIZE(prop_id),
436 "PROPERTY=%u", property->base.id);
438 DRM_DEBUG("generating connector status event\n");
440 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
442 EXPORT_SYMBOL(drm_sysfs_connector_status_event);
444 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
446 const char *minor_str;
450 if (minor->type == DRM_MINOR_RENDER)
451 minor_str = "renderD%d";
453 minor_str = "card%d";
455 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
457 return ERR_PTR(-ENOMEM);
459 device_initialize(kdev);
460 kdev->devt = MKDEV(DRM_MAJOR, minor->index);
461 kdev->class = drm_class;
462 kdev->type = &drm_sysfs_device_minor;
463 kdev->parent = minor->dev->dev;
464 kdev->release = drm_sysfs_release;
465 dev_set_drvdata(kdev, minor);
467 r = dev_set_name(kdev, minor_str, minor->index);
479 * drm_class_device_register - register new device with the DRM sysfs class
480 * @dev: device to register
482 * Registers a new &struct device within the DRM sysfs class. Essentially only
483 * used by ttm to have a place for its global settings. Drivers should never use
486 int drm_class_device_register(struct device *dev)
488 if (!drm_class || IS_ERR(drm_class))
491 dev->class = drm_class;
492 return device_register(dev);
494 EXPORT_SYMBOL_GPL(drm_class_device_register);
497 * drm_class_device_unregister - unregister device with the DRM sysfs class
498 * @dev: device to unregister
500 * Unregisters a &struct device from the DRM sysfs class. Essentially only used
501 * by ttm to have a place for its global settings. Drivers should never use
504 void drm_class_device_unregister(struct device *dev)
506 return device_unregister(dev);
508 EXPORT_SYMBOL_GPL(drm_class_device_unregister);