[deliverable/linux.git] / drivers / gpu / drm / drm_sysfs.c


/*
 * 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 <linux/gfp.h>
#include <linux/err.h>
#include <linux/export.h>

#include <drm/drm_sysfs.h>
#include <drm/drm_core.h>
#include <drm/drmP.h>

#define to_drm_minor(d) dev_get_drvdata(d)
#define to_drm_connector(d) dev_get_drvdata(d)

static struct device_type drm_sysfs_device_minor = {
	.name = "drm_minor"
};

/**
 * __drm_class_suspend - internal DRM class suspend routine
 * @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.
 */
static int __drm_class_suspend(struct device *dev, pm_message_t state)
{
	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);
	}
	return 0;
}

/**
 * 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);
}

/**
 * drm_class_resume - DRM class resume hook
 * @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.
 */
static int drm_class_resume(struct device *dev)
{
	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);
	}
	return 0;
}

static const struct dev_pm_ops drm_class_dev_pm_ops = {
	.suspend	= drm_class_suspend,
	.resume		= drm_class_resume,
	.freeze		= drm_class_freeze,
};

static char *drm_devnode(struct device *dev, umode_t *mode)
{
	return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
}

static CLASS_ATTR_STRING(version, S_IRUGO,
		CORE_NAME " "
		__stringify(CORE_MAJOR) "."
		__stringify(CORE_MINOR) "."
		__stringify(CORE_PATCHLEVEL) " "
		CORE_DATE);

/**
 * 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.
 *
 * This is used to create DRM class pointer that can then be used
 * 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().
 */
struct class *drm_sysfs_create(struct module *owner, char *name)
{
	struct class *class;
	int err;

	class = class_create(owner, name);
	if (IS_ERR(class)) {
		err = PTR_ERR(class);
		goto err_out;
	}

	class->pm = &drm_class_dev_pm_ops;

	err = class_create_file(class, &class_attr_version.attr);
	if (err)
		goto err_out_class;

	class->devnode = drm_devnode;

	return class;

err_out_class:
	class_destroy(class);
err_out:
	return ERR_PTR(err);
}

/**
 * drm_sysfs_destroy - destroys DRM class
 *
 * Destroy the DRM device class.
 */
void drm_sysfs_destroy(void)
{
	if ((drm_class == NULL) || (IS_ERR(drm_class)))
		return;
	class_remove_file(drm_class, &class_attr_version.attr);
	class_destroy(drm_class);
	drm_class = NULL;
}

/*
 * 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;
	int ret;

	ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex);
	if (ret)
		return ret;

	status = connector->funcs->detect(connector, true);
	mutex_unlock(&connector->dev->mode_config.mutex);

	return snprintf(buf, PAGE_SIZE, "%s\n",
			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;

	ret = drm_object_property_get_value(&connector->base,
					    dev->mode_config.dpms_property,
					    &dpms_status);
	if (ret)
		return 0;

	return snprintf(buf, PAGE_SIZE, "%s\n",
			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);

	return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
			"disabled");
}

static ssize_t edid_show(struct file *filp, struct kobject *kobj,
			 struct bin_attribute *attr, char *buf, loff_t off,
			 size_t count)
{
	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:
		case DRM_MODE_CONNECTOR_TV:
			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;
	}

	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
	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:
		case DRM_MODE_CONNECTOR_TV:
			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;
	}

	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
	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",
	.attr.mode = 0444,
	.size = 0,
	.read = edid_show,
};

/**
 * drm_sysfs_connector_add - add a connector to sysfs
 * @connector: connector to add
 *
 * Create a connector device in sysfs, along with its associated connector
 * properties (so far, connection status, dpms, mode list & edid) and
 * generate a hotplug event so userspace knows there's a new connector
 * available.
 */
