Linux Audio

Check our new training course

Loading...
v4.6
 
  1
  2/*
  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.
  6 *
  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.
 10 *
 11 * This file is released under the GPLv2
 12 *
 13 */
 14
 
 
 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>
 
 
 
 
 
 20
 
 
 
 
 
 
 
 21#include <drm/drm_sysfs.h>
 22#include <drm/drm_core.h>
 23#include <drm/drmP.h>
 24#include "drm_internal.h"
 
 25
 26#define to_drm_minor(d) dev_get_drvdata(d)
 27#define to_drm_connector(d) dev_get_drvdata(d)
 28
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 29static struct device_type drm_sysfs_device_minor = {
 30	.name = "drm_minor"
 31};
 32
 
 
 
 
 33struct class *drm_class;
 34
 35/**
 36 * __drm_class_suspend - internal DRM class suspend routine
 37 * @dev: Linux device to suspend
 38 * @state: power state to enter
 39 *
 40 * Just figures out what the actual struct drm_device associated with
 41 * @dev is and calls its suspend hook, if present.
 42 */
 43static int __drm_class_suspend(struct device *dev, pm_message_t state)
 44{
 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;
 48
 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);
 53	}
 54	return 0;
 55}
 56
 57/**
 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
 61 */
 62static int drm_class_suspend(struct device *dev)
 63{
 64	return __drm_class_suspend(dev, PMSG_SUSPEND);
 
 
 65}
 66
 67/**
 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
 71 */
 72static int drm_class_freeze(struct device *dev)
 
 73{
 74	return __drm_class_suspend(dev, PMSG_FREEZE);
 75}
 76
 77/**
 78 * drm_class_resume - DRM class resume hook
 79 * @dev: Linux device to resume
 80 *
 81 * Just figures out what the actual struct drm_device associated with
 82 * @dev is and calls its resume hook, if present.
 83 */
 84static int drm_class_resume(struct device *dev)
 85{
 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;
 89
 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);
 94	}
 95	return 0;
 96}
 
 
 
 
 97
 98static 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,
102};
103
104static char *drm_devnode(struct device *dev, umode_t *mode)
105{
106	return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
107}
108
109static CLASS_ATTR_STRING(version, S_IRUGO,
110		CORE_NAME " "
111		__stringify(CORE_MAJOR) "."
112		__stringify(CORE_MINOR) "."
113		__stringify(CORE_PATCHLEVEL) " "
114		CORE_DATE);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
115
116/**
117 * drm_sysfs_init - initialize sysfs helpers
118 *
119 * This is used to create the DRM class, which is the implicit parent of any
120 * other top-level DRM sysfs objects.
121 *
122 * You must call drm_sysfs_destroy() to release the allocated resources.
123 *
124 * Return: 0 on success, negative error code on failure.
125 */
126int drm_sysfs_init(void)
127{
128	int err;
129
130	drm_class = class_create(THIS_MODULE, "drm");
131	if (IS_ERR(drm_class))
132		return PTR_ERR(drm_class);
133
134	drm_class->pm = &drm_class_dev_pm_ops;
135
136	err = class_create_file(drm_class, &class_attr_version.attr);
137	if (err) {
138		class_destroy(drm_class);
139		drm_class = NULL;
140		return err;
141	}
142
143	drm_class->devnode = drm_devnode;
 
 
144	return 0;
145}
146
147/**
148 * drm_sysfs_destroy - destroys DRM class
149 *
150 * Destroy the DRM device class.
151 */
152void drm_sysfs_destroy(void)
153{
154	if (IS_ERR_OR_NULL(drm_class))
155		return;
 
156	class_remove_file(drm_class, &class_attr_version.attr);
157	class_destroy(drm_class);
158	drm_class = NULL;
159}
160
 
 
 
 
 
