3 * drm_sysfs.c - Modifications to drm_sysfs_class.c to support
4 * extra sysfs attribute from DRM. Normal drm_sysfs_class
5 * does not allow adding attributes.
7 * Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com>
8 * Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com>
9 * Copyright (c) 2003-2004 IBM Corp.
11 * This file is released under the GPLv2
15 #include <linux/device.h>
16 #include <linux/kdev_t.h>
17 #include <linux/gfp.h>
18 #include <linux/err.h>
19 #include <linux/export.h>
21 #include <drm/drm_sysfs.h>
22 #include <drm/drm_core.h>
24 #include "drm_internal.h"
26 #define to_drm_minor(d) dev_get_drvdata(d)
27 #define to_drm_connector(d) dev_get_drvdata(d)
29 static struct device_type drm_sysfs_device_minor
= {
33 struct class *drm_class
;
36 * __drm_class_suspend - internal DRM class suspend routine
37 * @dev: Linux device to suspend
38 * @state: power state to enter
40 * Just figures out what the actual struct drm_device associated with
41 * @dev is and calls its suspend hook, if present.
43 static int __drm_class_suspend(struct device
*dev
, pm_message_t state
)
45 if (dev
->type
== &drm_sysfs_device_minor
) {
46 struct drm_minor
*drm_minor
= to_drm_minor(dev
);
47 struct drm_device
*drm_dev
= drm_minor
->dev
;
49 if (drm_minor
->type
== DRM_MINOR_LEGACY
&&
50 !drm_core_check_feature(drm_dev
, DRIVER_MODESET
) &&
51 drm_dev
->driver
->suspend
)
52 return drm_dev
->driver
->suspend(drm_dev
, state
);
58 * drm_class_suspend - internal DRM class suspend hook. Simply calls
59 * __drm_class_suspend() with the correct pm state.
60 * @dev: Linux device to suspend
62 static int drm_class_suspend(struct device
*dev
)
64 return __drm_class_suspend(dev
, PMSG_SUSPEND
);
68 * drm_class_freeze - internal DRM class freeze hook. Simply calls
69 * __drm_class_suspend() with the correct pm state.
70 * @dev: Linux device to freeze
72 static int drm_class_freeze(struct device
*dev
)
74 return __drm_class_suspend(dev
, PMSG_FREEZE
);
78 * drm_class_resume - DRM class resume hook
79 * @dev: Linux device to resume
81 * Just figures out what the actual struct drm_device associated with
82 * @dev is and calls its resume hook, if present.
84 static int drm_class_resume(struct device
*dev
)
86 if (dev
->type
== &drm_sysfs_device_minor
) {
87 struct drm_minor
*drm_minor
= to_drm_minor(dev
);
88 struct drm_device
*drm_dev
= drm_minor
->dev
;
90 if (drm_minor
->type
== DRM_MINOR_LEGACY
&&
91 !drm_core_check_feature(drm_dev
, DRIVER_MODESET
) &&
92 drm_dev
->driver
->resume
)
93 return drm_dev
->driver
->resume(drm_dev
);
98 static const struct dev_pm_ops drm_class_dev_pm_ops
= {
99 .suspend
= drm_class_suspend
,
100 .resume
= drm_class_resume
,
101 .freeze
= drm_class_freeze
,
104 static char *drm_devnode(struct device
*dev
, umode_t
*mode
)
106 return kasprintf(GFP_KERNEL
, "dri/%s", dev_name(dev
));
109 static CLASS_ATTR_STRING(version
, S_IRUGO
,
111 __stringify(CORE_MAJOR
) "."
112 __stringify(CORE_MINOR
) "."
113 __stringify(CORE_PATCHLEVEL
) " "
117 * drm_sysfs_init - initialize sysfs helpers
119 * This is used to create the DRM class, which is the implicit parent of any
120 * other top-level DRM sysfs objects.
122 * You must call drm_sysfs_destroy() to release the allocated resources.
124 * Return: 0 on success, negative error code on failure.
126 int drm_sysfs_init(void)
130 drm_class
= class_create(THIS_MODULE
, "drm");
131 if (IS_ERR(drm_class
))
132 return PTR_ERR(drm_class
);
134 drm_class
->pm
= &drm_class_dev_pm_ops
;
136 err
= class_create_file(drm_class
, &class_attr_version
.attr
);
138 class_destroy(drm_class
);
143 drm_class
->devnode
= drm_devnode
;
148 * drm_sysfs_destroy - destroys DRM class
150 * Destroy the DRM device class.
152 void drm_sysfs_destroy(void)
154 if (IS_ERR_OR_NULL(drm_class
))
156 class_remove_file(drm_class
, &class_attr_version
.attr
);
157 class_destroy(drm_class
);
162 * Connector properties
164 static ssize_t
status_store(struct device
*device
,
165 struct device_attribute
*attr
,
166 const char *buf
, size_t count
)
168 struct drm_connector
*connector
= to_drm_connector(device
);
169 struct drm_device
*dev
= connector
->dev
;
170 enum drm_connector_status old_status
;
173 ret
= mutex_lock_interruptible(&dev
->mode_config
.mutex
);
177 old_status
= connector
->status
;
179 if (sysfs_streq(buf
, "detect")) {
180 connector
->force
= 0;
181 connector
->status
= connector
->funcs
->detect(connector
, true);
182 } else if (sysfs_streq(buf
, "on")) {
183 connector
->force
= DRM_FORCE_ON
;
184 } else if (sysfs_streq(buf
, "on-digital")) {
185 connector
->force
= DRM_FORCE_ON_DIGITAL
;
186 } else if (sysfs_streq(buf
, "off")) {
187 connector
->force
= DRM_FORCE_OFF
;
191 if (ret
== 0 && connector
->force
) {
192 if (connector
->force
== DRM_FORCE_ON
||
193 connector
->force
== DRM_FORCE_ON_DIGITAL
)
194 connector
->status
= connector_status_connected
;
196 connector
->status
= connector_status_disconnected
;
197 if (connector
->funcs
->force
)
198 connector
->funcs
->force(connector
);
201 if (old_status
!= connector
->status
) {
202 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
205 old_status
, connector
->status
);
207 dev
->mode_config
.delayed_event
= true;
208 if (dev
->mode_config
.poll_enabled
)
209 schedule_delayed_work(&dev
->mode_config
.output_poll_work
,
213 mutex_unlock(&dev
->mode_config
.mutex
);
215 return ret
? ret
: count
;
218 static ssize_t
status_show(struct device
*device
,
219 struct device_attribute
*attr
,
222 struct drm_connector
*connector
= to_drm_connector(device
);
224 return snprintf(buf
, PAGE_SIZE
, "%s\n",
225 drm_get_connector_status_name(connector
->status
));
228 static ssize_t
dpms_show(struct device
*device
,
229 struct device_attribute
*attr
,
232 struct drm_connector
*connector
= to_drm_connector(device
);
233 struct drm_device
*dev
= connector
->dev
;
234 uint64_t dpms_status
;
237 ret
= drm_object_property_get_value(&connector
->base
,
238 dev
->mode_config
.dpms_property
,
243 return snprintf(buf
, PAGE_SIZE
, "%s\n",
244 drm_get_dpms_name((int)dpms_status
));
247 static ssize_t
enabled_show(struct device
*device
,
248 struct device_attribute
*attr
,
251 struct drm_connector
*connector
= to_drm_connector(device
);
253 return snprintf(buf
, PAGE_SIZE
, "%s\n", connector
->encoder
? "enabled" :
257 static ssize_t
edid_show(struct file
*filp
, struct kobject
*kobj
,
258 struct bin_attribute
*attr
, char *buf
, loff_t off
,
261 struct device
*connector_dev
= container_of(kobj
, struct device
, kobj
);
262 struct drm_connector
*connector
= to_drm_connector(connector_dev
);
266 if (!connector
->edid_blob_ptr
)
269 edid
= connector
->edid_blob_ptr
->data
;
270 size
= connector
->edid_blob_ptr
->length
;
277 if (off
+ count
> size
)
279 memcpy(buf
, edid
+ off
, count
);
284 static ssize_t
modes_show(struct device
*device
,
285 struct device_attribute
*attr
,
288 struct drm_connector
*connector
= to_drm_connector(device
);
289 struct drm_display_mode
*mode
;
292 list_for_each_entry(mode
, &connector
->modes
, head
) {
293 written
+= snprintf(buf
+ written
, PAGE_SIZE
- written
, "%s\n",
300 static ssize_t
tv_subconnector_show(struct device
*device
,
301 struct device_attribute
*attr
,
304 struct drm_connector
*connector
= to_drm_connector(device
);
305 struct drm_device
*dev
= connector
->dev
;
306 struct drm_property
*prop
;
307 uint64_t subconnector
;
310 prop
= dev
->mode_config
.tv_subconnector_property
;
312 DRM_ERROR("Unable to find subconnector property\n");
316 ret
= drm_object_property_get_value(&connector
->base
, prop
, &subconnector
);
320 return snprintf(buf
, PAGE_SIZE
, "%s",
321 drm_get_tv_subconnector_name((int)subconnector
));
324 static ssize_t
tv_select_subconnector_show(struct device
*device
,
325 struct device_attribute
*attr
,
328 struct drm_connector
*connector
= to_drm_connector(device
);
329 struct drm_device
*dev
= connector
->dev
;
330 struct drm_property
*prop
;
331 uint64_t subconnector
;
334 prop
= dev
->mode_config
.tv_select_subconnector_property
;
336 DRM_ERROR("Unable to find select subconnector property\n");
340 ret
= drm_object_property_get_value(&connector
->base
, prop
, &subconnector
);
344 return snprintf(buf
, PAGE_SIZE
, "%s",
345 drm_get_tv_select_name((int)subconnector
));
348 static ssize_t
dvii_subconnector_show(struct device
*device
,
349 struct device_attribute
*attr
,
352 struct drm_connector
*connector
= to_drm_connector(device
);
353 struct drm_device
*dev
= connector
->dev
;
354 struct drm_property
*prop
;
355 uint64_t subconnector
;
358 prop
= dev
->mode_config
.dvi_i_subconnector_property
;
360 DRM_ERROR("Unable to find subconnector property\n");
364 ret
= drm_object_property_get_value(&connector
->base
, prop
, &subconnector
);
368 return snprintf(buf
, PAGE_SIZE
, "%s",
369 drm_get_dvi_i_subconnector_name((int)subconnector
));
372 static ssize_t
dvii_select_subconnector_show(struct device
*device
,
373 struct device_attribute
*attr
,
376 struct drm_connector
*connector
= to_drm_connector(device
);
377 struct drm_device
*dev
= connector
->dev
;
378 struct drm_property
*prop
;
379 uint64_t subconnector
;
382 prop
= dev
->mode_config
.dvi_i_select_subconnector_property
;
384 DRM_ERROR("Unable to find select subconnector property\n");
388 ret
= drm_object_property_get_value(&connector
->base
, prop
, &subconnector
);
392 return snprintf(buf
, PAGE_SIZE
, "%s",
393 drm_get_dvi_i_select_name((int)subconnector
));
396 static DEVICE_ATTR_RW(status
);
397 static DEVICE_ATTR_RO(enabled
);
398 static DEVICE_ATTR_RO(dpms
);
399 static DEVICE_ATTR_RO(modes
);
401 static struct attribute
*connector_dev_attrs
[] = {
402 &dev_attr_status
.attr
,
403 &dev_attr_enabled
.attr
,
405 &dev_attr_modes
.attr
,
409 static DEVICE_ATTR_RO(tv_subconnector
);
410 static DEVICE_ATTR_RO(tv_select_subconnector
);
412 static struct attribute
*connector_tv_dev_attrs
[] = {
413 &dev_attr_tv_subconnector
.attr
,
414 &dev_attr_tv_select_subconnector
.attr
,
418 static DEVICE_ATTR_RO(dvii_subconnector
);
419 static DEVICE_ATTR_RO(dvii_select_subconnector
);
421 static struct attribute
*connector_dvii_dev_attrs
[] = {
422 &dev_attr_dvii_subconnector
.attr
,
423 &dev_attr_dvii_select_subconnector
.attr
,
427 /* Connector type related helpers */
428 static int kobj_connector_type(struct kobject
*kobj
)
430 struct device
*dev
= kobj_to_dev(kobj
);
431 struct drm_connector
*connector
= to_drm_connector(dev
);
433 return connector
->connector_type
;
436 static umode_t
connector_is_dvii(struct kobject
*kobj
,
437 struct attribute
*attr
, int idx
)
439 return kobj_connector_type(kobj
) == DRM_MODE_CONNECTOR_DVII
?
443 static umode_t
connector_is_tv(struct kobject
*kobj
,
444 struct attribute
*attr
, int idx
)
446 switch (kobj_connector_type(kobj
)) {
447 case DRM_MODE_CONNECTOR_Composite
:
448 case DRM_MODE_CONNECTOR_SVIDEO
:
449 case DRM_MODE_CONNECTOR_Component
:
450 case DRM_MODE_CONNECTOR_TV
:
457 static struct bin_attribute edid_attr
= {
464 static struct bin_attribute
*connector_bin_attrs
[] = {
469 static const struct attribute_group connector_dev_group
= {
470 .attrs
= connector_dev_attrs
,
471 .bin_attrs
= connector_bin_attrs
,
474 static const struct attribute_group connector_tv_dev_group
= {
475 .attrs
= connector_tv_dev_attrs
,
476 .is_visible
= connector_is_tv
,
479 static const struct attribute_group connector_dvii_dev_group
= {
480 .attrs
= connector_dvii_dev_attrs
,
481 .is_visible
= connector_is_dvii
,
484 static const struct attribute_group
*connector_dev_groups
[] = {
485 &connector_dev_group
,
486 &connector_tv_dev_group
,
487 &connector_dvii_dev_group
,
492 * drm_sysfs_connector_add - add a connector to sysfs
493 * @connector: connector to add
495 * Create a connector device in sysfs, along with its associated connector
496 * properties (so far, connection status, dpms, mode list & edid) and
497 * generate a hotplug event so userspace knows there's a new connector
500 int drm_sysfs_connector_add(struct drm_connector
*connector
)
502 struct drm_device
*dev
= connector
->dev
;
508 device_create_with_groups(drm_class
, dev
->primary
->kdev
, 0,
509 connector
, connector_dev_groups
,
510 "card%d-%s", dev
->primary
->index
,
512 DRM_DEBUG("adding \"%s\" to sysfs\n",
515 if (IS_ERR(connector
->kdev
)) {
516 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector
->kdev
));
517 return PTR_ERR(connector
->kdev
);
520 /* Let userspace know we have a new connector */
521 drm_sysfs_hotplug_event(dev
);
527 * drm_sysfs_connector_remove - remove an connector device from sysfs
528 * @connector: connector to remove
530 * Remove @connector and its associated attributes from sysfs. Note that
531 * the device model core will take care of sending the "remove" uevent
532 * at this time, so we don't need to do it.
535 * This routine should only be called if the connector was previously
536 * successfully registered. If @connector hasn't been registered yet,
537 * you'll likely see a panic somewhere deep in sysfs code when called.
539 void drm_sysfs_connector_remove(struct drm_connector
*connector
)
541 if (!connector
->kdev
)
543 DRM_DEBUG("removing \"%s\" from sysfs\n",
546 device_unregister(connector
->kdev
);
547 connector
->kdev
= NULL
;
551 * drm_sysfs_hotplug_event - generate a DRM uevent
554 * Send a uevent for the DRM device specified by @dev. Currently we only
555 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
556 * deal with other types of events.
558 void drm_sysfs_hotplug_event(struct drm_device
*dev
)
560 char *event_string
= "HOTPLUG=1";
561 char *envp
[] = { event_string
, NULL
};
563 DRM_DEBUG("generating hotplug event\n");
565 kobject_uevent_env(&dev
->primary
->kdev
->kobj
, KOBJ_CHANGE
, envp
);
567 EXPORT_SYMBOL(drm_sysfs_hotplug_event
);
569 static void drm_sysfs_release(struct device
*dev
)
575 * drm_sysfs_minor_alloc() - Allocate sysfs device for given minor
576 * @minor: minor to allocate sysfs device for
578 * This allocates a new sysfs device for @minor and returns it. The device is
579 * not registered nor linked. The caller has to use device_add() and
580 * device_del() to register and unregister it.
582 * Note that dev_get_drvdata() on the new device will return the minor.
583 * However, the device does not hold a ref-count to the minor nor to the
584 * underlying drm_device. This is unproblematic as long as you access the
585 * private data only in sysfs callbacks. device_del() disables those
586 * synchronously, so they cannot be called after you cleanup a minor.
588 struct device
*drm_sysfs_minor_alloc(struct drm_minor
*minor
)
590 const char *minor_str
;
594 if (minor
->type
== DRM_MINOR_CONTROL
)
595 minor_str
= "controlD%d";
596 else if (minor
->type
== DRM_MINOR_RENDER
)
597 minor_str
= "renderD%d";
599 minor_str
= "card%d";
601 kdev
= kzalloc(sizeof(*kdev
), GFP_KERNEL
);
603 return ERR_PTR(-ENOMEM
);
605 device_initialize(kdev
);
606 kdev
->devt
= MKDEV(DRM_MAJOR
, minor
->index
);
607 kdev
->class = drm_class
;
608 kdev
->type
= &drm_sysfs_device_minor
;
609 kdev
->parent
= minor
->dev
->dev
;
610 kdev
->release
= drm_sysfs_release
;
611 dev_set_drvdata(kdev
, minor
);
613 r
= dev_set_name(kdev
, minor_str
, minor
->index
);
625 * drm_class_device_register - Register a struct device in the drm class.
627 * @dev: pointer to struct device to register.
629 * @dev should have all relevant members pre-filled with the exception
630 * of the class member. In particular, the device_type member must
634 int drm_class_device_register(struct device
*dev
)
636 if (!drm_class
|| IS_ERR(drm_class
))
639 dev
->class = drm_class
;
640 return device_register(dev
);
642 EXPORT_SYMBOL_GPL(drm_class_device_register
);
644 void drm_class_device_unregister(struct device
*dev
)
646 return device_unregister(dev
);
648 EXPORT_SYMBOL_GPL(drm_class_device_unregister
);