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