161/*
162 * Connector properties
163 */
164static ssize_t status_store(struct device *device,
165			   struct device_attribute *attr,
166			   const char *buf, size_t count)
167{
168	struct drm_connector *connector = to_drm_connector(device);
169	struct drm_device *dev = connector->dev;
170	enum drm_connector_force old_force;
171	int ret;
172
173	ret = mutex_lock_interruptible(&dev->mode_config.mutex);
174	if (ret)
175		return ret;
176
177	old_force = connector->force;
178
179	if (sysfs_streq(buf, "detect"))
180		connector->force = 0;
181	else if (sysfs_streq(buf, "on"))
182		connector->force = DRM_FORCE_ON;
183	else if (sysfs_streq(buf, "on-digital"))
184		connector->force = DRM_FORCE_ON_DIGITAL;
185	else if (sysfs_streq(buf, "off"))
186		connector->force = DRM_FORCE_OFF;
187	else
188		ret = -EINVAL;
189
190	if (old_force != connector->force || !connector->force) {
191		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
192			      connector->base.id,
193			      connector->name,
194			      old_force, connector->force);
195
196		connector->funcs->fill_modes(connector,
197					     dev->mode_config.max_width,
198					     dev->mode_config.max_height);
199	}
200
201	mutex_unlock(&dev->mode_config.mutex);
202
203	return ret ? ret : count;
204}
205
206static ssize_t status_show(struct device *device,
207			   struct device_attribute *attr,
208			   char *buf)
209{
210	struct drm_connector *connector = to_drm_connector(device);
 
 
 
211
212	return snprintf(buf, PAGE_SIZE, "%s\n",
213			drm_get_connector_status_name(connector->status));
214}
215
216static ssize_t dpms_show(struct device *device,
217			   struct device_attribute *attr,
218			   char *buf)
219{
220	struct drm_connector *connector = to_drm_connector(device);
221	int dpms;
222
223	dpms = READ_ONCE(connector->dpms);
224
225	return snprintf(buf, PAGE_SIZE, "%s\n",
226			drm_get_dpms_name(dpms));
227}
228
229static ssize_t enabled_show(struct device *device,
230			    struct device_attribute *attr,
231			   char *buf)
232{
233	struct drm_connector *connector = to_drm_connector(device);
 
 
 
234
235	return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
236			"disabled");
237}
238
239static ssize_t edid_show(struct file *filp, struct kobject *kobj,
240			 struct bin_attribute *attr, char *buf, loff_t off,
241			 size_t count)
242{
243	struct device *connector_dev = kobj_to_dev(kobj);
244	struct drm_connector *connector = to_drm_connector(connector_dev);
245	unsigned char *edid;
246	size_t size;
247	ssize_t ret = 0;
248
249	mutex_lock(&connector->dev->mode_config.mutex);
250	if (!connector->edid_blob_ptr)
251		goto unlock;
252
253	edid = connector->edid_blob_ptr->data;
254	size = connector->edid_blob_ptr->length;
255	if (!edid)
256		goto unlock;
257
258	if (off >= size)
259		goto unlock;
260
261	if (off + count > size)
262		count = size - off;
263	memcpy(buf, edid + off, count);
264
265	ret = count;
266unlock:
267	mutex_unlock(&connector->dev->mode_config.mutex);
268
269	return ret;
270}
271
272static ssize_t modes_show(struct device *device,
273			   struct device_attribute *attr,
274			   char *buf)
275{
276	struct drm_connector *connector = to_drm_connector(device);
277	struct drm_display_mode *mode;
278	int written = 0;
279
280	mutex_lock(&connector->dev->mode_config.mutex);
281	list_for_each_entry(mode, &connector->modes, head) {
282		written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
283				    mode->name);
284	}
285	mutex_unlock(&connector->dev->mode_config.mutex);
286
287	return written;
288}
289
290static ssize_t tv_subconnector_show(struct device *device,
291				    struct device_attribute *attr,
292				    char *buf)
293{
294	struct drm_connector *connector = to_drm_connector(device);
295	struct drm_device *dev = connector->dev;
296	struct drm_property *prop;
297	uint64_t subconnector;
298	int ret;
299
300	prop = dev->mode_config.tv_subconnector_property;
301	if (!prop) {
302		DRM_ERROR("Unable to find subconnector property\n");
303		return 0;
304	}
305
306	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
307	if (ret)
308		return 0;
309
310	return snprintf(buf, PAGE_SIZE, "%s",
311			drm_get_tv_subconnector_name((int)subconnector));
312}
313
314static ssize_t tv_select_subconnector_show(struct device *device,
315					   struct device_attribute *attr,
316					   char *buf)
317{
318	struct drm_connector *connector = to_drm_connector(device);
319	struct drm_device *dev = connector->dev;
320	struct drm_property *prop;
321	uint64_t subconnector;
322	int ret;
323
324	prop = dev->mode_config.tv_select_subconnector_property;
325	if (!prop) {
326		DRM_ERROR("Unable to find select subconnector property\n");
327		return 0;
328	}
329
330	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
331	if (ret)
332		return 0;
333
334	return snprintf(buf, PAGE_SIZE, "%s",
335			drm_get_tv_select_name((int)subconnector));
336}
337
338static ssize_t dvii_subconnector_show(struct device *device,
339				      struct device_attribute *attr,
340				      char *buf)
341{
342	struct drm_connector *connector = to_drm_connector(device);
343	struct drm_device *dev = connector->dev;
344	struct drm_property *prop;
345	uint64_t subconnector;
346	int ret;
347
348	prop = dev->mode_config.dvi_i_subconnector_property;
349	if (!prop) {
350		DRM_ERROR("Unable to find subconnector property\n");
351		return 0;
352	}
353
354	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
355	if (ret)
356		return 0;
357
358	return snprintf(buf, PAGE_SIZE, "%s",
359			drm_get_dvi_i_subconnector_name((int)subconnector));
360}
361
362static ssize_t dvii_select_subconnector_show(struct device *device,
363					     struct device_attribute *attr,
364					     char *buf)
365{
366	struct drm_connector *connector = to_drm_connector(device);
367	struct drm_device *dev = connector->dev;
368	struct drm_property *prop;
369	uint64_t subconnector;
370	int ret;
371
372	prop = dev->mode_config.dvi_i_select_subconnector_property;
373	if (!prop) {
374		DRM_ERROR("Unable to find select subconnector property\n");
375		return 0;
376	}
377
378	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
379	if (ret)
380		return 0;
381
382	return snprintf(buf, PAGE_SIZE, "%s",
383			drm_get_dvi_i_select_name((int)subconnector));
384}
385
386static DEVICE_ATTR_RW(status);
387static DEVICE_ATTR_RO(enabled);
388static DEVICE_ATTR_RO(dpms);
389static DEVICE_ATTR_RO(modes);
 
