2006-01-20 15:08:59 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* drm_sysfs.c - Modifications to drm_sysfs_class.c to support
|
|
|
|
* extra sysfs attribute from DRM. Normal drm_sysfs_class
|
|
|
|
* does not allow adding attributes.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com>
|
|
|
|
* Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com>
|
|
|
|
* Copyright (c) 2003-2004 IBM Corp.
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/kdev_t.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/err.h>
|
2011-08-30 16:16:33 -06:00
|
|
|
#include <linux/export.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-10-02 11:01:07 -06:00
|
|
|
#include <drm/drm_sysfs.h>
|
|
|
|
#include <drm/drm_core.h>
|
|
|
|
#include <drm/drmP.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-21 00:47:32 -06:00
|
|
|
#define to_drm_minor(d) container_of(d, struct drm_minor, kdev)
|
2008-11-07 15:05:41 -07:00
|
|
|
#define to_drm_connector(d) container_of(d, struct drm_connector, kdev)
|
2007-11-21 21:02:38 -07:00
|
|
|
|
2009-08-20 03:02:31 -06:00
|
|
|
static struct device_type drm_sysfs_device_minor = {
|
|
|
|
.name = "drm_minor"
|
|
|
|
};
|
|
|
|
|
2007-11-21 21:02:38 -07:00
|
|
|
/**
|
2013-07-01 16:06:02 -06:00
|
|
|
* __drm_class_suspend - internal DRM class suspend routine
|
2007-11-21 21:02:38 -07:00
|
|
|
* @dev: Linux device to suspend
|
|
|
|
* @state: power state to enter
|
|
|
|
*
|
|
|
|
* Just figures out what the actual struct drm_device associated with
|
|
|
|
* @dev is and calls its suspend hook, if present.
|
|
|
|
*/
|
2013-07-01 16:06:02 -06:00
|
|
|
static int __drm_class_suspend(struct device *dev, pm_message_t state)
|
2007-11-21 21:02:38 -07:00
|
|
|
{
|
2009-08-20 03:02:31 -06:00
|
|
|
if (dev->type == &drm_sysfs_device_minor) {
|
|
|
|
struct drm_minor *drm_minor = to_drm_minor(dev);
|
|
|
|
struct drm_device *drm_dev = drm_minor->dev;
|
|
|
|
|
|
|
|
if (drm_minor->type == DRM_MINOR_LEGACY &&
|
|
|
|
!drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
|
|
|
|
drm_dev->driver->suspend)
|
|
|
|
return drm_dev->driver->suspend(drm_dev, state);
|
|
|
|
}
|
2007-11-21 21:02:38 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-01 16:06:02 -06:00
|
|
|
/**
|
|
|
|
* drm_class_suspend - internal DRM class suspend hook. Simply calls
|
|
|
|
* __drm_class_suspend() with the correct pm state.
|
|
|
|
* @dev: Linux device to suspend
|
|
|
|
*/
|
|
|
|
static int drm_class_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
return __drm_class_suspend(dev, PMSG_SUSPEND);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_class_freeze - internal DRM class freeze hook. Simply calls
|
|
|
|
* __drm_class_suspend() with the correct pm state.
|
|
|
|
* @dev: Linux device to freeze
|
|
|
|
*/
|
|
|
|
static int drm_class_freeze(struct device *dev)
|
|
|
|
{
|
|
|
|
return __drm_class_suspend(dev, PMSG_FREEZE);
|
|
|
|
}
|
|
|
|
|
2007-11-21 21:02:38 -07:00
|
|
|
/**
|
2009-08-20 03:02:31 -06:00
|
|
|
* drm_class_resume - DRM class resume hook
|
2007-11-21 21:02:38 -07:00
|
|
|
* @dev: Linux device to resume
|
|
|
|
*
|
|
|
|
* Just figures out what the actual struct drm_device associated with
|
|
|
|
* @dev is and calls its resume hook, if present.
|
|
|
|
*/
|
2009-08-20 03:02:31 -06:00
|
|
|
static int drm_class_resume(struct device *dev)
|
2007-11-21 21:02:38 -07:00
|
|
|
{
|
2009-08-20 03:02:31 -06:00
|
|
|
if (dev->type == &drm_sysfs_device_minor) {
|
|
|
|
struct drm_minor *drm_minor = to_drm_minor(dev);
|
|
|
|
struct drm_device *drm_dev = drm_minor->dev;
|
|
|
|
|
|
|
|
if (drm_minor->type == DRM_MINOR_LEGACY &&
|
|
|
|
!drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
|
|
|
|
drm_dev->driver->resume)
|
|
|
|
return drm_dev->driver->resume(drm_dev);
|
|
|
|
}
|
2007-11-21 21:02:38 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-01 16:06:02 -06:00
|
|
|
static const struct dev_pm_ops drm_class_dev_pm_ops = {
|
|
|
|
.suspend = drm_class_suspend,
|
|
|
|
.resume = drm_class_resume,
|
|
|
|
.freeze = drm_class_freeze,
|
|
|
|
};
|
|
|
|
|
2011-07-23 18:24:48 -06:00
|
|
|
static char *drm_devnode(struct device *dev, umode_t *mode)
|
2009-04-30 07:23:42 -06:00
|
|
|
{
|
|
|
|
return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
|
|
|
|
}
|
|
|
|
|
2010-01-05 04:48:09 -07:00
|
|
|
static CLASS_ATTR_STRING(version, S_IRUGO,
|
|
|
|
CORE_NAME " "
|
|
|
|
__stringify(CORE_MAJOR) "."
|
|
|
|
__stringify(CORE_MINOR) "."
|
|
|
|
__stringify(CORE_PATCHLEVEL) " "
|
|
|
|
CORE_DATE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_sysfs_create - create a struct drm_sysfs_class structure
|
|
|
|
* @owner: pointer to the module that is to "own" this struct drm_sysfs_class
|
|
|
|
* @name: pointer to a string for the name of this class.
|
|
|
|
*
|
2007-11-21 21:02:38 -07:00
|
|
|
* This is used to create DRM class pointer that can then be used
|
2005-04-16 16:20:36 -06:00
|
|
|
* in calls to drm_sysfs_device_add().
|
|
|
|
*
|
|
|
|
* Note, the pointer created here is to be destroyed when finished by making a
|
|
|
|
* call to drm_sysfs_destroy().
|
|
|
|
*/
|
2006-01-20 15:08:59 -07:00
|
|
|
struct class *drm_sysfs_create(struct module *owner, char *name)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-20 15:08:59 -07:00
|
|
|
struct class *class;
|
2006-10-10 15:23:37 -06:00
|
|
|
int err;
|
2006-01-20 15:08:59 -07:00
|
|
|
|
|
|
|
class = class_create(owner, name);
|
2006-12-08 16:49:47 -07:00
|
|
|
if (IS_ERR(class)) {
|
|
|
|
err = PTR_ERR(class);
|
2006-10-10 15:23:37 -06:00
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
2013-07-01 16:06:02 -06:00
|
|
|
class->pm = &drm_class_dev_pm_ops;
|
2007-11-21 21:02:38 -07:00
|
|
|
|
2010-01-05 04:48:09 -07:00
|
|
|
err = class_create_file(class, &class_attr_version.attr);
|
2006-10-10 15:23:37 -06:00
|
|
|
if (err)
|
|
|
|
goto err_out_class;
|
2006-01-20 15:08:59 -07:00
|
|
|
|
2009-09-18 15:01:12 -06:00
|
|
|
class->devnode = drm_devnode;
|
2009-04-30 07:23:42 -06:00
|
|
|
|
2006-01-20 15:08:59 -07:00
|
|
|
return class;
|
2006-10-10 15:23:37 -06:00
|
|
|
|
|
|
|
err_out_class:
|
|
|
|
class_destroy(class);
|
|
|
|
err_out:
|
|
|
|
return ERR_PTR(err);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-21 21:02:38 -07:00
|
|
|
* drm_sysfs_destroy - destroys DRM class
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-11-21 21:02:38 -07:00
|
|
|
* Destroy the DRM device class.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-11-21 21:02:38 -07:00
|
|
|
void drm_sysfs_destroy(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-21 21:02:38 -07:00
|
|
|
if ((drm_class == NULL) || (IS_ERR(drm_class)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
2010-01-05 04:48:09 -07:00
|
|
|
class_remove_file(drm_class, &class_attr_version.attr);
|
2007-11-21 21:02:38 -07:00
|
|
|
class_destroy(drm_class);
|
2012-07-06 11:06:42 -06:00
|
|
|
drm_class = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-21 21:02:38 -07:00
|
|
|
/**
|
|
|
|
* drm_sysfs_device_release - do nothing
|
|
|
|
* @dev: Linux device
|
|
|
|
*
|
|
|
|
* Normally, this would free the DRM device associated with @dev, along
|
|
|
|
* with cleaning up any other stuff. But we do that in the DRM core, so
|
|
|
|
* this function can just return and hope that the core does its job.
|
|
|
|
*/
|
|
|
|
static void drm_sysfs_device_release(struct device *dev)
|
|
|
|
{
|
2009-04-16 03:51:25 -06:00
|
|
|
memset(dev, 0, sizeof(struct device));
|
2007-11-21 21:02:38 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-07 15:05:41 -07:00
|
|
|
/*
|
|
|
|
* Connector properties
|
|
|
|
*/
|
|
|
|
static ssize_t status_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
enum drm_connector_status status;
|
2011-03-15 05:40:00 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-11-07 15:05:41 -07:00
|
|
|
|
2010-09-09 16:51:02 -06:00
|
|
|
status = connector->funcs->detect(connector, true);
|
2011-03-15 05:40:00 -06:00
|
|
|
mutex_unlock(&connector->dev->mode_config.mutex);
|
|
|
|
|
2009-05-30 21:42:25 -06:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",
|
2008-11-07 15:05:41 -07:00
|
|
|
drm_get_connector_status_name(status));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t dpms_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
uint64_t dpms_status;
|
|
|
|
int ret;
|
|
|
|
|
2012-10-11 19:50:56 -06:00
|
|
|
ret = drm_object_property_get_value(&connector->base,
|
2008-11-07 15:05:41 -07:00
|
|
|
dev->mode_config.dpms_property,
|
|
|
|
&dpms_status);
|
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
|
2009-05-30 21:42:25 -06:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n",
|
2008-11-07 15:05:41 -07:00
|
|
|
drm_get_dpms_name((int)dpms_status));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t enabled_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
|
2009-05-30 21:42:25 -06:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
|
2008-11-07 15:05:41 -07:00
|
|
|
"disabled");
|
|
|
|
}
|
|
|
|
|
2010-05-12 19:28:57 -06:00
|
|
|
static ssize_t edid_show(struct file *filp, struct kobject *kobj,
|
|
|
|
struct bin_attribute *attr, char *buf, loff_t off,
|
|
|
|
size_t count)
|
2008-11-07 15:05:41 -07:00
|
|
|
{
|
|
|
|
struct device *connector_dev = container_of(kobj, struct device, kobj);
|
|
|
|
struct drm_connector *connector = to_drm_connector(connector_dev);
|
|
|
|
unsigned char *edid;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
if (!connector->edid_blob_ptr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
edid = connector->edid_blob_ptr->data;
|
|
|
|
size = connector->edid_blob_ptr->length;
|
|
|
|
if (!edid)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (off >= size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (off + count > size)
|
|
|
|
count = size - off;
|
|
|
|
memcpy(buf, edid + off, count);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t modes_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
struct drm_display_mode *mode;
|
|
|
|
int written = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(mode, &connector->modes, head) {
|
|
|
|
written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
|
|
|
|
mode->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return written;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t subconnector_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct drm_property *prop = NULL;
|
|
|
|
uint64_t subconnector;
|
|
|
|
int is_tv = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch (connector->connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
prop = dev->mode_config.dvi_i_subconnector_property;
|
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Component:
|
2009-08-01 20:19:18 -06:00
|
|
|
case DRM_MODE_CONNECTOR_TV:
|
2008-11-07 15:05:41 -07:00
|
|
|
prop = dev->mode_config.tv_subconnector_property;
|
|
|
|
is_tv = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
DRM_ERROR("Wrong connector type for this property\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
DRM_ERROR("Unable to find subconnector property\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-11 19:50:56 -06:00
|
|
|
ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
|
2008-11-07 15:05:41 -07:00
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
|
|
|
|
drm_get_tv_subconnector_name((int)subconnector) :
|
|
|
|
drm_get_dvi_i_subconnector_name((int)subconnector));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t select_subconnector_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct drm_connector *connector = to_drm_connector(device);
|
|
|
|
struct drm_device *dev = connector->dev;
|
|
|
|
struct drm_property *prop = NULL;
|
|
|
|
uint64_t subconnector;
|
|
|
|
int is_tv = 0;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
switch (connector->connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
prop = dev->mode_config.dvi_i_select_subconnector_property;
|
|
|
|
break;
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Component:
|
2009-08-01 20:19:18 -06:00
|
|
|
case DRM_MODE_CONNECTOR_TV:
|
2008-11-07 15:05:41 -07:00
|
|
|
prop = dev->mode_config.tv_select_subconnector_property;
|
|
|
|
is_tv = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
DRM_ERROR("Wrong connector type for this property\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
DRM_ERROR("Unable to find select subconnector property\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-11 19:50:56 -06:00
|
|
|
ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
|
2008-11-07 15:05:41 -07:00
|
|
|
if (ret)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
|
|
|
|
drm_get_tv_select_name((int)subconnector) :
|
|
|
|
drm_get_dvi_i_select_name((int)subconnector));
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct device_attribute connector_attrs[] = {
|
|
|
|
__ATTR_RO(status),
|
|
|
|
__ATTR_RO(enabled),
|
|
|
|
__ATTR_RO(dpms),
|
|
|
|
__ATTR_RO(modes),
|
|
|
|
};
|
|
|
|
|
|
|
|
/* These attributes are for both DVI-I connectors and all types of tv-out. */
|
|
|
|
static struct device_attribute connector_attrs_opt1[] = {
|
|
|
|
__ATTR_RO(subconnector),
|
|
|
|
__ATTR_RO(select_subconnector),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bin_attribute edid_attr = {
|
|
|
|
.attr.name = "edid",
|
2009-05-30 21:42:26 -06:00
|
|
|
.attr.mode = 0444,
|
2010-03-29 15:43:23 -06:00
|
|
|
.size = 0,
|
2008-11-07 15:05:41 -07:00
|
|
|
.read = edid_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2012-05-17 05:27:20 -06:00
|
|
|
* drm_sysfs_connector_add - add a connector to sysfs
|
2008-11-07 15:05:41 -07:00
|
|
|
* @connector: connector to add
|
|
|
|
*
|
2012-05-17 05:27:20 -06:00
|
|
|
* Create a connector device in sysfs, along with its associated connector
|
2008-11-07 15:05:41 -07:00
|
|
|
* properties (so far, connection status, dpms, mode list & edid) and
|
|
|
|
* generate a hotplug event so userspace knows there's a new connector
|
|
|
|
* available.
|
|
|
|
*
|
|
|
|
* Note:
|
2012-05-17 05:27:20 -06:00
|
|
|
* This routine should only be called *once* for each registered connector.
|
|
|
|
* A second call for an already registered connector will trigger the BUG_ON
|
2008-11-07 15:05:41 -07:00
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
int drm_sysfs_connector_add(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
struct drm_device *dev = connector->dev;
|
2010-04-27 15:11:05 -06:00
|
|
|
int attr_cnt = 0;
|
|
|
|
int opt_cnt = 0;
|
|
|
|
int i;
|
2012-05-17 05:27:21 -06:00
|
|
|
int ret;
|
2008-11-07 15:05:41 -07:00
|
|
|
|
|
|
|
/* We shouldn't get called more than once for the same connector */
|
|
|
|
BUG_ON(device_is_registered(&connector->kdev));
|
|
|
|
|
|
|
|
connector->kdev.parent = &dev->primary->kdev;
|
|
|
|
connector->kdev.class = drm_class;
|
|
|
|
connector->kdev.release = drm_sysfs_device_release;
|
|
|
|
|
|
|
|
DRM_DEBUG("adding \"%s\" to sysfs\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
|
2009-03-24 17:38:22 -06:00
|
|
|
dev_set_name(&connector->kdev, "card%d-%s",
|
|
|
|
dev->primary->index, drm_get_connector_name(connector));
|
2008-11-07 15:05:41 -07:00
|
|
|
ret = device_register(&connector->kdev);
|
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
DRM_ERROR("failed to register connector device: %d\n", ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Standard attributes */
|
|
|
|
|
2010-04-27 15:11:05 -06:00
|
|
|
for (attr_cnt = 0; attr_cnt < ARRAY_SIZE(connector_attrs); attr_cnt++) {
|
|
|
|
ret = device_create_file(&connector->kdev, &connector_attrs[attr_cnt]);
|
2008-11-07 15:05:41 -07:00
|
|
|
if (ret)
|
|
|
|
goto err_out_files;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Optional attributes */
|
|
|
|
/*
|
|
|
|
* In the long run it maybe a good idea to make one set of
|
|
|
|
* optionals per connector type.
|
|
|
|
*/
|
|
|
|
switch (connector->connector_type) {
|
|
|
|
case DRM_MODE_CONNECTOR_DVII:
|
|
|
|
case DRM_MODE_CONNECTOR_Composite:
|
|
|
|
case DRM_MODE_CONNECTOR_SVIDEO:
|
|
|
|
case DRM_MODE_CONNECTOR_Component:
|
2009-08-01 20:19:18 -06:00
|
|
|
case DRM_MODE_CONNECTOR_TV:
|
2010-04-27 15:11:05 -06:00
|
|
|
for (opt_cnt = 0; opt_cnt < ARRAY_SIZE(connector_attrs_opt1); opt_cnt++) {
|
|
|
|
ret = device_create_file(&connector->kdev, &connector_attrs_opt1[opt_cnt]);
|
2008-11-07 15:05:41 -07:00
|
|
|
if (ret)
|
|
|
|
goto err_out_files;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = sysfs_create_bin_file(&connector->kdev.kobj, &edid_attr);
|
|
|
|
if (ret)
|
|
|
|
goto err_out_files;
|
|
|
|
|
|
|
|
/* Let userspace know we have a new connector */
|
|
|
|
drm_sysfs_hotplug_event(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out_files:
|
2010-04-27 15:11:05 -06:00
|
|
|
for (i = 0; i < opt_cnt; i++)
|
|
|
|
device_remove_file(&connector->kdev, &connector_attrs_opt1[i]);
|
|
|
|
for (i = 0; i < attr_cnt; i++)
|
|
|
|
device_remove_file(&connector->kdev, &connector_attrs[i]);
|
2008-11-07 15:05:41 -07:00
|
|
|
device_unregister(&connector->kdev);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_sysfs_connector_add);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_sysfs_connector_remove - remove an connector device from sysfs
|
|
|
|
* @connector: connector to remove
|
|
|
|
*
|
|
|
|
* Remove @connector and its associated attributes from sysfs. Note that
|
|
|
|
* the device model core will take care of sending the "remove" uevent
|
|
|
|
* at this time, so we don't need to do it.
|
|
|
|
*
|
|
|
|
* Note:
|
|
|
|
* This routine should only be called if the connector was previously
|
|
|
|
* successfully registered. If @connector hasn't been registered yet,
|
|
|
|
* you'll likely see a panic somewhere deep in sysfs code when called.
|
|
|
|
*/
|
|
|
|
void drm_sysfs_connector_remove(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2012-02-20 07:15:02 -07:00
|
|
|
if (!connector->kdev.parent)
|
|
|
|
return;
|
2008-11-07 15:05:41 -07:00
|
|
|
DRM_DEBUG("removing \"%s\" from sysfs\n",
|
|
|
|
drm_get_connector_name(connector));
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(connector_attrs); i++)
|
|
|
|
device_remove_file(&connector->kdev, &connector_attrs[i]);
|
|
|
|
sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr);
|
|
|
|
device_unregister(&connector->kdev);
|
2012-02-20 07:15:02 -07:00
|
|
|
connector->kdev.parent = NULL;
|
2008-11-07 15:05:41 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_sysfs_connector_remove);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_sysfs_hotplug_event - generate a DRM uevent
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* Send a uevent for the DRM device specified by @dev. Currently we only
|
|
|
|
* set HOTPLUG=1 in the uevent environment, but this could be expanded to
|
|
|
|
* deal with other types of events.
|
|
|
|
*/
|
|
|
|
void drm_sysfs_hotplug_event(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
char *event_string = "HOTPLUG=1";
|
|
|
|
char *envp[] = { event_string, NULL };
|
|
|
|
|
|
|
|
DRM_DEBUG("generating hotplug event\n");
|
|
|
|
|
|
|
|
kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp);
|
|
|
|
}
|
2009-03-31 15:11:15 -06:00
|
|
|
EXPORT_SYMBOL(drm_sysfs_hotplug_event);
|
2008-11-07 15:05:41 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* drm_sysfs_device_add - adds a class device to sysfs for a character driver
|
2007-11-21 21:02:38 -07:00
|
|
|
* @dev: DRM device to be added
|
|
|
|
* @head: DRM head in question
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-11-21 21:02:38 -07:00
|
|
|
* Add a DRM device to the DRM's device model class. We use @dev's PCI device
|
|
|
|
* as the parent for the Linux device, and make sure it has a file containing
|
|
|
|
* the driver we're using (for userspace compatibility).
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2008-04-21 00:47:32 -06:00
|
|
|
int drm_sysfs_device_add(struct drm_minor *minor)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-11-21 21:02:38 -07:00
|
|
|
int err;
|
2008-04-21 00:47:32 -06:00
|
|
|
char *minor_str;
|
2007-11-21 21:02:38 -07:00
|
|
|
|
2010-05-27 13:40:25 -06:00
|
|
|
minor->kdev.parent = minor->dev->dev;
|
|
|
|
|
2008-04-21 00:47:32 -06:00
|
|
|
minor->kdev.class = drm_class;
|
|
|
|
minor->kdev.release = drm_sysfs_device_release;
|
|
|
|
minor->kdev.devt = minor->device;
|
2009-08-20 03:02:31 -06:00
|
|
|
minor->kdev.type = &drm_sysfs_device_minor;
|
2008-11-07 15:05:41 -07:00
|
|
|
if (minor->type == DRM_MINOR_CONTROL)
|
|
|
|
minor_str = "controlD%d";
|
|
|
|
else if (minor->type == DRM_MINOR_RENDER)
|
|
|
|
minor_str = "renderD%d";
|
|
|
|
else
|
|
|
|
minor_str = "card%d";
|
2007-11-21 21:02:38 -07:00
|
|
|
|
2009-01-06 11:44:41 -07:00
|
|
|
dev_set_name(&minor->kdev, minor_str, minor->index);
|
2008-04-21 00:47:32 -06:00
|
|
|
|
|
|
|
err = device_register(&minor->kdev);
|
2007-11-21 21:02:38 -07:00
|
|
|
if (err) {
|
|
|
|
DRM_ERROR("device add failed: %d\n", err);
|
2006-10-10 15:23:37 -06:00
|
|
|
goto err_out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-21 21:02:38 -07:00
|
|
|
return 0;
|
2006-10-10 15:23:37 -06:00
|
|
|
|
|
|
|
err_out:
|
2007-11-21 21:02:38 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-21 21:02:38 -07:00
|
|
|
* drm_sysfs_device_remove - remove DRM device
|
|
|
|
* @dev: DRM device to remove
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This call unregisters and cleans up a class device that was created with a
|
|
|
|
* call to drm_sysfs_device_add()
|
|
|
|
*/
|
2008-04-21 00:47:32 -06:00
|
|
|
void drm_sysfs_device_remove(struct drm_minor *minor)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-02-20 07:15:02 -07:00
|
|
|
if (minor->kdev.parent)
|
|
|
|
device_unregister(&minor->kdev);
|
|
|
|
minor->kdev.parent = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-08-17 08:28:37 -06:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_class_device_register - Register a struct device in the drm class.
|
|
|
|
*
|
|
|
|
* @dev: pointer to struct device to register.
|
|
|
|
*
|
|
|
|
* @dev should have all relevant members pre-filled with the exception
|
|
|
|
* of the class member. In particular, the device_type member must
|
|
|
|
* be set.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int drm_class_device_register(struct device *dev)
|
|
|
|
{
|
2012-07-06 11:06:42 -06:00
|
|
|
if (!drm_class || IS_ERR(drm_class))
|
|
|
|
return -ENOENT;
|
|
|
|
|
2009-08-17 08:28:37 -06:00
|
|
|
dev->class = drm_class;
|
|
|
|
return device_register(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_class_device_register);
|
|
|
|
|
|
|
|
void drm_class_device_unregister(struct device *dev)
|
|
|
|
{
|
|
|
|
return device_unregister(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_class_device_unregister);
|