DRM: add mode setting support

Add mode setting support to the DRM layer.

This is a fairly big chunk of work that allows DRM drivers to provide
full output control and configuration capabilities to userspace.  It was
motivated by several factors:
  - the fb layer's APIs aren't suited for anything but simple
    configurations
  - coordination between the fb layer, DRM layer, and various userspace
    drivers is poor to non-existent (radeonfb excepted)
  - user level mode setting drivers makes displaying panic & oops
    messages more difficult
  - suspend/resume of graphics state is possible in many more
    configurations with kernel level support

This commit just adds the core DRM part of the mode setting APIs.
Driver specific commits using these new structure and APIs will follow.

Co-authors: Jesse Barnes <jbarnes@virtuousgeek.org>, Jakob Bornecrantz <jakob@tungstengraphics.com>
Contributors: Alan Hourihane <alanh@tungstengraphics.com>, Maarten Maathuis <madman2003@gmail.com>

Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>

1 files changed, 326 insertions, 3 deletions

diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 1611b9bcbe7f..65d72d094c81 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -20,6 +20,7 @@
 #include "drmP.h"
 
 #define to_drm_minor(d) container_of(d, struct drm_minor, kdev)
+#define to_drm_connector(d) container_of(d, struct drm_connector, kdev)
 
 /**
  * drm_sysfs_suspend - DRM class suspend hook
@@ -34,7 +35,7 @@ static int drm_sysfs_suspend(struct device *dev, pm_message_t state)
         struct drm_minor *drm_minor = to_drm_minor(dev);
         struct drm_device *drm_dev = drm_minor->dev;
 
-        if (drm_dev->driver->suspend)
+        if (drm_minor->type == DRM_MINOR_LEGACY && drm_dev->driver->suspend)
                 return drm_dev->driver->suspend(drm_dev, state);
 
         return 0;
@@ -52,7 +53,7 @@ static int drm_sysfs_resume(struct device *dev)
         struct drm_minor *drm_minor = to_drm_minor(dev);
         struct drm_device *drm_dev = drm_minor->dev;
 
-        if (drm_dev->driver->resume)
+        if (drm_minor->type == DRM_MINOR_LEGACY && drm_dev->driver->resume)
                 return drm_dev->driver->resume(drm_dev);
 
         return 0;
@@ -144,6 +145,323 @@ static void drm_sysfs_device_release(struct device *dev)
         return;
 }
 
+/*
+ * 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;
+
+        status = connector->funcs->detect(connector);
+        return snprintf(buf, PAGE_SIZE, "%s",
+                        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_connector_property_get_value(connector,
+                                            dev->mode_config.dpms_property,
+                                            &dpms_status);
+        if (ret)
+                return 0;
+
+        return snprintf(buf, PAGE_SIZE, "%s",
+                        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, connector->encoder ? "enabled" :
+                        "disabled");
+}
+
+static ssize_t edid_show(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:
+                        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_connector_property_get_value(connector, 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:
+                        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_connector_property_get_value(connector, 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",
+        .size = 128,
+        .read = edid_show,
+};
+
+/**
+ * drm_sysfs_connector_add - add an connector to sysfs
+ * @connector: connector to add
+ *
+ * Create an 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.
+ *
+ * Note:
+ * This routine should only be called *once* for each DRM minor registered.
+ * A second call for an already registered device will trigger the BUG_ON
+ * below.
+ */
+int drm_sysfs_connector_add(struct drm_connector *connector)
+{
+        struct drm_device *dev = connector->dev;
+        int ret = 0, i, j;
+
+        /* 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));
+
+        snprintf(connector->kdev.bus_id, BUS_ID_SIZE, "card%d-%s",
+                 dev->primary->index, drm_get_connector_name(connector));
+        ret = device_register(&connector->kdev);
+
+        if (ret) {
+                DRM_ERROR("failed to register connector device: %d\n", ret);
+                goto out;
+        }
+
+        /* Standard attributes */
+
+        for (i = 0; i < ARRAY_SIZE(connector_attrs); i++) {
+                ret = device_create_file(&connector->kdev, &connector_attrs[i]);
+                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:
+                        for (i = 0; i < ARRAY_SIZE(connector_attrs_opt1); i++) {
+                                ret = device_create_file(&connector->kdev, &connector_attrs_opt1[i]);
+                                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:
+        if (i > 0)
+                for (j = 0; j < i; j++)
+                        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;
+
+        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);
+}
+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);
+}
+
 /**
  * drm_sysfs_device_add - adds a class device to sysfs for a character driver
  * @dev: DRM device to be added
@@ -163,7 +481,12 @@ int drm_sysfs_device_add(struct drm_minor *minor)
         minor->kdev.class = drm_class;
         minor->kdev.release = drm_sysfs_device_release;
         minor->kdev.devt = minor->device;
-        minor_str = "card%d";
+        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";
 
         snprintf(minor->kdev.bus_id, BUS_ID_SIZE, minor_str, minor->index);