390
391static struct attribute *connector_dev_attrs[] = {
392	&dev_attr_status.attr,
393	&dev_attr_enabled.attr,
394	&dev_attr_dpms.attr,
395	&dev_attr_modes.attr,
 
396	NULL
397};
398
399static DEVICE_ATTR_RO(tv_subconnector);
400static DEVICE_ATTR_RO(tv_select_subconnector);
401
402static struct attribute *connector_tv_dev_attrs[] = {
403	&dev_attr_tv_subconnector.attr,
404	&dev_attr_tv_select_subconnector.attr,
405	NULL
406};
407
408static DEVICE_ATTR_RO(dvii_subconnector);
409static DEVICE_ATTR_RO(dvii_select_subconnector);
410
411static struct attribute *connector_dvii_dev_attrs[] = {
412	&dev_attr_dvii_subconnector.attr,
413	&dev_attr_dvii_select_subconnector.attr,
414	NULL
415};
416
417/* Connector type related helpers */
418static int kobj_connector_type(struct kobject *kobj)
419{
420	struct device *dev = kobj_to_dev(kobj);
421	struct drm_connector *connector = to_drm_connector(dev);
422
423	return connector->connector_type;
424}
425
426static umode_t connector_is_dvii(struct kobject *kobj,
427				 struct attribute *attr, int idx)
428{
429	return kobj_connector_type(kobj) == DRM_MODE_CONNECTOR_DVII ?
430		attr->mode : 0;
431}
432
433static umode_t connector_is_tv(struct kobject *kobj,
434			       struct attribute *attr, int idx)
435{
436	switch (kobj_connector_type(kobj)) {
437	case DRM_MODE_CONNECTOR_Composite:
438	case DRM_MODE_CONNECTOR_SVIDEO:
439	case DRM_MODE_CONNECTOR_Component:
440	case DRM_MODE_CONNECTOR_TV:
441		return attr->mode;
442	}
443
444	return 0;
445}
446
447static struct bin_attribute edid_attr = {
448	.attr.name = "edid",
449	.attr.mode = 0444,
450	.size = 0,
451	.read = edid_show,
452};
453
454static struct bin_attribute *connector_bin_attrs[] = {
455	&edid_attr,
456	NULL
457};
458
459static const struct attribute_group connector_dev_group = {
460	.attrs = connector_dev_attrs,
461	.bin_attrs = connector_bin_attrs,
462};
463
464static const struct attribute_group connector_tv_dev_group = {
465	.attrs = connector_tv_dev_attrs,
466	.is_visible = connector_is_tv,
467};
468
469static const struct attribute_group connector_dvii_dev_group = {
470	.attrs = connector_dvii_dev_attrs,
471	.is_visible = connector_is_dvii,
472};
473
474static const struct attribute_group *connector_dev_groups[] = {
475	&connector_dev_group,
476	&connector_tv_dev_group,
477	&connector_dvii_dev_group,
478	NULL
479};
480
481/**
482 * drm_sysfs_connector_add - add a connector to sysfs
483 * @connector: connector to add
484 *
485 * Create a connector device in sysfs, along with its associated connector
486 * properties (so far, connection status, dpms, mode list & edid) and
487 * generate a hotplug event so userspace knows there's a new connector
488 * available.
489 */
490int drm_sysfs_connector_add(struct drm_connector *connector)
491{
492	struct drm_device *dev = connector->dev;
 
 
493
494	if (connector->kdev)
495		return 0;
496
497	connector->kdev =
498		device_create_with_groups(drm_class, dev->primary->kdev, 0,
499					  connector, connector_dev_groups,
500					  "card%d-%s", dev->primary->index,
501					  connector->name);
 
 
 
 
 
 
 
 
 
 
 
502	DRM_DEBUG("adding \"%s\" to sysfs\n",
503		  connector->name);
504
505	if (IS_ERR(connector->kdev)) {
506		DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
507		return PTR_ERR(connector->kdev);
 
 
 
 
 
 
 
 
 
508	}
509
510	/* Let userspace know we have a new connector */
511	drm_sysfs_hotplug_event(dev);
 
 
 
 
 
 
 
 
 
 
512
513	return 0;
514}
515
516/**
517 * drm_sysfs_connector_remove - remove an connector device from sysfs
518 * @connector: connector to remove
519 *
520 * Remove @connector and its associated attributes from sysfs.  Note that
521 * the device model core will take care of sending the "remove" uevent
522 * at this time, so we don't need to do it.
523 *
524 * Note:
525 * This routine should only be called if the connector was previously
526 * successfully registered.  If @connector hasn't been registered yet,
527 * you'll likely see a panic somewhere deep in sysfs code when called.
528 */
529void drm_sysfs_connector_remove(struct drm_connector *connector)
530{
531	if (!connector->kdev)
532		return;
 
 
 
 
533	DRM_DEBUG("removing \"%s\" from sysfs\n",
534		  connector->name);
535
536	device_unregister(connector->kdev);
537	connector->kdev = NULL;
538}
539
 
 
 
 
 
 
 
 
 
 
540/**
541 * drm_sysfs_hotplug_event - generate a DRM uevent
542 * @dev: DRM device
543 *
544 * Send a uevent for the DRM device specified by @dev.  Currently we only
545 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
546 * deal with other types of events.
 
 
 
547 */
548void drm_sysfs_hotplug_event(struct drm_device *dev)
549{
550	char *event_string = "HOTPLUG=1";
551	char *envp[] = { event_string, NULL };
552
553	DRM_DEBUG("generating hotplug event\n");
554
555	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
556}
557EXPORT_SYMBOL(drm_sysfs_hotplug_event);
558
559static void drm_sysfs_release(struct device *dev)
 
 
 
 
 
 
 
 
560{
561	kfree(dev);
 
 
 
 
 
 
 
 
 
 
 
562}
 