int drm_sysfs_connector_add(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	int attr_cnt = 0;
	int opt_cnt = 0;
	int i;
	int ret;

	if (connector->kdev)
		return 0;

	connector->kdev = device_create(drm_class, dev->primary->kdev,
					0, connector, "card%d-%s",
					dev->primary->index, connector->name);
	DRM_DEBUG("adding \"%s\" to sysfs\n",
		  connector->name);

	if (IS_ERR(connector->kdev)) {
		DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
		ret = PTR_ERR(connector->kdev);
		goto out;
	}

	/* Standard attributes */

	for (attr_cnt = 0; attr_cnt < ARRAY_SIZE(connector_attrs); attr_cnt++) {
		ret = device_create_file(connector->kdev, &connector_attrs[attr_cnt]);
		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:
		case DRM_MODE_CONNECTOR_TV:
			for (opt_cnt = 0; opt_cnt < ARRAY_SIZE(connector_attrs_opt1); opt_cnt++) {
				ret = device_create_file(connector->kdev, &connector_attrs_opt1[opt_cnt]);
				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:
	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]);
	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;

	if (!connector->kdev)
		return;
	DRM_DEBUG("removing \"%s\" from sysfs\n",
		  connector->name);

	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);
	connector->kdev = NULL;
}
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);
}
EXPORT_SYMBOL(drm_sysfs_hotplug_event);

static void drm_sysfs_release(struct device *dev)
{
	kfree(dev);
}

/**
 * drm_sysfs_device_add - adds a class device to sysfs for a character driver
 * @dev: DRM device to be added
 * @head: DRM head in question
 *
 * 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).
 */
int drm_sysfs_device_add(struct drm_minor *minor)
{
	char *minor_str;
	int r;

	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";

	minor->kdev = kzalloc(sizeof(*minor->kdev), GFP_KERNEL);
	if (!minor->kdev) {
		r = -ENOMEM;
		goto error;
	}

	device_initialize(minor->kdev);
	minor->kdev->devt = MKDEV(DRM_MAJOR, minor->index);
	minor->kdev->class = drm_class;
	minor->kdev->type = &drm_sysfs_device_minor;
	minor->kdev->parent = minor->dev->dev;
	minor->kdev->release = drm_sysfs_release;
	dev_set_drvdata(minor->kdev, minor);

	r = dev_set_name(minor->kdev, minor_str, minor->index);
	if (r < 0)
		goto error;

	r = device_add(minor->kdev);
	if (r < 0)
		goto error;

	return 0;

error:
	DRM_ERROR("device create failed %d\n", r);
	put_device(minor->kdev);
	return r;
}

/**
 * drm_sysfs_device_remove - remove DRM device
 * @dev: DRM device to remove
 *
 * This call unregisters and cleans up a class device that was created with a
 * call to drm_sysfs_device_add()
 */
void drm_sysfs_device_remove(struct drm_minor *minor)
{
	if (minor->kdev)
		device_unregister(minor->kdev);
	minor->kdev = NULL;
}


/**
 * 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)
{
	if (!drm_class || IS_ERR(drm_class))
		return -ENOENT;

	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);
Commit	Line	Data
0650fd58	1
1da177e4 LT	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
1da177e4 LT	15	#include <linux/device.h>
1da177e4 LT	16	#include <linux/kdev_t.h>
5a0e3ad6	17	#include <linux/gfp.h>
1da177e4	18	#include <linux/err.h>
2d1a8a48	19	#include <linux/export.h>
1da177e4	20
760285e7 DH	21	#include <drm/drm_sysfs.h>
	22	#include <drm/drm_core.h>
	23	#include <drm/drmP.h>
1da177e4	24
5bdebb18 DA	25	#define to_drm_minor(d) dev_get_drvdata(d)
5bdebb18 DA	26	#define to_drm_connector(d) dev_get_drvdata(d)
e8b962b6	27
08e4d534 TH	28	static struct device_type drm_sysfs_device_minor = {
	29	.name = "drm_minor"
	30	};
	31
e8b962b6	32	/**
cf4b91f2	33	* __drm_class_suspend - internal DRM class suspend routine
e8b962b6 JB	34	* @dev: Linux device to suspend
	35	* @state: power state to enter
	36	*
	37	* Just figures out what the actual struct drm_device associated with
	38	* @dev is and calls its suspend hook, if present.
	39	*/
cf4b91f2	40	static int __drm_class_suspend(struct device *dev, pm_message_t state)
e8b962b6	41	{
08e4d534 TH	42	if (dev->type == &drm_sysfs_device_minor) {
	43	struct drm_minor *drm_minor = to_drm_minor(dev);
	44	struct drm_device *drm_dev = drm_minor->dev;
	45
	46	if (drm_minor->type == DRM_MINOR_LEGACY &&
	47	!drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
	48	drm_dev->driver->suspend)
	49	return drm_dev->driver->suspend(drm_dev, state);
	50	}
e8b962b6 JB	51	return 0;
	52	}
	53
