Merge v6.5-rc1 into drm-misc-fixes
[platform/kernel/linux-rpi.git] / drivers / gpu / drm / drm_sysfs.c
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
53 static struct device_type drm_sysfs_device_minor = {
54         .name = "drm_minor"
55 };
56
57 static struct device_type drm_sysfs_device_connector = {
58         .name = "drm_connector",
59 };
60
61 struct class *drm_class;
62
63 #ifdef CONFIG_ACPI
64 static bool drm_connector_acpi_bus_match(struct device *dev)
65 {
66         return dev->type == &drm_sysfs_device_connector;
67 }
68
69 static 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
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,
80 };
81
82 static void drm_sysfs_acpi_register(void)
83 {
84         register_acpi_bus_type(&drm_connector_acpi_bus);
85 }
86
87 static void drm_sysfs_acpi_unregister(void)
88 {
89         unregister_acpi_bus_type(&drm_connector_acpi_bus);
90 }
91 #else
92 static void drm_sysfs_acpi_register(void) { }
93 static void drm_sysfs_acpi_unregister(void) { }
94 #endif
95
96 static char *drm_devnode(const struct device *dev, umode_t *mode)
97 {
98         return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
99 }
100
101 static 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
117 static 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
124 static const struct component_ops typec_connector_ops = {
125         .bind = typec_connector_bind,
126         .unbind = typec_connector_unbind,
127 };
128
129 static 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  */
141 int 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  */
167 void 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
177 static void drm_sysfs_release(struct device *dev)
178 {
179         kfree(dev);
180 }
181
182 /*
183  * Connector properties
184  */
185 static 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
227 static 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
240 static 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
252 static 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
264 static 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;
291 unlock:
292         mutex_unlock(&connector->dev->mode_config.mutex);
293
294         return ret;
295 }
296
297 static 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
315 static 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
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);
329
330 static 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
339 static struct bin_attribute edid_attr = {
340         .attr.name = "edid",
341         .attr.mode = 0444,
342         .size = 0,
343         .read = edid_show,
344 };
345
346 static struct bin_attribute *connector_bin_attrs[] = {
347         &edid_attr,
348         NULL
349 };
350
351 static const struct attribute_group connector_dev_group = {
352         .attrs = connector_dev_attrs,
353         .bin_attrs = connector_bin_attrs,
354 };
355
356 static const struct attribute_group *connector_dev_groups[] = {
357         &connector_dev_group,
358         NULL
359 };
360
361 int 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         if (connector->ddc)
404                 return sysfs_create_link(&connector->kdev->kobj,
405                                  &connector->ddc->dev.kobj, "ddc");
406
407         return 0;
408
409 err_free:
410         put_device(kdev);
411         return r;
412 }
413
414 void drm_sysfs_connector_remove(struct drm_connector *connector)
415 {
416         if (!connector->kdev)
417                 return;
418
419         if (connector->ddc)
420                 sysfs_remove_link(&connector->kdev->kobj, "ddc");
421
422         if (dev_fwnode(connector->kdev))
423                 component_del(connector->kdev, &typec_connector_ops);
424
425         DRM_DEBUG("removing \"%s\" from sysfs\n",
426                   connector->name);
427
428         device_unregister(connector->kdev);
429         connector->kdev = NULL;
430 }
431
432 void drm_sysfs_lease_event(struct drm_device *dev)
433 {
434         char *event_string = "LEASE=1";
435         char *envp[] = { event_string, NULL };
436
437         DRM_DEBUG("generating lease event\n");
438
439         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
440 }
441
442 /**
443  * drm_sysfs_hotplug_event - generate a DRM uevent
444  * @dev: DRM device
445  *
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.
449  *
450  * Any new uapi should be using the drm_sysfs_connector_status_event()
451  * for uevents on connector status change.
452  */
453 void drm_sysfs_hotplug_event(struct drm_device *dev)
454 {
455         char *event_string = "HOTPLUG=1";
456         char *envp[] = { event_string, NULL };
457
458         DRM_DEBUG("generating hotplug event\n");
459
460         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
461 }
462 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
463
464 /**
465  * drm_sysfs_connector_hotplug_event - generate a DRM uevent for any connector
466  * change
467  * @connector: connector which has changed
468  *
469  * Send a uevent for the DRM connector specified by @connector. This will send
470  * a uevent with the properties HOTPLUG=1 and CONNECTOR.
471  */
472 void drm_sysfs_connector_hotplug_event(struct drm_connector *connector)
473 {
474         struct drm_device *dev = connector->dev;
475         char hotplug_str[] = "HOTPLUG=1", conn_id[21];
476         char *envp[] = { hotplug_str, conn_id, NULL };
477
478         snprintf(conn_id, sizeof(conn_id),
479                  "CONNECTOR=%u", connector->base.id);
480
481         drm_dbg_kms(connector->dev,
482                     "[CONNECTOR:%d:%s] generating connector hotplug event\n",
483                     connector->base.id, connector->name);
484
485         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
486 }
487 EXPORT_SYMBOL(drm_sysfs_connector_hotplug_event);
488
489 /**
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.
494  *
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.
498  */
499 void drm_sysfs_connector_status_event(struct drm_connector *connector,
500                                       struct drm_property *property)
501 {
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 };
505
506         WARN_ON(!drm_mode_obj_find_prop_id(&connector->base,
507                                            property->base.id));
508
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);
513
514         DRM_DEBUG("generating connector status event\n");
515
516         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
517 }
518 EXPORT_SYMBOL(drm_sysfs_connector_status_event);
519
520 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
521 {
522         const char *minor_str;
523         struct device *kdev;
524         int r;
525
526         kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
527         if (!kdev)
528                 return ERR_PTR(-ENOMEM);
529
530         device_initialize(kdev);
531
532         if (minor->type == DRM_MINOR_ACCEL) {
533                 minor_str = "accel%d";
534                 accel_set_device_instance_params(kdev, minor->index);
535         } else {
536                 if (minor->type == DRM_MINOR_RENDER)
537                         minor_str = "renderD%d";
538                 else
539                         minor_str = "card%d";
540
541                 kdev->devt = MKDEV(DRM_MAJOR, minor->index);
542                 kdev->class = drm_class;
543                 kdev->type = &drm_sysfs_device_minor;
544         }
545
546         kdev->parent = minor->dev->dev;
547         kdev->release = drm_sysfs_release;
548         dev_set_drvdata(kdev, minor);
549
550         r = dev_set_name(kdev, minor_str, minor->index);
551         if (r < 0)
552                 goto err_free;
553
554         return kdev;
555
556 err_free:
557         put_device(kdev);
558         return ERR_PTR(r);
559 }
560
561 /**
562  * drm_class_device_register - register new device with the DRM sysfs class
563  * @dev: device to register
564  *
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
567  * this.
568  */
569 int drm_class_device_register(struct device *dev)
570 {
571         if (!drm_class || IS_ERR(drm_class))
572                 return -ENOENT;
573
574         dev->class = drm_class;
575         return device_register(dev);
576 }
577 EXPORT_SYMBOL_GPL(drm_class_device_register);
578
579 /**
580  * drm_class_device_unregister - unregister device with the DRM sysfs class
581  * @dev: device to unregister
582  *
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
585  * this.
586  */
587 void drm_class_device_unregister(struct device *dev)
588 {
589         return device_unregister(dev);
590 }
591 EXPORT_SYMBOL_GPL(drm_class_device_unregister);