563
564/**
565 * drm_sysfs_minor_alloc() - Allocate sysfs device for given minor
566 * @minor: minor to allocate sysfs device for
 
 
567 *
568 * This allocates a new sysfs device for @minor and returns it. The device is
569 * not registered nor linked. The caller has to use device_add() and
570 * device_del() to register and unregister it.
571 *
572 * Note that dev_get_drvdata() on the new device will return the minor.
573 * However, the device does not hold a ref-count to the minor nor to the
574 * underlying drm_device. This is unproblematic as long as you access the
575 * private data only in sysfs callbacks. device_del() disables those
576 * synchronously, so they cannot be called after you cleanup a minor.
577 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
578struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
579{
580	const char *minor_str;
581	struct device *kdev;
582	int r;
583
584	if (minor->type == DRM_MINOR_CONTROL)
585		minor_str = "controlD%d";
586	else if (minor->type == DRM_MINOR_RENDER)
587		minor_str = "renderD%d";
588	else
589		minor_str = "card%d";
590
591	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
592	if (!kdev)
593		return ERR_PTR(-ENOMEM);
594
595	device_initialize(kdev);
596	kdev->devt = MKDEV(DRM_MAJOR, minor->index);
597	kdev->class = drm_class;
598	kdev->type = &drm_sysfs_device_minor;
 
 
 
 
 
 
 
 
 
 
 
 
599	kdev->parent = minor->dev->dev;
600	kdev->release = drm_sysfs_release;
601	dev_set_drvdata(kdev, minor);
602
603	r = dev_set_name(kdev, minor_str, minor->index);
604	if (r < 0)
605		goto err_free;
606
607	return kdev;
608
609err_free:
610	put_device(kdev);
611	return ERR_PTR(r);
612}
613
614/**
615 * drm_class_device_register - Register a struct device in the drm class.
616 *
617 * @dev: pointer to struct device to register.
618 *
619 * @dev should have all relevant members pre-filled with the exception
620 * of the class member. In particular, the device_type member must
621 * be set.
622 */
623
624int drm_class_device_register(struct device *dev)
625{
626	if (!drm_class || IS_ERR(drm_class))
627		return -ENOENT;
628
629	dev->class = drm_class;
630	return device_register(dev);
631}
632EXPORT_SYMBOL_GPL(drm_class_device_register);
633
 
 
 
 
 
 
 
 
634void drm_class_device_unregister(struct device *dev)
635{
636	return device_unregister(dev);
637}
638EXPORT_SYMBOL_GPL(drm_class_device_unregister);
v6.8
  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
 53static struct device_type drm_sysfs_device_minor = {
 54	.name = "drm_minor"
 55};
 56
 57static struct device_type drm_sysfs_device_connector = {
 58	.name = "drm_connector",
 59};
 60
 61struct class *drm_class;
 62
 63#ifdef CONFIG_ACPI
 64static bool drm_connector_acpi_bus_match(struct device *dev)
 
 
 
 
 
 
 
 65{
 66	return dev->type == &drm_sysfs_device_connector;
 
 
 
 
 
 
 
 
 
 67}
 68
 69static 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
 76static 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
 82static void drm_sysfs_acpi_register(void)
 83{
 84	register_acpi_bus_type(&drm_connector_acpi_bus);
 85}
 86
 87static void drm_sysfs_acpi_unregister(void)
 
 
 
 
 
 
 
 88{
 89	unregister_acpi_bus_type(&drm_connector_acpi_bus);
 
 
 
 
 
 
 
 
 
 90}
 91#else
 92static void drm_sysfs_acpi_register(void) { }
 93static void drm_sysfs_acpi_unregister(void) { }
 94#endif
 95
 96static char *drm_devnode(const struct device *dev, umode_t *mode)
 
 
 
 
 
 
 97{
 98	return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
 99}