cf4b91f2 SK	54	/**
	55	* drm_class_suspend - internal DRM class suspend hook. Simply calls
	56	* __drm_class_suspend() with the correct pm state.
	57	* @dev: Linux device to suspend
	58	*/
	59	static int drm_class_suspend(struct device *dev)
	60	{
	61	return __drm_class_suspend(dev, PMSG_SUSPEND);
	62	}
	63
	64	/**
	65	* drm_class_freeze - internal DRM class freeze hook. Simply calls
	66	* __drm_class_suspend() with the correct pm state.
	67	* @dev: Linux device to freeze
	68	*/
	69	static int drm_class_freeze(struct device *dev)
	70	{
	71	return __drm_class_suspend(dev, PMSG_FREEZE);
	72	}
	73
e8b962b6	74	/**
08e4d534	75	* drm_class_resume - DRM class resume hook
e8b962b6 JB	76	* @dev: Linux device to resume
	77	*
	78	* Just figures out what the actual struct drm_device associated with
	79	* @dev is and calls its resume hook, if present.
	80	*/
08e4d534	81	static int drm_class_resume(struct device *dev)
e8b962b6	82	{
08e4d534 TH	83	if (dev->type == &drm_sysfs_device_minor) {
	84	struct drm_minor *drm_minor = to_drm_minor(dev);
	85	struct drm_device *drm_dev = drm_minor->dev;
	86
	87	if (drm_minor->type == DRM_MINOR_LEGACY &&
	88	!drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
	89	drm_dev->driver->resume)
	90	return drm_dev->driver->resume(drm_dev);
	91	}
e8b962b6 JB	92	return 0;
	93	}
	94
cf4b91f2 SK	95	static const struct dev_pm_ops drm_class_dev_pm_ops = {
	96	.suspend = drm_class_suspend,
	97	.resume = drm_class_resume,
	98	.freeze = drm_class_freeze,
	99	};
	100
2c9ede55	101	static char drm_devnode(struct device dev, umode_t *mode)
02200d06 KS	102	{
	103	return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
	104	}
	105
0933e2d9 AK	106	static CLASS_ATTR_STRING(version, S_IRUGO,
	107	CORE_NAME " "
	108	__stringify(CORE_MAJOR) "."
	109	__stringify(CORE_MINOR) "."
	110	__stringify(CORE_PATCHLEVEL) " "
	111	CORE_DATE);
1da177e4 LT	112
	113	/**
	114	* drm_sysfs_create - create a struct drm_sysfs_class structure
	115	* @owner: pointer to the module that is to "own" this struct drm_sysfs_class
	116	* @name: pointer to a string for the name of this class.
	117	*
e8b962b6	118	* This is used to create DRM class pointer that can then be used
1da177e4 LT	119	* in calls to drm_sysfs_device_add().
	120	*
	121	* Note, the pointer created here is to be destroyed when finished by making a
	122	* call to drm_sysfs_destroy().
	123	*/
0650fd58	124	struct class drm_sysfs_create(struct module owner, char *name)
1da177e4	125	{
0650fd58	126	struct class *class;
24f73c92	127	int err;
0650fd58 GKH	128
0650fd58 GKH	129	class = class_create(owner, name);
94f060bd AM	130	if (IS_ERR(class)) {
94f060bd AM	131	err = PTR_ERR(class);
24f73c92 JG	132	goto err_out;
	133	}
	134
cf4b91f2	135	class->pm = &drm_class_dev_pm_ops;
e8b962b6	136
0933e2d9	137	err = class_create_file(class, &class_attr_version.attr);
24f73c92 JG	138	if (err)
24f73c92 JG	139	goto err_out_class;
0650fd58	140
e454cea2	141	class->devnode = drm_devnode;
02200d06	142
0650fd58	143	return class;
24f73c92 JG	144
	145	err_out_class:
	146	class_destroy(class);
	147	err_out:
	148	return ERR_PTR(err);
1da177e4 LT	149	}
	150
	151	/**
e8b962b6	152	* drm_sysfs_destroy - destroys DRM class
1da177e4	153	*
e8b962b6	154	* Destroy the DRM device class.
1da177e4	155	*/
e8b962b6	156	void drm_sysfs_destroy(void)
1da177e4	157	{
e8b962b6	158	if ((drm_class == NULL) \|\| (IS_ERR(drm_class)))
1da177e4	159	return;
0933e2d9	160	class_remove_file(drm_class, &class_attr_version.attr);
e8b962b6	161	class_destroy(drm_class);
49099c49	162	drm_class = NULL;
1da177e4 LT	163	}
1da177e4 LT	164
f453ba04 DA	165	/*
	166	* Connector properties
	167	*/
	168	static ssize_t status_show(struct device *device,
	169	struct device_attribute *attr,
	170	char *buf)
	171	{
	172	struct drm_connector *connector = to_drm_connector(device);
	173	enum drm_connector_status status;
007c80a5 CW	174	int ret;
	175
	176	ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex);
	177	if (ret)
	178	return ret;
