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/device.h>
14 #include <linux/err.h>
15 #include <linux/export.h>
16 #include <linux/gfp.h>
17 #include <linux/kdev_t.h>
18 #include <linux/slab.h>
20 #include <drm/drm_connector.h>
21 #include <drm/drm_device.h>
22 #include <drm/drm_file.h>
23 #include <drm/drm_modes.h>
24 #include <drm/drm_print.h>
25 #include <drm/drm_property.h>
26 #include <drm/drm_sysfs.h>
28 #include "drm_internal.h"
30 #define to_drm_minor(d) dev_get_drvdata(d)
31 #define to_drm_connector(d) dev_get_drvdata(d)
36 * DRM provides very little additional support to drivers for sysfs
37 * interactions, beyond just all the standard stuff. Drivers who want to expose
38 * additional sysfs properties and property groups can attach them at either
39 * &drm_device.dev or &drm_connector.kdev.
41 * Registration is automatically handled when calling drm_dev_register(), or
42 * drm_connector_register() in case of hot-plugged connectors. Unregistration is
43 * also automatically handled by drm_dev_unregister() and
44 * drm_connector_unregister().
47 static struct device_type drm_sysfs_device_minor = {
51 struct class *drm_class;
53 static char *drm_devnode(struct device *dev, umode_t *mode)
55 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
58 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810");
61 * drm_sysfs_init - initialize sysfs helpers
63 * This is used to create the DRM class, which is the implicit parent of any
64 * other top-level DRM sysfs objects.
66 * You must call drm_sysfs_destroy() to release the allocated resources.
68 * Return: 0 on success, negative error code on failure.
70 int drm_sysfs_init(void)
74 drm_class = class_create(THIS_MODULE, "drm");
75 if (IS_ERR(drm_class))
76 return PTR_ERR(drm_class);
78 err = class_create_file(drm_class, &class_attr_version.attr);
80 class_destroy(drm_class);
85 drm_class->devnode = drm_devnode;
86 drm_setup_hdcp_srm(drm_class);
91 * drm_sysfs_destroy - destroys DRM class
93 * Destroy the DRM device class.
95 void drm_sysfs_destroy(void)
97 if (IS_ERR_OR_NULL(drm_class))
99 drm_teardown_hdcp_srm(drm_class);
100 class_remove_file(drm_class, &class_attr_version.attr);
101 class_destroy(drm_class);
106 * Connector properties
108 static ssize_t status_store(struct device *device,
109 struct device_attribute *attr,
110 const char *buf, size_t count)
112 struct drm_connector *connector = to_drm_connector(device);
113 struct drm_device *dev = connector->dev;
114 enum drm_connector_force old_force;
117 ret = mutex_lock_interruptible(&dev->mode_config.mutex);
121 old_force = connector->force;
123 if (sysfs_streq(buf, "detect"))
124 connector->force = 0;
125 else if (sysfs_streq(buf, "on"))
126 connector->force = DRM_FORCE_ON;
127 else if (sysfs_streq(buf, "on-digital"))
128 connector->force = DRM_FORCE_ON_DIGITAL;
129 else if (sysfs_streq(buf, "off"))
130 connector->force = DRM_FORCE_OFF;
134 if (old_force != connector->force || !connector->force) {
135 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
138 old_force, connector->force);
140 connector->funcs->fill_modes(connector,
141 dev->mode_config.max_width,
142 dev->mode_config.max_height);
145 mutex_unlock(&dev->mode_config.mutex);
147 return ret ? ret : count;
150 static ssize_t status_show(struct device *device,
151 struct device_attribute *attr,
154 struct drm_connector *connector = to_drm_connector(device);
155 enum drm_connector_status status;
157 status = READ_ONCE(connector->status);
159 return snprintf(buf, PAGE_SIZE, "%s\n",
160 drm_get_connector_status_name(status));
163 static ssize_t dpms_show(struct device *device,
164 struct device_attribute *attr,
167 struct drm_connector *connector = to_drm_connector(device);
170 dpms = READ_ONCE(connector->dpms);
172 return snprintf(buf, PAGE_SIZE, "%s\n",
173 drm_get_dpms_name(dpms));
176 static ssize_t enabled_show(struct device *device,
177 struct device_attribute *attr,
180 struct drm_connector *connector = to_drm_connector(device);
183 enabled = READ_ONCE(connector->encoder);
185 return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n");
188 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
189 struct bin_attribute *attr, char *buf, loff_t off,
192 struct device *connector_dev = kobj_to_dev(kobj);
193 struct drm_connector *connector = to_drm_connector(connector_dev);
198 mutex_lock(&connector->dev->mode_config.mutex);
199 if (!connector->edid_blob_ptr)
202 edid = connector->edid_blob_ptr->data;
203 size = connector->edid_blob_ptr->length;
210 if (off + count > size)
212 memcpy(buf, edid + off, count);
216 mutex_unlock(&connector->dev->mode_config.mutex);
221 static ssize_t modes_show(struct device *device,
222 struct device_attribute *attr,
225 struct drm_connector *connector = to_drm_connector(device);
226 struct drm_display_mode *mode;
229 mutex_lock(&connector->dev->mode_config.mutex);
230 list_for_each_entry(mode, &connector->modes, head) {
231 written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
234 mutex_unlock(&connector->dev->mode_config.mutex);
239 static DEVICE_ATTR_RW(status);
240 static DEVICE_ATTR_RO(enabled);
241 static DEVICE_ATTR_RO(dpms);
242 static DEVICE_ATTR_RO(modes);
244 static struct attribute *connector_dev_attrs[] = {
245 &dev_attr_status.attr,
246 &dev_attr_enabled.attr,
248 &dev_attr_modes.attr,
252 static struct bin_attribute edid_attr = {
259 static struct bin_attribute *connector_bin_attrs[] = {
264 static const struct attribute_group connector_dev_group = {
265 .attrs = connector_dev_attrs,
266 .bin_attrs = connector_bin_attrs,
269 static const struct attribute_group *connector_dev_groups[] = {
270 &connector_dev_group,
274 int drm_sysfs_connector_add(struct drm_connector *connector)
276 struct drm_device *dev = connector->dev;
282 device_create_with_groups(drm_class, dev->primary->kdev, 0,
283 connector, connector_dev_groups,
284 "card%d-%s", dev->primary->index,
286 DRM_DEBUG("adding \"%s\" to sysfs\n",
289 if (IS_ERR(connector->kdev)) {
290 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
291 return PTR_ERR(connector->kdev);
294 /* Let userspace know we have a new connector */
295 drm_sysfs_hotplug_event(dev);
300 void drm_sysfs_connector_remove(struct drm_connector *connector)
302 if (!connector->kdev)
304 DRM_DEBUG("removing \"%s\" from sysfs\n",
307 device_unregister(connector->kdev);
308 connector->kdev = NULL;
311 void drm_sysfs_lease_event(struct drm_device *dev)
313 char *event_string = "LEASE=1";
314 char *envp[] = { event_string, NULL };
316 DRM_DEBUG("generating lease event\n");
318 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
322 * drm_sysfs_hotplug_event - generate a DRM uevent
325 * Send a uevent for the DRM device specified by @dev. Currently we only
326 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
327 * deal with other types of events.
329 void drm_sysfs_hotplug_event(struct drm_device *dev)
331 char *event_string = "HOTPLUG=1";
332 char *envp[] = { event_string, NULL };
334 DRM_DEBUG("generating hotplug event\n");
336 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
338 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
340 static void drm_sysfs_release(struct device *dev)
345 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
347 const char *minor_str;
351 if (minor->type == DRM_MINOR_RENDER)
352 minor_str = "renderD%d";
354 minor_str = "card%d";
356 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
358 return ERR_PTR(-ENOMEM);
360 device_initialize(kdev);
361 kdev->devt = MKDEV(DRM_MAJOR, minor->index);
362 kdev->class = drm_class;
363 kdev->type = &drm_sysfs_device_minor;
364 kdev->parent = minor->dev->dev;
365 kdev->release = drm_sysfs_release;
366 dev_set_drvdata(kdev, minor);
368 r = dev_set_name(kdev, minor_str, minor->index);
380 * drm_class_device_register - register new device with the DRM sysfs class
381 * @dev: device to register
383 * Registers a new &struct device within the DRM sysfs class. Essentially only
384 * used by ttm to have a place for its global settings. Drivers should never use
387 int drm_class_device_register(struct device *dev)
389 if (!drm_class || IS_ERR(drm_class))
392 dev->class = drm_class;
393 return device_register(dev);
395 EXPORT_SYMBOL_GPL(drm_class_device_register);
398 * drm_class_device_unregister - unregister device with the DRM sysfs class
399 * @dev: device to unregister
401 * Unregisters a &struct device from the DRM sysfs class. Essentially only used
402 * by ttm to have a place for its global settings. Drivers should never use
405 void drm_class_device_unregister(struct device *dev)
407 return device_unregister(dev);
409 EXPORT_SYMBOL_GPL(drm_class_device_unregister);