100
101static 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
117static 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
124static const struct component_ops typec_connector_ops = {
125	.bind = typec_connector_bind,
126	.unbind = typec_connector_unbind,
127};
128
129static 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 */
141int 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 */
167void 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
177static void drm_sysfs_release(struct device *dev)
178{
179	kfree(dev);
180}
181
182/*
183 * Connector properties
184 */
185static 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
227static 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
240static 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
252static 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
264static 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;
291unlock:
292	mutex_unlock(&connector->dev->mode_config.mutex);
293
294	return ret;
295}
296
297static 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
315static 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
324static DEVICE_ATTR_RW(status);
325static DEVICE_ATTR_RO(enabled);
326static DEVICE_ATTR_RO(dpms);
327static DEVICE_ATTR_RO(modes);
328static DEVICE_ATTR_RO(connector_id);
329
330static 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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
339static struct bin_attribute edid_attr = {
340	.attr.name = "edid",
341	.attr.mode = 0444,
342	.size = 0,
343	.read = edid_show,
344};
345
346static struct bin_attribute *connector_bin_attrs[] = {
347	&edid_attr,
348	NULL
349};
350
351static const struct attribute_group connector_dev_group = {
352	.attrs = connector_dev_attrs,
353	.bin_attrs = connector_bin_attrs,
354};
355
 
 
 
 
 
 
 
 
 
 
356static const struct attribute_group *connector_dev_groups[] = {
357	&connector_dev_group,
 
 
358	NULL
359};
360
 
 
 
 
 
 
 
 
 
