git.oblomov.eu Git - linux-2.6/blob - drivers/gpu/drm/drm_sysfs.c

   1
   2 /*
   3  * drm_sysfs.c - Modifications to drm_sysfs_class.c to support
   4  *               extra sysfs attribute from DRM. Normal drm_sysfs_class
   5  *               does not allow adding attributes.
   6  *
   7  * Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com>
   8  * Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com>
   9  * Copyright (c) 2003-2004 IBM Corp.
  10  *
  11  * This file is released under the GPLv2
  12  *
  13  */
  14
  15 #include <linux/device.h>
  16 #include <linux/kdev_t.h>
  17 #include <linux/err.h>
  18
  19 #include "drm_core.h"
  20 #include "drmP.h"
  21
  22 #define to_drm_minor(d) container_of(d, struct drm_minor, kdev)
  23 #define to_drm_connector(d) container_of(d, struct drm_connector, kdev)
  24
  25 /**
  26  * drm_sysfs_suspend - DRM class suspend hook
  27  * @dev: Linux device to suspend
  28  * @state: power state to enter
  29  *
  30  * Just figures out what the actual struct drm_device associated with
  31  * @dev is and calls its suspend hook, if present.
  32  */
  33 static int drm_sysfs_suspend(struct device *dev, pm_message_t state)
  34 {
  35         struct drm_minor *drm_minor = to_drm_minor(dev);
  36         struct drm_device *drm_dev = drm_minor->dev;
  37
  38         if (drm_minor->type == DRM_MINOR_LEGACY &&
  39             !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
  40             drm_dev->driver->suspend)
  41                 return drm_dev->driver->suspend(drm_dev, state);
  42
  43         return 0;
  44 }
  45
  46 /**
  47  * drm_sysfs_resume - DRM class resume hook
  48  * @dev: Linux device to resume
  49  *
  50  * Just figures out what the actual struct drm_device associated with
  51  * @dev is and calls its resume hook, if present.
  52  */
  53 static int drm_sysfs_resume(struct device *dev)
  54 {
  55         struct drm_minor *drm_minor = to_drm_minor(dev);
  56         struct drm_device *drm_dev = drm_minor->dev;
  57
  58         if (drm_minor->type == DRM_MINOR_LEGACY &&
  59             !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
  60             drm_dev->driver->resume)
  61                 return drm_dev->driver->resume(drm_dev);
  62
  63         return 0;
  64 }
  65
  66 /* Display the version of drm_core. This doesn't work right in current design */
  67 static ssize_t version_show(struct class *dev, char *buf)
  68 {
  69         return sprintf(buf, "%s %d.%d.%d %s\n", CORE_NAME, CORE_MAJOR,
  70                        CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
  71 }
  72
  73 static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
  74
  75 /**
  76  * drm_sysfs_create - create a struct drm_sysfs_class structure
  77  * @owner: pointer to the module that is to "own" this struct drm_sysfs_class
  78  * @name: pointer to a string for the name of this class.
  79  *
  80  * This is used to create DRM class pointer that can then be used
  81  * in calls to drm_sysfs_device_add().
  82  *
  83  * Note, the pointer created here is to be destroyed when finished by making a
  84  * call to drm_sysfs_destroy().
  85  */
  86 struct class *drm_sysfs_create(struct module *owner, char *name)
  87 {
  88         struct class *class;
  89         int err;
  90
  91         class = class_create(owner, name);
  92         if (IS_ERR(class)) {
  93                 err = PTR_ERR(class);
  94                 goto err_out;
  95         }
  96
  97         class->suspend = drm_sysfs_suspend;
  98         class->resume = drm_sysfs_resume;
  99
 100         err = class_create_file(class, &class_attr_version);
 101         if (err)
 102                 goto err_out_class;
 103
 104         return class;
 105
 106 err_out_class:
 107         class_destroy(class);
 108 err_out:
 109         return ERR_PTR(err);
 110 }
 111
 112 /**
 113  * drm_sysfs_destroy - destroys DRM class
 114  *
 115  * Destroy the DRM device class.
 116  */
 117 void drm_sysfs_destroy(void)
 118 {
 119         if ((drm_class == NULL) || (IS_ERR(drm_class)))
 120                 return;
 121         class_remove_file(drm_class, &class_attr_version);
 122         class_destroy(drm_class);
 123 }
 124
 125 /**
 126  * drm_sysfs_device_release - do nothing
 127  * @dev: Linux device
 128  *
 129  * Normally, this would free the DRM device associated with @dev, along
 130  * with cleaning up any other stuff.  But we do that in the DRM core, so
 131  * this function can just return and hope that the core does its job.
 132  */
 133 static void drm_sysfs_device_release(struct device *dev)
 134 {
 135         memset(dev, 0, sizeof(struct device));
 136         return;
 137 }
 138
 139 /*
 140  * Connector properties
 141  */
 142 static ssize_t status_show(struct device *device,
 143                            struct device_attribute *attr,
 144                            char *buf)
 145 {
 146         struct drm_connector *connector = to_drm_connector(device);
 147         enum drm_connector_status status;
 148
 149         status = connector->funcs->detect(connector);
 150         return snprintf(buf, PAGE_SIZE, "%s\n",
 151                         drm_get_connector_status_name(status));
 152 }
 153
 154 static ssize_t dpms_show(struct device *device,
 155                            struct device_attribute *attr,
 156                            char *buf)
 157 {
 158         struct drm_connector *connector = to_drm_connector(device);
 159         struct drm_device *dev = connector->dev;
 160         uint64_t dpms_status;
 161         int ret;
 162
 163         ret = drm_connector_property_get_value(connector,
 164                                             dev->mode_config.dpms_property,
 165                                             &dpms_status);
 166         if (ret)
 167                 return 0;
 168
 169         return snprintf(buf, PAGE_SIZE, "%s\n",
 170                         drm_get_dpms_name((int)dpms_status));
 171 }
 172
 173 static ssize_t enabled_show(struct device *device,
 174                             struct device_attribute *attr,
 175                            char *buf)
 176 {
 177         struct drm_connector *connector = to_drm_connector(device);
 178
 179         return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
 180                         "disabled");
 181 }
 182
 183 static ssize_t edid_show(struct kobject *kobj, struct bin_attribute *attr,
 184                          char *buf, loff_t off, size_t count)
 185 {
 186         struct device *connector_dev = container_of(kobj, struct device, kobj);
 187         struct drm_connector *connector = to_drm_connector(connector_dev);
 188         unsigned char *edid;
 189         size_t size;
 190
 191         if (!connector->edid_blob_ptr)
 192                 return 0;
 193
 194         edid = connector->edid_blob_ptr->data;
 195         size = connector->edid_blob_ptr->length;
 196         if (!edid)
 197                 return 0;
 198
 199         if (off >= size)
 200                 return 0;
 201
 202         if (off + count > size)
 203                 count = size - off;
 204         memcpy(buf, edid + off, count);
 205
 206         return count;
 207 }
 208
 209 static ssize_t modes_show(struct device *device,
 210                            struct device_attribute *attr,
 211                            char *buf)
 212 {
 213         struct drm_connector *connector = to_drm_connector(device);
 214         struct drm_display_mode *mode;
 215         int written = 0;
 216
 217         list_for_each_entry(mode, &connector->modes, head) {
 218                 written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
 219                                     mode->name);
 220         }
 221
 222         return written;
 223 }
 224
 225 static ssize_t subconnector_show(struct device *device,
 226                            struct device_attribute *attr,
 227                            char *buf)
 228 {
 229         struct drm_connector *connector = to_drm_connector(device);
 230         struct drm_device *dev = connector->dev;
 231         struct drm_property *prop = NULL;
 232         uint64_t subconnector;
 233         int is_tv = 0;
 234         int ret;
 235
 236         switch (connector->connector_type) {
 237                 case DRM_MODE_CONNECTOR_DVII:
 238                         prop = dev->mode_config.dvi_i_subconnector_property;
 239                         break;
 240                 case DRM_MODE_CONNECTOR_Composite:
 241                 case DRM_MODE_CONNECTOR_SVIDEO:
 242                 case DRM_MODE_CONNECTOR_Component:
 243                         prop = dev->mode_config.tv_subconnector_property;
 244                         is_tv = 1;
 245                         break;
 246                 default:
 247                         DRM_ERROR("Wrong connector type for this property\n");
 248                         return 0;
 249         }
 250
 251         if (!prop) {
 252                 DRM_ERROR("Unable to find subconnector property\n");
 253                 return 0;
 254         }
 255
 256         ret = drm_connector_property_get_value(connector, prop, &subconnector);
 257         if (ret)
 258                 return 0;
 259
 260         return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
 261                         drm_get_tv_subconnector_name((int)subconnector) :
 262                         drm_get_dvi_i_subconnector_name((int)subconnector));
 263 }
 264
 265 static ssize_t select_subconnector_show(struct device *device,
 266                            struct device_attribute *attr,
 267                            char *buf)
 268 {
 269         struct drm_connector *connector = to_drm_connector(device);
 270         struct drm_device *dev = connector->dev;
 271         struct drm_property *prop = NULL;
 272         uint64_t subconnector;
 273         int is_tv = 0;
 274         int ret;
 275
 276         switch (connector->connector_type) {
 277                 case DRM_MODE_CONNECTOR_DVII:
 278                         prop = dev->mode_config.dvi_i_select_subconnector_property;
 279                         break;
 280                 case DRM_MODE_CONNECTOR_Composite:
 281                 case DRM_MODE_CONNECTOR_SVIDEO:
 282                 case DRM_MODE_CONNECTOR_Component:
 283                         prop = dev->mode_config.tv_select_subconnector_property;
 284                         is_tv = 1;
 285                         break;
 286                 default:
 287                         DRM_ERROR("Wrong connector type for this property\n");
 288                         return 0;
 289         }
 290
 291         if (!prop) {
 292                 DRM_ERROR("Unable to find select subconnector property\n");
 293                 return 0;
 294         }
 295
 296         ret = drm_connector_property_get_value(connector, prop, &subconnector);
 297         if (ret)
 298                 return 0;
 299
 300         return snprintf(buf, PAGE_SIZE, "%s", is_tv ?
 301                         drm_get_tv_select_name((int)subconnector) :
 302                         drm_get_dvi_i_select_name((int)subconnector));
 303 }
 304
 305 static struct device_attribute connector_attrs[] = {
 306         __ATTR_RO(status),
 307         __ATTR_RO(enabled),
 308         __ATTR_RO(dpms),
 309         __ATTR_RO(modes),
 310 };
 311
 312 /* These attributes are for both DVI-I connectors and all types of tv-out. */
 313 static struct device_attribute connector_attrs_opt1[] = {
 314         __ATTR_RO(subconnector),
 315         __ATTR_RO(select_subconnector),
 316 };
 317
 318 static struct bin_attribute edid_attr = {
 319         .attr.name = "edid",
 320         .attr.mode = 0444,
 321         .size = 128,
 322         .read = edid_show,
 323 };
 324
 325 /**
 326  * drm_sysfs_connector_add - add an connector to sysfs
 327  * @connector: connector to add
 328  *
 329  * Create an connector device in sysfs, along with its associated connector
 330  * properties (so far, connection status, dpms, mode list & edid) and
 331  * generate a hotplug event so userspace knows there's a new connector
 332  * available.
 333  *
 334  * Note:
 335  * This routine should only be called *once* for each DRM minor registered.
 336  * A second call for an already registered device will trigger the BUG_ON
 337  * below.
 338  */
 339 int drm_sysfs_connector_add(struct drm_connector *connector)
 340 {
 341         struct drm_device *dev = connector->dev;
 342         int ret = 0, i, j;
 343
 344         /* We shouldn't get called more than once for the same connector */
 345         BUG_ON(device_is_registered(&connector->kdev));
 346
 347         connector->kdev.parent = &dev->primary->kdev;
 348         connector->kdev.class = drm_class;
 349         connector->kdev.release = drm_sysfs_device_release;
 350
 351         DRM_DEBUG("adding \"%s\" to sysfs\n",
 352                   drm_get_connector_name(connector));
 353
 354         dev_set_name(&connector->kdev, "card%d-%s",
 355                      dev->primary->index, drm_get_connector_name(connector));
 356         ret = device_register(&connector->kdev);
 357
 358         if (ret) {
 359                 DRM_ERROR("failed to register connector device: %d\n", ret);
 360                 goto out;
 361         }
 362
 363         /* Standard attributes */
 364
 365         for (i = 0; i < ARRAY_SIZE(connector_attrs); i++) {
 366                 ret = device_create_file(&connector->kdev, &connector_attrs[i]);
 367                 if (ret)
 368                         goto err_out_files;
 369         }
 370
 371         /* Optional attributes */
 372         /*
 373          * In the long run it maybe a good idea to make one set of
 374          * optionals per connector type.
 375          */
 376         switch (connector->connector_type) {
 377                 case DRM_MODE_CONNECTOR_DVII:
 378                 case DRM_MODE_CONNECTOR_Composite:
 379                 case DRM_MODE_CONNECTOR_SVIDEO:
 380                 case DRM_MODE_CONNECTOR_Component:
 381                         for (i = 0; i < ARRAY_SIZE(connector_attrs_opt1); i++) {
 382                                 ret = device_create_file(&connector->kdev, &connector_attrs_opt1[i]);
 383                                 if (ret)
 384                                         goto err_out_files;
 385                         }
 386                         break;
 387                 default:
 388                         break;
 389         }
 390
 391         ret = sysfs_create_bin_file(&connector->kdev.kobj, &edid_attr);
 392         if (ret)
 393                 goto err_out_files;
 394
 395         /* Let userspace know we have a new connector */
 396         drm_sysfs_hotplug_event(dev);
 397
 398         return 0;
 399
 400 err_out_files:
 401         if (i > 0)
 402                 for (j = 0; j < i; j++)
 403                         device_remove_file(&connector->kdev,
 404                                            &connector_attrs[i]);
 405         device_unregister(&connector->kdev);
 406
 407 out:
 408         return ret;
 409 }
 410 EXPORT_SYMBOL(drm_sysfs_connector_add);
 411
 412 /**
 413  * drm_sysfs_connector_remove - remove an connector device from sysfs
 414  * @connector: connector to remove
 415  *
 416  * Remove @connector and its associated attributes from sysfs.  Note that
 417  * the device model core will take care of sending the "remove" uevent
 418  * at this time, so we don't need to do it.
 419  *
 420  * Note:
 421  * This routine should only be called if the connector was previously
 422  * successfully registered.  If @connector hasn't been registered yet,
 423  * you'll likely see a panic somewhere deep in sysfs code when called.
 424  */
 425 void drm_sysfs_connector_remove(struct drm_connector *connector)
 426 {
 427         int i;
 428
 429         DRM_DEBUG("removing \"%s\" from sysfs\n",
 430                   drm_get_connector_name(connector));
 431
 432         for (i = 0; i < ARRAY_SIZE(connector_attrs); i++)
 433                 device_remove_file(&connector->kdev, &connector_attrs[i]);
 434         sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr);
 435         device_unregister(&connector->kdev);
 436 }
 437 EXPORT_SYMBOL(drm_sysfs_connector_remove);
 438
 439 /**
 440  * drm_sysfs_hotplug_event - generate a DRM uevent
 441  * @dev: DRM device
 442  *
 443  * Send a uevent for the DRM device specified by @dev.  Currently we only
 444  * set HOTPLUG=1 in the uevent environment, but this could be expanded to
 445  * deal with other types of events.
 446  */
 447 void drm_sysfs_hotplug_event(struct drm_device *dev)
 448 {
 449         char *event_string = "HOTPLUG=1";
 450         char *envp[] = { event_string, NULL };
 451
 452         DRM_DEBUG("generating hotplug event\n");
 453
 454         kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp);
 455 }
 456 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
 457
 458 /**
 459  * drm_sysfs_device_add - adds a class device to sysfs for a character driver
 460  * @dev: DRM device to be added
 461  * @head: DRM head in question
 462  *
 463  * Add a DRM device to the DRM's device model class.  We use @dev's PCI device
 464  * as the parent for the Linux device, and make sure it has a file containing
 465  * the driver we're using (for userspace compatibility).
 466  */
 467 int drm_sysfs_device_add(struct drm_minor *minor)
 468 {
 469         int err;
 470         char *minor_str;
 471
 472         minor->kdev.parent = &minor->dev->pdev->dev;
 473         minor->kdev.class = drm_class;
 474         minor->kdev.release = drm_sysfs_device_release;
 475         minor->kdev.devt = minor->device;
 476         if (minor->type == DRM_MINOR_CONTROL)
 477                 minor_str = "controlD%d";
 478         else if (minor->type == DRM_MINOR_RENDER)
 479                 minor_str = "renderD%d";
 480         else
 481                 minor_str = "card%d";
 482
 483         dev_set_name(&minor->kdev, minor_str, minor->index);
 484
 485         err = device_register(&minor->kdev);
 486         if (err) {
 487                 DRM_ERROR("device add failed: %d\n", err);
 488                 goto err_out;
 489         }
 490
 491         return 0;
 492
 493 err_out:
 494         return err;
 495 }
 496
 497 /**
 498  * drm_sysfs_device_remove - remove DRM device
 499  * @dev: DRM device to remove
 500  *
 501  * This call unregisters and cleans up a class device that was created with a
 502  * call to drm_sysfs_device_add()
 503  */
 504 void drm_sysfs_device_remove(struct drm_minor *minor)
 505 {
 506         device_unregister(&minor->kdev);
 507 }