xref: /openbmc/linux/drivers/gpu/drm/drm_sysfs.c (revision fcee01b9)
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/err.h>
17 #include <linux/export.h>
18 #include <linux/gfp.h>
19 #include <linux/kdev_t.h>
20 #include <linux/slab.h>
21 
22 #include <drm/drm_connector.h>
23 #include <drm/drm_device.h>
24 #include <drm/drm_file.h>
25 #include <drm/drm_modes.h>
26 #include <drm/drm_print.h>
27 #include <drm/drm_property.h>
28 #include <drm/drm_sysfs.h>
29 
30 #include "drm_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 	drm_setup_hdcp_srm(drm_class);
89 	return 0;
90 }
91 
92 /**
93  * drm_sysfs_destroy - destroys DRM class
94  *
95  * Destroy the DRM device class.
96  */
97 void drm_sysfs_destroy(void)
98 {
99 	if (IS_ERR_OR_NULL(drm_class))
100 		return;
101 	drm_teardown_hdcp_srm(drm_class);
102 	class_remove_file(drm_class, &class_attr_version.attr);
103 	class_destroy(drm_class);
104 	drm_class = NULL;
105 }
106 
107 /*
108  * Connector properties
109  */
110 static ssize_t status_store(struct device *device,
111 			   struct device_attribute *attr,
112 			   const char *buf, size_t count)
113 {
114 	struct drm_connector *connector = to_drm_connector(device);
115 	struct drm_device *dev = connector->dev;
116 	enum drm_connector_force old_force;
117 	int ret;
118 
119 	ret = mutex_lock_interruptible(&dev->mode_config.mutex);
120 	if (ret)
121 		return ret;
122 
123 	old_force = connector->force;
124 
125 	if (sysfs_streq(buf, "detect"))
126 		connector->force = 0;
127 	else if (sysfs_streq(buf, "on"))
128 		connector->force = DRM_FORCE_ON;
129 	else if (sysfs_streq(buf, "on-digital"))
130 		connector->force = DRM_FORCE_ON_DIGITAL;
131 	else if (sysfs_streq(buf, "off"))
132 		connector->force = DRM_FORCE_OFF;
133 	else
134 		ret = -EINVAL;
135 
136 	if (old_force != connector->force || !connector->force) {
137 		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
138 			      connector->base.id,
139 			      connector->name,
140 			      old_force, connector->force);
141 
142 		connector->funcs->fill_modes(connector,
143 					     dev->mode_config.max_width,
144 					     dev->mode_config.max_height);
145 	}
146 
147 	mutex_unlock(&dev->mode_config.mutex);
148 
149 	return ret ? ret : count;
150 }
151 
152 static ssize_t status_show(struct device *device,
153 			   struct device_attribute *attr,
154 			   char *buf)
155 {
156 	struct drm_connector *connector = to_drm_connector(device);
157 	enum drm_connector_status status;
158 
159 	status = READ_ONCE(connector->status);
160 
161 	return snprintf(buf, PAGE_SIZE, "%s\n",
162 			drm_get_connector_status_name(status));
163 }
164 
165 static ssize_t dpms_show(struct device *device,
166 			   struct device_attribute *attr,
167 			   char *buf)
168 {
169 	struct drm_connector *connector = to_drm_connector(device);
170 	int dpms;
171 
172 	dpms = READ_ONCE(connector->dpms);
173 
174 	return snprintf(buf, PAGE_SIZE, "%s\n",
175 			drm_get_dpms_name(dpms));
176 }
177 
178 static ssize_t enabled_show(struct device *device,
179 			    struct device_attribute *attr,
180 			   char *buf)
181 {
182 	struct drm_connector *connector = to_drm_connector(device);
183 	bool enabled;
184 
185 	enabled = READ_ONCE(connector->encoder);
186 
187 	return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n");
188 }
189 
190 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
191 			 struct bin_attribute *attr, char *buf, loff_t off,
192 			 size_t count)
193 {
194 	struct device *connector_dev = kobj_to_dev(kobj);
195 	struct drm_connector *connector = to_drm_connector(connector_dev);
196 	unsigned char *edid;
197 	size_t size;
198 	ssize_t ret = 0;
199 
200 	mutex_lock(&connector->dev->mode_config.mutex);
201 	if (!connector->edid_blob_ptr)
202 		goto unlock;
203 
204 	edid = connector->edid_blob_ptr->data;
205 	size = connector->edid_blob_ptr->length;
206 	if (!edid)
207 		goto unlock;
208 
209 	if (off >= size)
210 		goto unlock;
211 
212 	if (off + count > size)
213 		count = size - off;
214 	memcpy(buf, edid + off, count);
215 
216 	ret = count;
217 unlock:
218 	mutex_unlock(&connector->dev->mode_config.mutex);
219 
220 	return ret;
221 }
222 
223 static ssize_t modes_show(struct device *device,
224 			   struct device_attribute *attr,
225 			   char *buf)
226 {
227 	struct drm_connector *connector = to_drm_connector(device);
228 	struct drm_display_mode *mode;
229 	int written = 0;
230 
231 	mutex_lock(&connector->dev->mode_config.mutex);
232 	list_for_each_entry(mode, &connector->modes, head) {
233 		written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
234 				    mode->name);
235 	}
236 	mutex_unlock(&connector->dev->mode_config.mutex);
237 
238 	return written;
239 }
240 
241 static DEVICE_ATTR_RW(status);
242 static DEVICE_ATTR_RO(enabled);
243 static DEVICE_ATTR_RO(dpms);
244 static DEVICE_ATTR_RO(modes);
245 
246 static struct attribute *connector_dev_attrs[] = {
247 	&dev_attr_status.attr,
248 	&dev_attr_enabled.attr,
249 	&dev_attr_dpms.attr,
250 	&dev_attr_modes.attr,
251 	NULL
252 };
253 
254 static struct bin_attribute edid_attr = {
255 	.attr.name = "edid",
256 	.attr.mode = 0444,
257 	.size = 0,
258 	.read = edid_show,
259 };
260 
261 static struct bin_attribute *connector_bin_attrs[] = {
262 	&edid_attr,
263 	NULL
264 };
265 
266 static const struct attribute_group connector_dev_group = {
267 	.attrs = connector_dev_attrs,
268 	.bin_attrs = connector_bin_attrs,
269 };
270 
271 static const struct attribute_group *connector_dev_groups[] = {
272 	&connector_dev_group,
273 	NULL
274 };
275 
276 int drm_sysfs_connector_add(struct drm_connector *connector)
277 {
278 	struct drm_device *dev = connector->dev;
279 
280 	if (connector->kdev)
281 		return 0;
282 
283 	connector->kdev =
284 		device_create_with_groups(drm_class, dev->primary->kdev, 0,
285 					  connector, connector_dev_groups,
286 					  "card%d-%s", dev->primary->index,
287 					  connector->name);
288 	DRM_DEBUG("adding \"%s\" to sysfs\n",
289 		  connector->name);
290 
291 	if (IS_ERR(connector->kdev)) {
292 		DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
293 		return PTR_ERR(connector->kdev);
294 	}
295 
296 	/* Let userspace know we have a new connector */
297 	drm_sysfs_hotplug_event(dev);
298 
299 	return 0;
300 }
301 
302 void drm_sysfs_connector_remove(struct drm_connector *connector)
303 {
304 	if (!connector->kdev)
305 		return;
306 	DRM_DEBUG("removing \"%s\" from sysfs\n",
307 		  connector->name);
308 
309 	device_unregister(connector->kdev);
310 	connector->kdev = NULL;
311 }
312 
313 void drm_sysfs_lease_event(struct drm_device *dev)
314 {
315 	char *event_string = "LEASE=1";
316 	char *envp[] = { event_string, NULL };
317 
318 	DRM_DEBUG("generating lease event\n");
319 
320 	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
321 }
322 
323 /**
324  * drm_sysfs_hotplug_event - generate a DRM uevent
325  * @dev: DRM device
326  *
327  * Send a uevent for the DRM device specified by @dev.  Currently we only
328  * set HOTPLUG=1 in the uevent environment, but this could be expanded to
329  * deal with other types of events.
330  */
331 void drm_sysfs_hotplug_event(struct drm_device *dev)
332 {
333 	char *event_string = "HOTPLUG=1";
334 	char *envp[] = { event_string, NULL };
335 
336 	DRM_DEBUG("generating hotplug event\n");
337 
338 	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
339 }
340 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
341 
342 static void drm_sysfs_release(struct device *dev)
343 {
344 	kfree(dev);
345 }
346 
347 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
348 {
349 	const char *minor_str;
350 	struct device *kdev;
351 	int r;
352 
353 	if (minor->type == DRM_MINOR_RENDER)
354 		minor_str = "renderD%d";
355 	else
356 		minor_str = "card%d";
357 
358 	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
359 	if (!kdev)
360 		return ERR_PTR(-ENOMEM);
361 
362 	device_initialize(kdev);
363 	kdev->devt = MKDEV(DRM_MAJOR, minor->index);
364 	kdev->class = drm_class;
365 	kdev->type = &drm_sysfs_device_minor;
366 	kdev->parent = minor->dev->dev;
367 	kdev->release = drm_sysfs_release;
368 	dev_set_drvdata(kdev, minor);
369 
370 	r = dev_set_name(kdev, minor_str, minor->index);
371 	if (r < 0)
372 		goto err_free;
373 
374 	return kdev;
375 
376 err_free:
377 	put_device(kdev);
378 	return ERR_PTR(r);
379 }
380 
381 /**
382  * drm_class_device_register - register new device with the DRM sysfs class
383  * @dev: device to register
384  *
385  * Registers a new &struct device within the DRM sysfs class. Essentially only
386  * used by ttm to have a place for its global settings. Drivers should never use
387  * this.
388  */
389 int drm_class_device_register(struct device *dev)
390 {
391 	if (!drm_class || IS_ERR(drm_class))
392 		return -ENOENT;
393 
394 	dev->class = drm_class;
395 	return device_register(dev);
396 }
397 EXPORT_SYMBOL_GPL(drm_class_device_register);
398 
399 /**
400  * drm_class_device_unregister - unregister device with the DRM sysfs class
401  * @dev: device to unregister
402  *
403  * Unregisters a &struct device from the DRM sysfs class. Essentially only used
404  * by ttm to have a place for its global settings. Drivers should never use
405  * this.
406  */
407 void drm_class_device_unregister(struct device *dev)
408 {
409 	return device_unregister(dev);
410 }
411 EXPORT_SYMBOL_GPL(drm_class_device_unregister);
412