f453ba04	179
7b334fcb	180	status = connector->funcs->detect(connector, true);
007c80a5 CW	181	mutex_unlock(&connector->dev->mode_config.mutex);
007c80a5 CW	182
75185c92	183	return snprintf(buf, PAGE_SIZE, "%s\n",
f453ba04 DA	184	drm_get_connector_status_name(status));
	185	}
	186
	187	static ssize_t dpms_show(struct device *device,
	188	struct device_attribute *attr,
	189	char *buf)
	190	{
	191	struct drm_connector *connector = to_drm_connector(device);
	192	struct drm_device *dev = connector->dev;
	193	uint64_t dpms_status;
	194	int ret;
	195
58495563	196	ret = drm_object_property_get_value(&connector->base,
f453ba04 DA	197	dev->mode_config.dpms_property,
	198	&dpms_status);
	199	if (ret)
	200	return 0;
	201
75185c92	202	return snprintf(buf, PAGE_SIZE, "%s\n",
f453ba04 DA	203	drm_get_dpms_name((int)dpms_status));
	204	}
	205
	206	static ssize_t enabled_show(struct device *device,
	207	struct device_attribute *attr,
	208	char *buf)
	209	{
	210	struct drm_connector *connector = to_drm_connector(device);
	211
75185c92	212	return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
f453ba04 DA	213	"disabled");
	214	}
	215
2c3c8bea CW	216	static ssize_t edid_show(struct file filp, struct kobject kobj,
	217	struct bin_attribute attr, char buf, loff_t off,
	218	size_t count)
