blob: f7a615b80c706a3094bb94f5f9981f1a0e5016ae [file] [log] [blame]
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -08001
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/device.h>
16#include <linux/kdev_t.h>
17#include <linux/err.h>
18
19#include "drm_core.h"
Dave Airlief2109732005-09-05 21:33:44 +100020#include "drmP.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Dave Airlie2c14f282008-04-21 16:47:32 +100022#define to_drm_minor(d) container_of(d, struct drm_minor, kdev)
Dave Airlief453ba02008-11-07 14:05:41 -080023#define to_drm_connector(d) container_of(d, struct drm_connector, kdev)
Jesse Barnese8b962b2007-11-22 14:02:38 +100024
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100025static struct device_type drm_sysfs_device_minor = {
26 .name = "drm_minor"
27};
28
Jesse Barnese8b962b2007-11-22 14:02:38 +100029/**
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100030 * drm_class_suspend - DRM class suspend hook
Jesse Barnese8b962b2007-11-22 14:02:38 +100031 * @dev: Linux device to suspend
32 * @state: power state to enter
33 *
34 * Just figures out what the actual struct drm_device associated with
35 * @dev is and calls its suspend hook, if present.
36 */
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100037static int drm_class_suspend(struct device *dev, pm_message_t state)
Jesse Barnese8b962b2007-11-22 14:02:38 +100038{
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100039 if (dev->type == &drm_sysfs_device_minor) {
40 struct drm_minor *drm_minor = to_drm_minor(dev);
41 struct drm_device *drm_dev = drm_minor->dev;
Jesse Barnese8b962b2007-11-22 14:02:38 +100042
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100043 if (drm_minor->type == DRM_MINOR_LEGACY &&
44 !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
45 drm_dev->driver->suspend)
46 return drm_dev->driver->suspend(drm_dev, state);
47 }
Jesse Barnese8b962b2007-11-22 14:02:38 +100048 return 0;
49}
50
51/**
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100052 * drm_class_resume - DRM class resume hook
Jesse Barnese8b962b2007-11-22 14:02:38 +100053 * @dev: Linux device to resume
54 *
55 * Just figures out what the actual struct drm_device associated with
56 * @dev is and calls its resume hook, if present.
57 */
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100058static int drm_class_resume(struct device *dev)
Jesse Barnese8b962b2007-11-22 14:02:38 +100059{
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100060 if (dev->type == &drm_sysfs_device_minor) {
61 struct drm_minor *drm_minor = to_drm_minor(dev);
62 struct drm_device *drm_dev = drm_minor->dev;
Jesse Barnese8b962b2007-11-22 14:02:38 +100063
Thomas Hellstrom08e4d532009-08-20 19:02:31 +100064 if (drm_minor->type == DRM_MINOR_LEGACY &&
65 !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
66 drm_dev->driver->resume)
67 return drm_dev->driver->resume(drm_dev);
68 }
Jesse Barnese8b962b2007-11-22 14:02:38 +100069 return 0;
70}
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/* Display the version of drm_core. This doesn't work right in current design */
73static ssize_t version_show(struct class *dev, char *buf)
74{
75 return sprintf(buf, "%s %d.%d.%d %s\n", CORE_NAME, CORE_MAJOR,
76 CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
77}
78
Kay Sievers02200d02009-04-30 15:23:42 +020079static char *drm_nodename(struct device *dev)
80{
81 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
82}
83
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
85
86/**
87 * drm_sysfs_create - create a struct drm_sysfs_class structure
88 * @owner: pointer to the module that is to "own" this struct drm_sysfs_class
89 * @name: pointer to a string for the name of this class.
90 *
Jesse Barnese8b962b2007-11-22 14:02:38 +100091 * This is used to create DRM class pointer that can then be used
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 * in calls to drm_sysfs_device_add().
93 *
94 * Note, the pointer created here is to be destroyed when finished by making a
95 * call to drm_sysfs_destroy().
96 */
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -080097struct class *drm_sysfs_create(struct module *owner, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -080099 struct class *class;
Jeff Garzik24f73c92006-10-10 14:23:37 -0700100 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -0800102 class = class_create(owner, name);
Akinobu Mita94f060b2006-12-09 10:49:47 +1100103 if (IS_ERR(class)) {
104 err = PTR_ERR(class);
Jeff Garzik24f73c92006-10-10 14:23:37 -0700105 goto err_out;
106 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
Thomas Hellstrom08e4d532009-08-20 19:02:31 +1000108 class->suspend = drm_class_suspend;
109 class->resume = drm_class_resume;
Jesse Barnese8b962b2007-11-22 14:02:38 +1000110
Jeff Garzik24f73c92006-10-10 14:23:37 -0700111 err = class_create_file(class, &class_attr_version);
112 if (err)
113 goto err_out_class;
114
Kay Sievers02200d02009-04-30 15:23:42 +0200115 class->nodename = drm_nodename;
116
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -0800117 return class;
Jeff Garzik24f73c92006-10-10 14:23:37 -0700118
119err_out_class:
120 class_destroy(class);
121err_out:
122 return ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123}
124
125/**
Jesse Barnese8b962b2007-11-22 14:02:38 +1000126 * drm_sysfs_destroy - destroys DRM class
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 *
Jesse Barnese8b962b2007-11-22 14:02:38 +1000128 * Destroy the DRM device class.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 */
Jesse Barnese8b962b2007-11-22 14:02:38 +1000130void drm_sysfs_destroy(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
Jesse Barnese8b962b2007-11-22 14:02:38 +1000132 if ((drm_class == NULL) || (IS_ERR(drm_class)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 return;
Jesse Barnese8b962b2007-11-22 14:02:38 +1000134 class_remove_file(drm_class, &class_attr_version);
135 class_destroy(drm_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
138/**
Jesse Barnese8b962b2007-11-22 14:02:38 +1000139 * drm_sysfs_device_release - do nothing
140 * @dev: Linux device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 *
Jesse Barnese8b962b2007-11-22 14:02:38 +1000142 * Normally, this would free the DRM device associated with @dev, along
143 * with cleaning up any other stuff. But we do that in the DRM core, so
144 * this function can just return and hope that the core does its job.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 */
Jesse Barnese8b962b2007-11-22 14:02:38 +1000146static void drm_sysfs_device_release(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Ma Ling77d26dc2009-04-16 17:51:25 +0800148 memset(dev, 0, sizeof(struct device));
Jesse Barnese8b962b2007-11-22 14:02:38 +1000149 return;
150}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Dave Airlief453ba02008-11-07 14:05:41 -0800152/*
153 * Connector properties
154 */
155static ssize_t status_show(struct device *device,
156 struct device_attribute *attr,
157 char *buf)
158{
159 struct drm_connector *connector = to_drm_connector(device);
160 enum drm_connector_status status;
161
162 status = connector->funcs->detect(connector);
Keith Packard75185c92009-05-30 20:42:25 -0700163 return snprintf(buf, PAGE_SIZE, "%s\n",
Dave Airlief453ba02008-11-07 14:05:41 -0800164 drm_get_connector_status_name(status));
165}
166
167static ssize_t dpms_show(struct device *device,
168 struct device_attribute *attr,
169 char *buf)
170{
171 struct drm_connector *connector = to_drm_connector(device);
172 struct drm_device *dev = connector->dev;
173 uint64_t dpms_status;
174 int ret;
175
176 ret = drm_connector_property_get_value(connector,
177 dev->mode_config.dpms_property,
178 &dpms_status);
179 if (ret)
180 return 0;
181
Keith Packard75185c92009-05-30 20:42:25 -0700182 return snprintf(buf, PAGE_SIZE, "%s\n",
Dave Airlief453ba02008-11-07 14:05:41 -0800183 drm_get_dpms_name((int)dpms_status));
184}
185
186static ssize_t enabled_show(struct device *device,
187 struct device_attribute *attr,
188 char *buf)
189{
190 struct drm_connector *connector = to_drm_connector(device);
191
Keith Packard75185c92009-05-30 20:42:25 -0700192 return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
Dave Airlief453ba02008-11-07 14:05:41 -0800193 "disabled");
194}
195
196static ssize_t edid_show(struct kobject *kobj, struct bin_attribute *attr,
197 char *buf, loff_t off, size_t count)
198{
199 struct device *connector_dev = container_of(kobj, struct device, kobj);
200 struct drm_connector *connector = to_drm_connector(connector_dev);
201 unsigned char *edid;
202 size_t size;
203
204 if (!connector->edid_blob_ptr)
205 return 0;
206
207 edid = connector->edid_blob_ptr->data;
208 size = connector->edid_blob_ptr->length;
209 if (!edid)
210 return 0;
211
212 if (off >= size)
213 return 0;
214
215 if (off + count > size)
216 count = size - off;
217 memcpy(buf, edid + off, count);
218
219 return count;
220}
221
222static ssize_t modes_show(struct device *device,
223 struct device_attribute *attr,
224 char *buf)
225{
226 struct drm_connector *connector = to_drm_connector(device);
227 struct drm_display_mode *mode;
228 int written = 0;
229
230 list_for_each_entry(mode, &connector->modes, head) {
231 written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
232 mode->name);
233 }
234
235 return written;
236}
237
238static ssize_t subconnector_show(struct device *device,
239 struct device_attribute *attr,
240 char *buf)
241{
242 struct drm_connector *connector = to_drm_connector(device);
243 struct drm_device *dev = connector->dev;
244 struct drm_property *prop = NULL;
245 uint64_t subconnector;
246 int is_tv = 0;
247 int ret;
248
249 switch (connector->connector_type) {
250 case DRM_MODE_CONNECTOR_DVII:
251 prop = dev->mode_config.dvi_i_subconnector_property;
252 break;
253 case DRM_MODE_CONNECTOR_Composite:
254 case DRM_MODE_CONNECTOR_SVIDEO:
255 case DRM_MODE_CONNECTOR_Component:
256 prop = dev->mode_config.tv_subconnector_property;
257 is_tv = 1;
258 break;
259 default:
260 DRM_ERROR("Wrong connector type for this property\n");
261 return 0;
262 }
263
264 if (!prop) {
265 DRM_ERROR("Unable to find subconnector property\n");
266 return 0;
267 }
268
269 ret = drm_connector_property_get_value(connector, prop, &subconnector);
270 if (ret)
271 return 0;
272
273 return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
274 drm_get_tv_subconnector_name((int)subconnector) :
275 drm_get_dvi_i_subconnector_name((int)subconnector));
276}
277
278static ssize_t select_subconnector_show(struct device *device,
279 struct device_attribute *attr,
280 char *buf)
281{
282 struct drm_connector *connector = to_drm_connector(device);
283 struct drm_device *dev = connector->dev;
284 struct drm_property *prop = NULL;
285 uint64_t subconnector;
286 int is_tv = 0;
287 int ret;
288
289 switch (connector->connector_type) {
290 case DRM_MODE_CONNECTOR_DVII:
291 prop = dev->mode_config.dvi_i_select_subconnector_property;
292 break;
293 case DRM_MODE_CONNECTOR_Composite:
294 case DRM_MODE_CONNECTOR_SVIDEO:
295 case DRM_MODE_CONNECTOR_Component:
296 prop = dev->mode_config.tv_select_subconnector_property;
297 is_tv = 1;
298 break;
299 default:
300 DRM_ERROR("Wrong connector type for this property\n");
301 return 0;
302 }
303
304 if (!prop) {
305 DRM_ERROR("Unable to find select subconnector property\n");
306 return 0;
307 }
308
309 ret = drm_connector_property_get_value(connector, prop, &subconnector);
310 if (ret)
311 return 0;
312
313 return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
314 drm_get_tv_select_name((int)subconnector) :
315 drm_get_dvi_i_select_name((int)subconnector));
316}
317
318static struct device_attribute connector_attrs[] = {
319 __ATTR_RO(status),
320 __ATTR_RO(enabled),
321 __ATTR_RO(dpms),
322 __ATTR_RO(modes),
323};
324
325/* These attributes are for both DVI-I connectors and all types of tv-out. */
326static struct device_attribute connector_attrs_opt1[] = {
327 __ATTR_RO(subconnector),
328 __ATTR_RO(select_subconnector),
329};
330
331static struct bin_attribute edid_attr = {
332 .attr.name = "edid",
Keith Packarde36ebaf2009-05-30 20:42:26 -0700333 .attr.mode = 0444,
Dave Airlief453ba02008-11-07 14:05:41 -0800334 .size = 128,
335 .read = edid_show,
336};
337
338/**
339 * drm_sysfs_connector_add - add an connector to sysfs
340 * @connector: connector to add
341 *
342 * Create an connector device in sysfs, along with its associated connector
343 * properties (so far, connection status, dpms, mode list & edid) and
344 * generate a hotplug event so userspace knows there's a new connector
345 * available.
346 *
347 * Note:
348 * This routine should only be called *once* for each DRM minor registered.
349 * A second call for an already registered device will trigger the BUG_ON
350 * below.
351 */
352int drm_sysfs_connector_add(struct drm_connector *connector)
353{
354 struct drm_device *dev = connector->dev;
355 int ret = 0, i, j;
356
357 /* We shouldn't get called more than once for the same connector */
358 BUG_ON(device_is_registered(&connector->kdev));
359
360 connector->kdev.parent = &dev->primary->kdev;
361 connector->kdev.class = drm_class;
362 connector->kdev.release = drm_sysfs_device_release;
363
364 DRM_DEBUG("adding \"%s\" to sysfs\n",
365 drm_get_connector_name(connector));
366
Kay Sievers2ead0542009-03-24 16:38:22 -0700367 dev_set_name(&connector->kdev, "card%d-%s",
368 dev->primary->index, drm_get_connector_name(connector));
Dave Airlief453ba02008-11-07 14:05:41 -0800369 ret = device_register(&connector->kdev);
370
371 if (ret) {
372 DRM_ERROR("failed to register connector device: %d\n", ret);
373 goto out;
374 }
375
376 /* Standard attributes */
377
378 for (i = 0; i < ARRAY_SIZE(connector_attrs); i++) {
379 ret = device_create_file(&connector->kdev, &connector_attrs[i]);
380 if (ret)
381 goto err_out_files;
382 }
383
384 /* Optional attributes */
385 /*
386 * In the long run it maybe a good idea to make one set of
387 * optionals per connector type.
388 */
389 switch (connector->connector_type) {
390 case DRM_MODE_CONNECTOR_DVII:
391 case DRM_MODE_CONNECTOR_Composite:
392 case DRM_MODE_CONNECTOR_SVIDEO:
393 case DRM_MODE_CONNECTOR_Component:
394 for (i = 0; i < ARRAY_SIZE(connector_attrs_opt1); i++) {
395 ret = device_create_file(&connector->kdev, &connector_attrs_opt1[i]);
396 if (ret)
397 goto err_out_files;
398 }
399 break;
400 default:
401 break;
402 }
403
404 ret = sysfs_create_bin_file(&connector->kdev.kobj, &edid_attr);
405 if (ret)
406 goto err_out_files;
407
408 /* Let userspace know we have a new connector */
409 drm_sysfs_hotplug_event(dev);
410
411 return 0;
412
413err_out_files:
414 if (i > 0)
415 for (j = 0; j < i; j++)
416 device_remove_file(&connector->kdev,
417 &connector_attrs[i]);
418 device_unregister(&connector->kdev);
419
420out:
421 return ret;
422}
423EXPORT_SYMBOL(drm_sysfs_connector_add);
424
425/**
426 * drm_sysfs_connector_remove - remove an connector device from sysfs
427 * @connector: connector to remove
428 *
429 * Remove @connector and its associated attributes from sysfs. Note that
430 * the device model core will take care of sending the "remove" uevent
431 * at this time, so we don't need to do it.
432 *
433 * Note:
434 * This routine should only be called if the connector was previously
435 * successfully registered. If @connector hasn't been registered yet,
436 * you'll likely see a panic somewhere deep in sysfs code when called.
437 */
438void drm_sysfs_connector_remove(struct drm_connector *connector)
439{
440 int i;
441
442 DRM_DEBUG("removing \"%s\" from sysfs\n",
443 drm_get_connector_name(connector));
444
445 for (i = 0; i < ARRAY_SIZE(connector_attrs); i++)
446 device_remove_file(&connector->kdev, &connector_attrs[i]);
447 sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr);
448 device_unregister(&connector->kdev);
449}
450EXPORT_SYMBOL(drm_sysfs_connector_remove);
451
452/**
453 * drm_sysfs_hotplug_event - generate a DRM uevent
454 * @dev: DRM device
455 *
456 * Send a uevent for the DRM device specified by @dev. Currently we only
457 * set HOTPLUG=1 in the uevent environment, but this could be expanded to
458 * deal with other types of events.
459 */
460void drm_sysfs_hotplug_event(struct drm_device *dev)
461{
462 char *event_string = "HOTPLUG=1";
463 char *envp[] = { event_string, NULL };
464
465 DRM_DEBUG("generating hotplug event\n");
466
467 kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp);
468}
Jesse Barnes5ca58282009-03-31 14:11:15 -0700469EXPORT_SYMBOL(drm_sysfs_hotplug_event);
Dave Airlief453ba02008-11-07 14:05:41 -0800470
Jesse Barnese8b962b2007-11-22 14:02:38 +1000471/**
472 * drm_sysfs_device_add - adds a class device to sysfs for a character driver
473 * @dev: DRM device to be added
474 * @head: DRM head in question
475 *
476 * Add a DRM device to the DRM's device model class. We use @dev's PCI device
477 * as the parent for the Linux device, and make sure it has a file containing
478 * the driver we're using (for userspace compatibility).
479 */
Dave Airlie2c14f282008-04-21 16:47:32 +1000480int drm_sysfs_device_add(struct drm_minor *minor)
Jesse Barnese8b962b2007-11-22 14:02:38 +1000481{
482 int err;
Dave Airlie2c14f282008-04-21 16:47:32 +1000483 char *minor_str;
Jesse Barnese8b962b2007-11-22 14:02:38 +1000484
Dave Airlie2c14f282008-04-21 16:47:32 +1000485 minor->kdev.parent = &minor->dev->pdev->dev;
486 minor->kdev.class = drm_class;
487 minor->kdev.release = drm_sysfs_device_release;
488 minor->kdev.devt = minor->device;
Thomas Hellstrom08e4d532009-08-20 19:02:31 +1000489 minor->kdev.type = &drm_sysfs_device_minor;
Dave Airlief453ba02008-11-07 14:05:41 -0800490 if (minor->type == DRM_MINOR_CONTROL)
491 minor_str = "controlD%d";
492 else if (minor->type == DRM_MINOR_RENDER)
493 minor_str = "renderD%d";
494 else
495 minor_str = "card%d";
Jesse Barnese8b962b2007-11-22 14:02:38 +1000496
Kay Sievers8f4bbd92009-01-06 10:44:41 -0800497 dev_set_name(&minor->kdev, minor_str, minor->index);
Dave Airlie2c14f282008-04-21 16:47:32 +1000498
499 err = device_register(&minor->kdev);
Jesse Barnese8b962b2007-11-22 14:02:38 +1000500 if (err) {
501 DRM_ERROR("device add failed: %d\n", err);
Jeff Garzik24f73c92006-10-10 14:23:37 -0700502 goto err_out;
503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Jesse Barnese8b962b2007-11-22 14:02:38 +1000505 return 0;
Jeff Garzik24f73c92006-10-10 14:23:37 -0700506
Jeff Garzik24f73c92006-10-10 14:23:37 -0700507err_out:
Jesse Barnese8b962b2007-11-22 14:02:38 +1000508 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509}
510
511/**
Jesse Barnese8b962b2007-11-22 14:02:38 +1000512 * drm_sysfs_device_remove - remove DRM device
513 * @dev: DRM device to remove
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 *
515 * This call unregisters and cleans up a class device that was created with a
516 * call to drm_sysfs_device_add()
517 */
Dave Airlie2c14f282008-04-21 16:47:32 +1000518void drm_sysfs_device_remove(struct drm_minor *minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
Dave Airlie2c14f282008-04-21 16:47:32 +1000520 device_unregister(&minor->kdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521}