xref: /openbmc/linux/drivers/gpu/drm/drm_sysfs.c (revision 877013bc)
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/device.h>
14 #include <linux/err.h>
15 #include <linux/export.h>
16 #include <linux/gfp.h>
17 #include <linux/i2c.h>
18 #include <linux/kdev_t.h>
19 #include <linux/slab.h>
20 
21 #include <drm/drm_connector.h>
22 #include <drm/drm_device.h>
23 #include <drm/drm_file.h>
24 #include <drm/drm_modes.h>
25 #include <drm/drm_print.h>
26 #include <drm/drm_property.h>
27 #include <drm/drm_sysfs.h>
28 
29 #include "drm_internal.h"
30 #include "drm_crtc_internal.h"
31 
32 #define to_drm_minor(d) dev_get_drvdata(d)
33 #define to_drm_connector(d) dev_get_drvdata(d)
34 
35 /**
36  * DOC: overview
37  *
38  * DRM provides very little additional support to drivers for sysfs
39  * interactions, beyond just all the standard stuff. Drivers who want to expose
40  * additional sysfs properties and property groups can attach them at either
41  * &drm_device.dev or &drm_connector.kdev.
42  *
43  * Registration is automatically handled when calling drm_dev_register(), or
44  * drm_connector_register() in case of hot-plugged connectors. Unregistration is
45  * also automatically handled by drm_dev_unregister() and
46  * drm_connector_unregister().
47  */
48 
49 static struct device_type drm_sysfs_device_minor = {
50 	.name = "drm_minor"
51 };
52 
53 struct class *drm_class;
54 
55 static char *drm_devnode(struct device *dev, umode_t *mode)
56 {
57 	return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
58 }
59 
60 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810");
61 
62 /**
63  * drm_sysfs_init - initialize sysfs helpers
64  *
65  * This is used to create the DRM class, which is the implicit parent of any
66  * other top-level DRM sysfs objects.
67  *
68  * You must call drm_sysfs_destroy() to release the allocated resources.
69  *
70  * Return: 0 on success, negative error code on failure.
71  */
72 int drm_sysfs_init(void)
73 {
74 	int err;
75 
76 	drm_class = class_create(THIS_MODULE, "drm");
77 	if (IS_ERR(drm_class))
78 		return PTR_ERR(drm_class);
79 
80 	err = class_create_file(drm_class, &class_attr_version.attr);
81 	if (err) {
82 		class_destroy(drm_class);
83 		drm_class = NULL;
84 		return err;
85 	}
86 
87 	drm_class->devnode = drm_devnode;
88 	return 0;
89 }
90 
91 /**
92  * drm_sysfs_destroy - destroys DRM class
93  *
94  * Destroy the DRM device class.
95  */
96 void drm_sysfs_destroy(void)
97 {
98 	if (IS_ERR_OR_NULL(drm_class))
99 		return;
100 	class_remove_file(drm_class, &class_attr_version.attr);
101 	class_destroy(drm_class);
102 	drm_class = NULL;
103 }
104 
105 /*
106  * Connector properties
107  */
108 static ssize_t status_store(struct device *device,
109 			   struct device_attribute *attr,
110 			   const char *buf, size_t count)
111 {
112 	struct drm_connector *connector = to_drm_connector(device);
113 	struct drm_device *dev = connector->dev;
114 	enum drm_connector_force old_force;
115 	int ret;
116 
117 	ret = mutex_lock_interruptible(&dev->mode_config.mutex);
118 	if (ret)
119 		return ret;
120 
121 	old_force = connector->force;
122 
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;
131 	else
132 		ret = -EINVAL;
133 
134 	if (old_force != connector->force || !connector->force) {
135 		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
136 			      connector->base.id,
137 			      connector->name,
138 			      old_force, connector->force);
139 
140 		connector->funcs->fill_modes(connector,
141 					     dev->mode_config.max_width,
142 					     dev->mode_config.max_height);
143 	}
144 
145 	mutex_unlock(&dev->mode_config.mutex);
146 
147 	return ret ? ret : count;
148 }
149 
150 static ssize_t status_show(struct device *device,
151 			   struct device_attribute *attr,
152 			   char *buf)
153 {
154 	struct drm_connector *connector = to_drm_connector(device);
155 	enum drm_connector_status status;
156 
157 	status = READ_ONCE(connector->status);
158 
159 	return sysfs_emit(buf, "%s\n",
160 			  drm_get_connector_status_name(status));
161 }
162 
163 static ssize_t dpms_show(struct device *device,
164 			   struct device_attribute *attr,
165 			   char *buf)
166 {
167 	struct drm_connector *connector = to_drm_connector(device);
168 	int dpms;
169 
170 	dpms = READ_ONCE(connector->dpms);
171 
172 	return sysfs_emit(buf, "%s\n", drm_get_dpms_name(dpms));
173 }
174 
175 static ssize_t enabled_show(struct device *device,
176 			    struct device_attribute *attr,
177 			   char *buf)
178 {
179 	struct drm_connector *connector = to_drm_connector(device);
180 	bool enabled;
181 
182 	enabled = READ_ONCE(connector->encoder);
183 
184 	return sysfs_emit(buf, enabled ? "enabled\n" : "disabled\n");
185 }
186 
187 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
188 			 struct bin_attribute *attr, char *buf, loff_t off,
189 			 size_t count)
190 {
191 	struct device *connector_dev = kobj_to_dev(kobj);
192 	struct drm_connector *connector = to_drm_connector(connector_dev);
193 	unsigned char *edid;
194 	size_t size;
195 	ssize_t ret = 0;
196 
197 	mutex_lock(&connector->dev->mode_config.mutex);
198 	if (!connector->edid_blob_ptr)
199 		goto unlock;
200 
201 	edid = connector->edid_blob_ptr->data;
202 	size = connector->edid_blob_ptr->length;
203 	if (!edid)
204 		goto unlock;
205 
206 	if (off >= size)
207 		goto unlock;
208 
209 	if (off + count > size)
210 		count = size - off;
211 	memcpy(buf, edid + off, count);
212 
213 	ret = count;
214 unlock:
215 	mutex_unlock(&connector->dev->mode_config.mutex);
216 
217 	return ret;
218 }
219 
220 static ssize_t modes_show(struct device *device,
221 			   struct device_attribute *attr,
222 			   char *buf)
223 {
224 	struct drm_connector *connector = to_drm_connector(device);
225 	struct drm_display_mode *mode;
226 	int written = 0;
227 
228 	mutex_lock(&connector->dev->mode_config.mutex);
229 	list_for_each_entry(mode, &connector->modes, head) {
230 		written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n",
231 				    mode->name);
232 	}
233 	mutex_unlock(&connector->dev->mode_config.mutex);
234 
235 	return written;
236 }
237 
238 static DEVICE_ATTR_RW(status);
239 static DEVICE_ATTR_RO(enabled);
240 static DEVICE_ATTR_RO(dpms);
241 static DEVICE_ATTR_RO(modes);
242 
243 static struct attribute *connector_dev_attrs[] = {
244 	&dev_attr_status.attr,
245 	&dev_attr_enabled.attr,
246 	&dev_attr_dpms.attr,
247 	&dev_attr_modes.attr,
248 	NULL
249 };
250 
251 static struct bin_attribute edid_attr = {
252 	.attr.name = "edid",
253 	.attr.mode = 0444,
254 	.size = 0,
255 	.read = edid_show,
256 };
257 
258 static struct bin_attribute *connector_bin_attrs[] = {
259 	&edid_attr,
260 	NULL
261 };
262 
263 static const struct attribute_group connector_dev_group = {
264 	.attrs = connector_dev_attrs,
265 	.bin_attrs = connector_bin_attrs,
266 };
267 
268 static const struct attribute_group *connector_dev_groups[] = {
269 	&connector_dev_group,
270 	NULL
271 };
272 
273 int drm_sysfs_connector_add(struct drm_connector *connector)
274 {
275 	struct drm_device *dev = connector->dev;
276 
277 	if (connector->kdev)
278 		return 0;
279 
280 	connector->kdev =
281 		device_create_with_groups(drm_class, dev->primary->kdev, 0,
282 					  connector, connector_dev_groups,
283 					  "card%d-%s", dev->primary->index,
284 					  connector->name);
285 	DRM_DEBUG("adding \"%s\" to sysfs\n",
286 		  connector->name);
287 
288 	if (IS_ERR(connector->kdev)) {
289 		DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
290 		return PTR_ERR(connector->kdev);
291 	}
292 
293 	if (connector->ddc)
294 		return sysfs_create_link(&connector->kdev->kobj,
295 				 &connector->ddc->dev.kobj, "ddc");
296 	return 0;
297 }
298 
299 void drm_sysfs_connector_remove(struct drm_connector *connector)
300 {
301 	if (!connector->kdev)
302 		return;
303 
304 	if (connector->ddc)
305 		sysfs_remove_link(&connector->kdev->kobj, "ddc");
306 
307 	DRM_DEBUG("removing \"%s\" from sysfs\n",
308 		  connector->name);
309 
310 	device_unregister(connector->kdev);
311 	connector->kdev = NULL;
312 }
313 
314 void drm_sysfs_lease_event(struct drm_device *dev)
315 {
316 	char *event_string = "LEASE=1";
317 	char *envp[] = { event_string, NULL };
318 
319 	DRM_DEBUG("generating lease event\n");
320 
321 	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
322 }
323 
324 /**
325  * drm_sysfs_hotplug_event - generate a DRM uevent
326  * @dev: DRM device
327  *
328  * Send a uevent for the DRM device specified by @dev.  Currently we only
329  * set HOTPLUG=1 in the uevent environment, but this could be expanded to
330  * deal with other types of events.
331  *
332  * Any new uapi should be using the drm_sysfs_connector_status_event()
333  * for uevents on connector status change.
334  */
335 void drm_sysfs_hotplug_event(struct drm_device *dev)
336 {
337 	char *event_string = "HOTPLUG=1";
338 	char *envp[] = { event_string, NULL };
339 
340 	DRM_DEBUG("generating hotplug event\n");
341 
342 	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
343 }
344 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
345 
346 /**
347  * drm_sysfs_connector_status_event - generate a DRM uevent for connector
348  * property status change
349  * @connector: connector on which property status changed
350  * @property: connector property whose status changed.
351  *
352  * Send a uevent for the DRM device specified by @dev.  Currently we
353  * set HOTPLUG=1 and connector id along with the attached property id
354  * related to the status change.
355  */
356 void drm_sysfs_connector_status_event(struct drm_connector *connector,
357 				      struct drm_property *property)
358 {
359 	struct drm_device *dev = connector->dev;
360 	char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21];
361 	char *envp[4] = { hotplug_str, conn_id, prop_id, NULL };
362 
363 	WARN_ON(!drm_mode_obj_find_prop_id(&connector->base,
364 					   property->base.id));
365 
366 	snprintf(conn_id, ARRAY_SIZE(conn_id),
367 		 "CONNECTOR=%u", connector->base.id);
368 	snprintf(prop_id, ARRAY_SIZE(prop_id),
369 		 "PROPERTY=%u", property->base.id);
370 
371 	DRM_DEBUG("generating connector status event\n");
372 
373 	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
374 }
375 EXPORT_SYMBOL(drm_sysfs_connector_status_event);
376 
377 static void drm_sysfs_release(struct device *dev)
378 {
379 	kfree(dev);
380 }
381 
382 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
383 {
384 	const char *minor_str;
385 	struct device *kdev;
386 	int r;
387 
388 	if (minor->type == DRM_MINOR_RENDER)
389 		minor_str = "renderD%d";
390 	else
391 		minor_str = "card%d";
392 
393 	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
394 	if (!kdev)
395 		return ERR_PTR(-ENOMEM);
396 
397 	device_initialize(kdev);
398 	kdev->devt = MKDEV(DRM_MAJOR, minor->index);
399 	kdev->class = drm_class;
400 	kdev->type = &drm_sysfs_device_minor;
401 	kdev->parent = minor->dev->dev;
402 	kdev->release = drm_sysfs_release;
403 	dev_set_drvdata(kdev, minor);
404 
405 	r = dev_set_name(kdev, minor_str, minor->index);
406 	if (r < 0)
407 		goto err_free;
408 
409 	return kdev;
410 
411 err_free:
412 	put_device(kdev);
413 	return ERR_PTR(r);
414 }
415 
416 /**
417  * drm_class_device_register - register new device with the DRM sysfs class
418  * @dev: device to register
419  *
420  * Registers a new &struct device within the DRM sysfs class. Essentially only
421  * used by ttm to have a place for its global settings. Drivers should never use
422  * this.
423  */
424 int drm_class_device_register(struct device *dev)
425 {
426 	if (!drm_class || IS_ERR(drm_class))
427 		return -ENOENT;
428 
429 	dev->class = drm_class;
430 	return device_register(dev);
431 }
432 EXPORT_SYMBOL_GPL(drm_class_device_register);
433 
434 /**
435  * drm_class_device_unregister - unregister device with the DRM sysfs class
436  * @dev: device to unregister
437  *
438  * Unregisters a &struct device from the DRM sysfs class. Essentially only used
439  * by ttm to have a place for its global settings. Drivers should never use
440  * this.
441  */
442 void drm_class_device_unregister(struct device *dev)
443 {
444 	return device_unregister(dev);
445 }
446 EXPORT_SYMBOL_GPL(drm_class_device_unregister);
447