f453ba04 DA	219	{
	220	struct device *connector_dev = container_of(kobj, struct device, kobj);
	221	struct drm_connector *connector = to_drm_connector(connector_dev);
	222	unsigned char *edid;
	223	size_t size;
	224
	225	if (!connector->edid_blob_ptr)
	226	return 0;
	227
	228	edid = connector->edid_blob_ptr->data;
	229	size = connector->edid_blob_ptr->length;
	230	if (!edid)
	231	return 0;
	232
	233	if (off >= size)
	234	return 0;
	235
	236	if (off + count > size)
	237	count = size - off;
	238	memcpy(buf, edid + off, count);
	239
	240	return count;
	241	}
	242
	243	static ssize_t modes_show(struct device *device,
	244	struct device_attribute *attr,
	245	char *buf)
	246	{
	247	struct drm_connector *connector = to_drm_connector(device);
	248	struct drm_display_mode *mode;
	249	int written = 0;
	250
	251	list_for_each_entry(mode, &connector->modes, head) {
	252	written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
	253	mode->name);
	254	}
	255
	256	return written;
	257	}
	258
	259	static ssize_t subconnector_show(struct device *device,
	260	struct device_attribute *attr,
	261	char *buf)
	262	{
	263	struct drm_connector *connector = to_drm_connector(device);
	264	struct drm_device *dev = connector->dev;
	265	struct drm_property *prop = NULL;
	266	uint64_t subconnector;
	267	int is_tv = 0;
	268	int ret;
	269
	270	switch (connector->connector_type) {
	271	case DRM_MODE_CONNECTOR_DVII:
	272	prop = dev->mode_config.dvi_i_subconnector_property;
	273	break;
	274	case DRM_MODE_CONNECTOR_Composite:
	275	case DRM_MODE_CONNECTOR_SVIDEO:
	276	case DRM_MODE_CONNECTOR_Component:
74bd3c26	277	case DRM_MODE_CONNECTOR_TV:
f453ba04 DA	278	prop = dev->mode_config.tv_subconnector_property;
	279	is_tv = 1;
	280	break;
	281	default:
	282	DRM_ERROR("Wrong connector type for this property\n");
	283	return 0;
	284	}
	285
	286	if (!prop) {
	287	DRM_ERROR("Unable to find subconnector property\n");
	288	return 0;
	289	}
	290
58495563	291	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
f453ba04 DA	292	if (ret)
	293	return 0;
	294
	295	return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
	296	drm_get_tv_subconnector_name((int)subconnector) :
	297	drm_get_dvi_i_subconnector_name((int)subconnector));
	298	}
	299
	300	static ssize_t select_subconnector_show(struct device *device,
	301	struct device_attribute *attr,
	302	char *buf)
	303	{
	304	struct drm_connector *connector = to_drm_connector(device);
	305	struct drm_device *dev = connector->dev;
	306	struct drm_property *prop = NULL;
	307	uint64_t subconnector;
	308	int is_tv = 0;
	309	int ret;
	310
	311	switch (connector->connector_type) {
	312	case DRM_MODE_CONNECTOR_DVII:
	313	prop = dev->mode_config.dvi_i_select_subconnector_property;
	314	break;
	315	case DRM_MODE_CONNECTOR_Composite:
	316	case DRM_MODE_CONNECTOR_SVIDEO:
	317	case DRM_MODE_CONNECTOR_Component:
74bd3c26	318	case DRM_MODE_CONNECTOR_TV:
f453ba04 DA	319	prop = dev->mode_config.tv_select_subconnector_property;
	320	is_tv = 1;
	321	break;
	322	default:
	323	DRM_ERROR("Wrong connector type for this property\n");
	324	return 0;
	325	}
	326
	327	if (!prop) {
	328	DRM_ERROR("Unable to find select subconnector property\n");
	329	return 0;
	330	}
	331
58495563	332	ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
f453ba04 DA	333	if (ret)
	334	return 0;
	335
	336	return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
	337	drm_get_tv_select_name((int)subconnector) :
	338	drm_get_dvi_i_select_name((int)subconnector));
	339	}
	340
	341	static struct device_attribute connector_attrs[] = {
	342	__ATTR_RO(status),
	343	__ATTR_RO(enabled),
	344	__ATTR_RO(dpms),
	345	__ATTR_RO(modes),
	346	};
	347
	348	/* These attributes are for both DVI-I connectors and all types of tv-out. */
	349	static struct device_attribute connector_attrs_opt1[] = {
	350	__ATTR_RO(subconnector),
	351	__ATTR_RO(select_subconnector),
	352	};
	353
	354	static struct bin_attribute edid_attr = {
	355	.attr.name = "edid",
e36ebaf4	356	.attr.mode = 0444,
7466f4cc	357	.size = 0,
f453ba04 DA	358	.read = edid_show,
	359	};
	360
	361	/**
3b02ab88	362	* drm_sysfs_connector_add - add a connector to sysfs
f453ba04 DA	363	* @connector: connector to add
f453ba04 DA	364	*
3b02ab88	365	* Create a connector device in sysfs, along with its associated connector
f453ba04 DA	366	* properties (so far, connection status, dpms, mode list & edid) and
	367	* generate a hotplug event so userspace knows there's a new connector
	368	* available.
f453ba04 DA	369	*/
	370	int drm_sysfs_connector_add(struct drm_connector *connector)
	371	{
	372	struct drm_device *dev = connector->dev;
a1c4560d DC	373	int attr_cnt = 0;
	374	int opt_cnt = 0;
	375	int i;
4a1b0714	376	int ret;
f453ba04	377
5bdebb18 DA	378	if (connector->kdev)
5bdebb18 DA	379	return 0;
f453ba04	380
5bdebb18 DA	381	connector->kdev = device_create(drm_class, dev->primary->kdev,
5bdebb18 DA	382	0, connector, "card%d-%s",
25933820	383	dev->primary->index, connector->name);
f453ba04	384	DRM_DEBUG("adding \"%s\" to sysfs\n",
25933820	385	connector->name);
f453ba04	386
5bdebb18 DA	387	if (IS_ERR(connector->kdev)) {
	388	DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
	389	ret = PTR_ERR(connector->kdev);
f453ba04 DA	390	goto out;
	391	}
	392
	393	/* Standard attributes */
	394
a1c4560d	395	for (attr_cnt = 0; attr_cnt < ARRAY_SIZE(connector_attrs); attr_cnt++) {
5bdebb18	396	ret = device_create_file(connector->kdev, &connector_attrs[attr_cnt]);
f453ba04 DA	397	if (ret)
	398	goto err_out_files;
	399	}
	400
	401	/* Optional attributes */
	402	/*
	403	* In the long run it maybe a good idea to make one set of
	404	* optionals per connector type.
	405	*/
	406	switch (connector->connector_type) {
	407	case DRM_MODE_CONNECTOR_DVII:
	408	case DRM_MODE_CONNECTOR_Composite:
	409	case DRM_MODE_CONNECTOR_SVIDEO:
	410	case DRM_MODE_CONNECTOR_Component:
74bd3c26	411	case DRM_MODE_CONNECTOR_TV:
a1c4560d	412	for (opt_cnt = 0; opt_cnt < ARRAY_SIZE(connector_attrs_opt1); opt_cnt++) {
5bdebb18	413	ret = device_create_file(connector->kdev, &connector_attrs_opt1[opt_cnt]);
f453ba04 DA	414	if (ret)
	415	goto err_out_files;
	416	}
	417	break;
	418	default:
	419	break;
	420	}
	421
5bdebb18	422	ret = sysfs_create_bin_file(&connector->kdev->kobj, &edid_attr);
f453ba04 DA	423	if (ret)
	424	goto err_out_files;
	425
	426	/* Let userspace know we have a new connector */
	427	drm_sysfs_hotplug_event(dev);
	428
	429	return 0;
	430
	431	err_out_files:
a1c4560d	432	for (i = 0; i < opt_cnt; i++)
5bdebb18	433	device_remove_file(connector->kdev, &connector_attrs_opt1[i]);
a1c4560d	434	for (i = 0; i < attr_cnt; i++)
5bdebb18	435	device_remove_file(connector->kdev, &connector_attrs[i]);
5bdebb18	436	device_unregister(connector->kdev);
f453ba04 DA	437
	438	out:
	439	return ret;
	440	}
	441	EXPORT_SYMBOL(drm_sysfs_connector_add);
	442
	443	/**
	444	* drm_sysfs_connector_remove - remove an connector device from sysfs
	445	* @connector: connector to remove
	446	*
	447	* Remove @connector and its associated attributes from sysfs. Note that
	448	* the device model core will take care of sending the "remove" uevent
	449	* at this time, so we don't need to do it.
	450	*
	451	* Note:
	452	* This routine should only be called if the connector was previously
	453	* successfully registered. If @connector hasn't been registered yet,
	454	* you'll likely see a panic somewhere deep in sysfs code when called.
	455	*/
	456	void drm_sysfs_connector_remove(struct drm_connector *connector)
	457	{
	458	int i;
	459
5bdebb18	460	if (!connector->kdev)
1828fe6c	461	return;
f453ba04	462	DRM_DEBUG("removing \"%s\" from sysfs\n",
25933820	463	connector->name);
f453ba04 DA	464
f453ba04 DA	465	for (i = 0; i < ARRAY_SIZE(connector_attrs); i++)
5bdebb18 DA	466	device_remove_file(connector->kdev, &connector_attrs[i]);
5bdebb18 DA	467	sysfs_remove_bin_file(&connector->kdev->kobj, &edid_attr);
5bdebb18 DA	468	device_unregister(connector->kdev);
5bdebb18 DA	469	connector->kdev = NULL;
f453ba04 DA	470	}
	471	EXPORT_SYMBOL(drm_sysfs_connector_remove);
	472
	473	/**
	474	* drm_sysfs_hotplug_event - generate a DRM uevent
	475	* @dev: DRM device
	476	*
	477	* Send a uevent for the DRM device specified by @dev. Currently we only
	478	* set HOTPLUG=1 in the uevent environment, but this could be expanded to
	479	* deal with other types of events.
	480	*/
	481	void drm_sysfs_hotplug_event(struct drm_device *dev)
	482	{
	483	char *event_string = "HOTPLUG=1";
	484	char *envp[] = { event_string, NULL };
	485
	486	DRM_DEBUG("generating hotplug event\n");
	487
5bdebb18	488	kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
f453ba04	489	}
5ca58282	490	EXPORT_SYMBOL(drm_sysfs_hotplug_event);
f453ba04	491
760c960b DH	492	static void drm_sysfs_release(struct device *dev)
	493	{
	494	kfree(dev);
	495	}
	496