361int 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	return 0;
404
405err_free:
406	put_device(kdev);
407	return r;
408}
409
410int drm_sysfs_connector_add_late(struct drm_connector *connector)
411{
412	if (connector->ddc)
413		return sysfs_create_link(&connector->kdev->kobj,
414					 &connector->ddc->dev.kobj, "ddc");
415
416	return 0;
417}
418
419void drm_sysfs_connector_remove_early(struct drm_connector *connector)
420{
421	if (connector->ddc)
422		sysfs_remove_link(&connector->kdev->kobj, "ddc");
423}
424
 
 
 
 
 
 
 
425void drm_sysfs_connector_remove(struct drm_connector *connector)
426{
427	if (!connector->kdev)
428		return;
429
430	if (dev_fwnode(connector->kdev))
431		component_del(connector->kdev, &typec_connector_ops);
432
433	DRM_DEBUG("removing \"%s\" from sysfs\n",
434		  connector->name);
435
436	device_unregister(connector->kdev);
437	connector->kdev = NULL;
438}
439
440void drm_sysfs_lease_event(struct drm_device *dev)
441{
442	char *event_string = "LEASE=1";
443	char *envp[] = { event_string, NULL };
444
445	DRM_DEBUG("generating lease event\n");
446
447	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
448}
449
450/**
451 * drm_sysfs_hotplug_event - generate a DRM uevent
452 * @dev: DRM device
453 *
454 * Send a uevent for the DRM device specified by @dev.  Currently we only
455 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
456 * deal with other types of events.
457 *
458 * Any new uapi should be using the drm_sysfs_connector_status_event()
459 * for uevents on connector status change.
460 */
461void drm_sysfs_hotplug_event(struct drm_device *dev)
462{
463	char *event_string = "HOTPLUG=1";
464	char *envp[] = { event_string, NULL };
465
466	DRM_DEBUG("generating hotplug event\n");
467
468	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
469}
470EXPORT_SYMBOL(drm_sysfs_hotplug_event);
471
472/**
473 * drm_sysfs_connector_hotplug_event - generate a DRM uevent for any connector
474 * change
475 * @connector: connector which has changed
476 *
477 * Send a uevent for the DRM connector specified by @connector. This will send
478 * a uevent with the properties HOTPLUG=1 and CONNECTOR.
479 */
480void drm_sysfs_connector_hotplug_event(struct drm_connector *connector)
481{
482	struct drm_device *dev = connector->dev;
483	char hotplug_str[] = "HOTPLUG=1", conn_id[21];
484	char *envp[] = { hotplug_str, conn_id, NULL };
485
486	snprintf(conn_id, sizeof(conn_id),
487		 "CONNECTOR=%u", connector->base.id);
488
489	drm_dbg_kms(connector->dev,
490		    "[CONNECTOR:%d:%s] generating connector hotplug event\n",
491		    connector->base.id, connector->name);
492
493	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
494}
495EXPORT_SYMBOL(drm_sysfs_connector_hotplug_event);
496
497/**
498 * drm_sysfs_connector_property_event - generate a DRM uevent for connector
499 * property change
500 * @connector: connector on which property changed
501 * @property: connector property which has changed.
502 *
503 * Send a uevent for the specified DRM connector and property.  Currently we
504 * set HOTPLUG=1 and connector id along with the attached property id
505 * related to the change.
 
 
 
 
 
 
506 */
507void drm_sysfs_connector_property_event(struct drm_connector *connector,
508					struct drm_property *property)
509{
510	struct drm_device *dev = connector->dev;
511	char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21];
512	char *envp[4] = { hotplug_str, conn_id, prop_id, NULL };
513
514	WARN_ON(!drm_mode_obj_find_prop_id(&connector->base,
515					   property->base.id));
516
517	snprintf(conn_id, ARRAY_SIZE(conn_id),
518		 "CONNECTOR=%u", connector->base.id);
519	snprintf(prop_id, ARRAY_SIZE(prop_id),
520		 "PROPERTY=%u", property->base.id);
521
522	drm_dbg_kms(connector->dev,
523		    "[CONNECTOR:%d:%s] generating connector property event for [PROP:%d:%s]\n",
524		    connector->base.id, connector->name,
525		    property->base.id, property->name);
526
527	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
528}
529EXPORT_SYMBOL(drm_sysfs_connector_property_event);
530
531struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
532{
533	const char *minor_str;
534	struct device *kdev;
535	int r;
536
 
 
 
 
 
 
 
537	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
538	if (!kdev)
539		return ERR_PTR(-ENOMEM);
540
541	device_initialize(kdev);
542
543	if (minor->type == DRM_MINOR_ACCEL) {
544		minor_str = "accel%d";
545		accel_set_device_instance_params(kdev, minor->index);
546	} else {
547		if (minor->type == DRM_MINOR_RENDER)
548			minor_str = "renderD%d";
549		else
550			minor_str = "card%d";
551
552		kdev->devt = MKDEV(DRM_MAJOR, minor->index);
553		kdev->class = drm_class;
554		kdev->type = &drm_sysfs_device_minor;
555	}
556
557	kdev->parent = minor->dev->dev;
558	kdev->release = drm_sysfs_release;
559	dev_set_drvdata(kdev, minor);
560
561	r = dev_set_name(kdev, minor_str, minor->index);
562	if (r < 0)
563		goto err_free;
564
565	return kdev;
566
567err_free:
568	put_device(kdev);
569	return ERR_PTR(r);
570}
571
572/**
573 * drm_class_device_register - register new device with the DRM sysfs class
574 * @dev: device to register
 
575 *
576 * Registers a new &struct device within the DRM sysfs class. Essentially only
577 * used by ttm to have a place for its global settings. Drivers should never use
578 * this.
579 */
 
580int drm_class_device_register(struct device *dev)
581{
582	if (!drm_class || IS_ERR(drm_class))
583		return -ENOENT;
584
585	dev->class = drm_class;
586	return device_register(dev);
587}
588EXPORT_SYMBOL_GPL(drm_class_device_register);
589
590/**
591 * drm_class_device_unregister - unregister device with the DRM sysfs class
592 * @dev: device to unregister
593 *
594 * Unregisters a &struct device from the DRM sysfs class. Essentially only used
595 * by ttm to have a place for its global settings. Drivers should never use
596 * this.
597 */
598void drm_class_device_unregister(struct device *dev)
599{
600	return device_unregister(dev);
601}
602EXPORT_SYMBOL_GPL(drm_class_device_unregister);