1da177e4 LT	497	/**
1da177e4 LT	498	* drm_sysfs_device_add - adds a class device to sysfs for a character driver
e8b962b6 JB	499	* @dev: DRM device to be added
e8b962b6 JB	500	* @head: DRM head in question
1da177e4	501	*
e8b962b6 JB	502	* Add a DRM device to the DRM's device model class. We use @dev's PCI device
	503	* as the parent for the Linux device, and make sure it has a file containing
	504	* the driver we're using (for userspace compatibility).
1da177e4	505	*/
2c14f28b	506	int drm_sysfs_device_add(struct drm_minor *minor)
1da177e4	507	{
2c14f28b	508	char *minor_str;
760c960b	509	int r;
e8b962b6	510
f453ba04 DA	511	if (minor->type == DRM_MINOR_CONTROL)
	512	minor_str = "controlD%d";
	513	else if (minor->type == DRM_MINOR_RENDER)
	514	minor_str = "renderD%d";
	515	else
	516	minor_str = "card%d";
e8b962b6	517
760c960b	518	minor->kdev = kzalloc(sizeof(*minor->kdev), GFP_KERNEL);
a1f84f57	519	if (!minor->kdev) {
760c960b DH	520	r = -ENOMEM;
760c960b DH	521	goto error;
24f73c92	522	}
760c960b DH	523
	524	device_initialize(minor->kdev);
	525	minor->kdev->devt = MKDEV(DRM_MAJOR, minor->index);
	526	minor->kdev->class = drm_class;
	527	minor->kdev->type = &drm_sysfs_device_minor;
	528	minor->kdev->parent = minor->dev->dev;
	529	minor->kdev->release = drm_sysfs_release;
	530	dev_set_drvdata(minor->kdev, minor);
	531
	532	r = dev_set_name(minor->kdev, minor_str, minor->index);
	533	if (r < 0)
	534	goto error;
	535
	536	r = device_add(minor->kdev);
	537	if (r < 0)
	538	goto error;
	539
e8b962b6	540	return 0;
760c960b DH	541
	542	error:
	543	DRM_ERROR("device create failed %d\n", r);
	544	put_device(minor->kdev);
	545	return r;
1da177e4 LT	546	}
	547
	548	/**
e8b962b6 JB	549	* drm_sysfs_device_remove - remove DRM device
e8b962b6 JB	550	* @dev: DRM device to remove
1da177e4 LT	551	*
	552	* This call unregisters and cleans up a class device that was created with a
	553	* call to drm_sysfs_device_add()
	554	*/
2c14f28b	555	void drm_sysfs_device_remove(struct drm_minor *minor)
1da177e4	556	{
5bdebb18	557	if (minor->kdev)
760c960b	558	device_unregister(minor->kdev);
5bdebb18	559	minor->kdev = NULL;
1da177e4	560	}
327c225b TH	561
	562
	563	/**
	564	* drm_class_device_register - Register a struct device in the drm class.
	565	*
	566	* @dev: pointer to struct device to register.
	567	*
	568	* @dev should have all relevant members pre-filled with the exception
	569	* of the class member. In particular, the device_type member must
	570	* be set.
	571	*/
	572
	573	int drm_class_device_register(struct device *dev)
	574	{
49099c49 DA	575	if (!drm_class \|\| IS_ERR(drm_class))
	576	return -ENOENT;
	577
327c225b TH	578	dev->class = drm_class;
	579	return device_register(dev);
	580	}
	581	EXPORT_SYMBOL_GPL(drm_class_device_register);
	582
	583	void drm_class_device_unregister(struct device *dev)
	584	{
	585	return device_unregister(dev);
	586	}
	587	EXPORT_SYMBOL_GPL(drm_class_device_unregister);