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/gfp.h>
  18 #include <linux/err.h>
  19 #include <linux/export.h>
  20
  21 #include <drm/drm_edid.h>
  22 #include <drm/drm_sysfs.h>
  23 #include <drm/drm_core.h>
  24 #include <drm/drmP.h>
  25 #include "drm_internal.h"
  26
  27 #define to_drm_minor(d) dev_get_drvdata(d)
  28 #define to_drm_connector(d) dev_get_drvdata(d)
  29
  30 static struct device_type drm_sysfs_device_minor = {
  31         .name = "drm_minor"
  32 };
  33
  34 struct class *drm_class;
  35
  36 static const char * const audioformatstr[] = {
  37         "",
  38         "LPCM",         /*AUDIO_LPCM = 1,*/
  39         "AC3",          /*AUDIO_AC3,*/
  40         "MPEG1",        /*AUDIO_MPEG1,*/
  41         "MP3",          /*AUDIO_MP3,*/
  42         "MPEG2",        /*AUDIO_MPEG2,*/
  43         "AAC-LC",       /*AUDIO_AAC_LC, AAC*/
  44         "DTS",          /*AUDIO_DTS,*/
  45         "ATARC",        /*AUDIO_ATARC,*/
  46         "DSD",          /*AUDIO_DSD, One bit Audio */
  47         "E-AC3",        /*AUDIO_E_AC3,*/
  48         "DTS-HD",       /*AUDIO_DTS_HD,*/
  49         "MLP",          /*AUDIO_MLP,*/
  50         "DST",          /*AUDIO_DST,*/
  51         "WMA-PRO",      /*AUDIO_WMA_PRO*/
  52 };
  53
  54 /**
  55  * __drm_class_suspend - internal DRM class suspend routine
  56  * @dev: Linux device to suspend
  57  * @state: power state to enter
  58  *
  59  * Just figures out what the actual struct drm_device associated with
  60  * @dev is and calls its suspend hook, if present.
  61  */
  62 static int __drm_class_suspend(struct device *dev, pm_message_t state)
  63 {
  64         if (dev->type == &drm_sysfs_device_minor) {
  65                 struct drm_minor *drm_minor = to_drm_minor(dev);
  66                 struct drm_device *drm_dev = drm_minor->dev;
  67
  68                 if (drm_minor->type == DRM_MINOR_LEGACY &&
  69                     !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
  70                     drm_dev->driver->suspend)
  71                         return drm_dev->driver->suspend(drm_dev, state);
  72         }
  73         return 0;
  74 }
  75
  76 /**
  77  * drm_class_suspend - internal DRM class suspend hook. Simply calls
  78  * __drm_class_suspend() with the correct pm state.
  79  * @dev: Linux device to suspend
  80  */
  81 static int drm_class_suspend(struct device *dev)
  82 {
  83         return __drm_class_suspend(dev, PMSG_SUSPEND);
  84 }
  85
  86 /**
  87  * drm_class_freeze - internal DRM class freeze hook. Simply calls
  88  * __drm_class_suspend() with the correct pm state.
  89  * @dev: Linux device to freeze
  90  */
  91 static int drm_class_freeze(struct device *dev)
  92 {
  93         return __drm_class_suspend(dev, PMSG_FREEZE);
  94 }
  95
  96 /**
  97  * drm_class_resume - DRM class resume hook
  98  * @dev: Linux device to resume
  99  *
 100  * Just figures out what the actual struct drm_device associated with
 101  * @dev is and calls its resume hook, if present.
 102  */
 103 static int drm_class_resume(struct device *dev)
 104 {
 105         if (dev->type == &drm_sysfs_device_minor) {
 106                 struct drm_minor *drm_minor = to_drm_minor(dev);
 107                 struct drm_device *drm_dev = drm_minor->dev;
 108
 109                 if (drm_minor->type == DRM_MINOR_LEGACY &&
 110                     !drm_core_check_feature(drm_dev, DRIVER_MODESET) &&
 111                     drm_dev->driver->resume)
 112                         return drm_dev->driver->resume(drm_dev);
 113         }
 114         return 0;
 115 }
 116
 117 static const struct dev_pm_ops drm_class_dev_pm_ops = {
 118         .suspend        = drm_class_suspend,
 119         .resume         = drm_class_resume,
 120         .freeze         = drm_class_freeze,
 121 };
 122
 123 static char *drm_devnode(struct device *dev, umode_t *mode)
 124 {
 125         return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
 126 }
 127
 128 static CLASS_ATTR_STRING(version, S_IRUGO,
 129                 CORE_NAME " "
 130                 __stringify(CORE_MAJOR) "."
 131                 __stringify(CORE_MINOR) "."
 132                 __stringify(CORE_PATCHLEVEL) " "
 133                 CORE_DATE);
 134
 135 /**
 136  * drm_sysfs_init - initialize sysfs helpers
 137  *
 138  * This is used to create the DRM class, which is the implicit parent of any
 139  * other top-level DRM sysfs objects.
 140  *
 141  * You must call drm_sysfs_destroy() to release the allocated resources.
 142  *
 143  * Return: 0 on success, negative error code on failure.
 144  */
 145 int drm_sysfs_init(void)
 146 {
 147         int err;
 148
 149         drm_class = class_create(THIS_MODULE, "drm");
 150         if (IS_ERR(drm_class))
 151                 return PTR_ERR(drm_class);
 152
 153         drm_class->pm = &drm_class_dev_pm_ops;
 154
 155         err = class_create_file(drm_class, &class_attr_version.attr);
 156         if (err) {
 157                 class_destroy(drm_class);
 158                 drm_class = NULL;
 159                 return err;
 160         }
 161
 162         drm_class->devnode = drm_devnode;
 163         return 0;
 164 }
 165
 166 /**
 167  * drm_sysfs_destroy - destroys DRM class
 168  *
 169  * Destroy the DRM device class.
 170  */
 171 void drm_sysfs_destroy(void)
 172 {
 173         if (IS_ERR_OR_NULL(drm_class))
 174                 return;
 175         class_remove_file(drm_class, &class_attr_version.attr);
 176         class_destroy(drm_class);
 177         drm_class = NULL;
 178 }
 179
 180 /*
 181  * Connector properties
 182  */
 183 static ssize_t status_store(struct device *device,
 184                            struct device_attribute *attr,
 185                            const char *buf, size_t count)
 186 {
 187         struct drm_connector *connector = to_drm_connector(device);
 188         struct drm_device *dev = connector->dev;
 189         enum drm_connector_status old_status;
 190         int ret;
 191
 192         ret = mutex_lock_interruptible(&dev->mode_config.mutex);
 193         if (ret)
 194                 return ret;
 195
 196         old_status = connector->status;
 197
 198         if (sysfs_streq(buf, "detect")) {
 199                 connector->force = 0;
 200                 connector->status = connector->funcs->detect(connector, true);
 201         } else if (sysfs_streq(buf, "on")) {
 202                 connector->force = DRM_FORCE_ON;
 203         } else if (sysfs_streq(buf, "on-digital")) {
 204                 connector->force = DRM_FORCE_ON_DIGITAL;
 205         } else if (sysfs_streq(buf, "off")) {
 206                 connector->force = DRM_FORCE_OFF;
 207         } else
 208                 ret = -EINVAL;
 209
 210         if (ret == 0 && connector->force) {
 211                 if (connector->force == DRM_FORCE_ON ||
 212                     connector->force == DRM_FORCE_ON_DIGITAL)
 213                         connector->status = connector_status_connected;
 214                 else
 215                         connector->status = connector_status_disconnected;
 216                 if (connector->funcs->force)
 217                         connector->funcs->force(connector);
 218         }
 219
 220         if (old_status != connector->status) {
 221                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %d to %d\n",
 222                               connector->base.id,
 223                               connector->name,
 224                               old_status, connector->status);
 225
 226                 dev->mode_config.delayed_event = true;
 227                 if (dev->mode_config.poll_enabled)
 228                         schedule_delayed_work(&dev->mode_config.output_poll_work,
 229                                               0);
 230         }
 231
 232         mutex_unlock(&dev->mode_config.mutex);
 233
 234         return ret ? ret : count;
 235 }
 236
 237 static ssize_t status_show(struct device *device,
 238                            struct device_attribute *attr,
 239                            char *buf)
 240 {
 241         struct drm_connector *connector = to_drm_connector(device);
 242
 243         return snprintf(buf, PAGE_SIZE, "%s\n",
 244                         drm_get_connector_status_name(connector->status));
 245 }
 246
 247 static ssize_t dpms_show(struct device *device,
 248                            struct device_attribute *attr,
 249                            char *buf)
 250 {
 251         struct drm_connector *connector = to_drm_connector(device);
 252         int dpms;
 253
 254         dpms = READ_ONCE(connector->dpms);
 255
 256         return snprintf(buf, PAGE_SIZE, "%s\n",
 257                         drm_get_dpms_name(dpms));
 258 }
 259
 260 static ssize_t enabled_show(struct device *device,
 261                             struct device_attribute *attr,
 262                            char *buf)
 263 {
 264         struct drm_connector *connector = to_drm_connector(device);
 265
 266         return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" :
 267                         "disabled");
 268 }
 269
 270 static int drm_get_audio_format(struct edid *edid,
 271                                char *audioformat, int len)
 272 {
 273         int i, size = 0, num = 0;
 274         struct cea_sad *sads;
 275
 276         memset(audioformat, 0, len);
 277         num = drm_edid_to_sad(edid, &sads);
 278         if (!num)
 279                 return 0;
 280
 281         for (i = 0; i < num; i++) {
 282                 if (sads[i].format < 1 || sads[i].format > 14) {
 283                         DRM_ERROR("audio type unsupported.\n");
 284                         continue;
 285                 }
 286                 size = strlen(audioformatstr[sads[i].format]);
 287                 memcpy(audioformat, audioformatstr[sads[i].format], size);
 288                 audioformat[size] = ',';
 289                 audioformat += (size + 1);
 290         }
 291         return num;
 292 }
 293
 294 static ssize_t audioformat_show(struct device *device,
 295                                 struct device_attribute *attr,
 296                                 char *buf)
 297 {
 298         char audioformat[200];
 299         int ret = 0;
 300         struct edid *edid;
 301         struct drm_connector *connector = to_drm_connector(device);
 302
 303         if (!connector->edid_blob_ptr)
 304                 return 0;
 305
 306         edid = (struct edid *)connector->edid_blob_ptr->data;
 307         ret = drm_get_audio_format(edid, audioformat, 200);
 308         if (ret)
 309                 return snprintf(buf, PAGE_SIZE, "%s\n", audioformat);
 310
 311         return 0;
 312 }
 313
 314 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
 315                          struct bin_attribute *attr, char *buf, loff_t off,
 316                          size_t count)
 317 {
 318         struct device *connector_dev = container_of(kobj, struct device, kobj);
 319         struct drm_connector *connector = to_drm_connector(connector_dev);
 320         unsigned char *edid;
 321         size_t size;
 322
 323         if (!connector->edid_blob_ptr)
 324                 return 0;
 325
 326         edid = connector->edid_blob_ptr->data;
 327         size = connector->edid_blob_ptr->length;
 328         if (!edid)
 329                 return 0;
 330
 331         if (off >= size)
 332                 return 0;
 333
 334         if (off + count > size)
 335                 count = size - off;
 336         memcpy(buf, edid + off, count);
 337
 338         return count;
 339 }
 340
 341 static ssize_t modes_show(struct device *device,
 342                            struct device_attribute *attr,
 343                            char *buf)
 344 {
 345         struct drm_connector *connector = to_drm_connector(device);
 346         struct drm_display_mode *mode;
 347         int written = 0;
 348
 349         list_for_each_entry(mode, &connector->modes, head) {
 350                 bool interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
 351
 352                 written += snprintf(buf + written, PAGE_SIZE - written,
 353                                     "%dx%d%s%d\n",
 354                                     mode->hdisplay, mode->vdisplay,
 355                                     interlaced ? "i" : "p",
 356                                     drm_mode_vrefresh(mode));
 357         }
 358
 359         return written;
 360 }
 361
 362 static ssize_t mode_show(struct device *device,
 363                            struct device_attribute *attr,
 364                            char *buf)
 365 {
 366         struct drm_connector *connector = to_drm_connector(device);
 367         struct drm_display_mode *mode;
 368         struct drm_crtc_state *crtc_state;
 369         bool interlaced;
 370         int written = 0;
 371
 372         if (!connector->state || !connector->state->crtc)
 373                 return written;
 374
 375         crtc_state = connector->state->crtc->state;
 376         if (!crtc_state)
 377                 return written;
 378
 379         mode = &crtc_state->mode;
 380
 381         interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
 382         written += snprintf(buf + written, PAGE_SIZE - written,
 383                             "%dx%d%s%d\n",
 384                             mode->hdisplay, mode->vdisplay,
 385                             interlaced ? "i" : "p",
 386                             drm_mode_vrefresh(mode));
 387
 388         return written;
 389 }
 390
 391 static ssize_t tv_subconnector_show(struct device *device,
 392                                     struct device_attribute *attr,
 393                                     char *buf)
 394 {
 395         struct drm_connector *connector = to_drm_connector(device);
 396         struct drm_device *dev = connector->dev;
 397         struct drm_property *prop;
 398         uint64_t subconnector;
 399         int ret;
 400
 401         prop = dev->mode_config.tv_subconnector_property;
 402         if (!prop) {
 403                 DRM_ERROR("Unable to find subconnector property\n");
 404                 return 0;
 405         }
 406
 407         ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
 408         if (ret)
 409                 return 0;
 410
 411         return snprintf(buf, PAGE_SIZE, "%s",
 412                         drm_get_tv_subconnector_name((int)subconnector));
 413 }
 414
 415 static ssize_t tv_select_subconnector_show(struct device *device,
 416                                            struct device_attribute *attr,
 417                                            char *buf)
 418 {
 419         struct drm_connector *connector = to_drm_connector(device);
 420         struct drm_device *dev = connector->dev;
 421         struct drm_property *prop;
 422         uint64_t subconnector;
 423         int ret;
 424
 425         prop = dev->mode_config.tv_select_subconnector_property;
 426         if (!prop) {
 427                 DRM_ERROR("Unable to find select subconnector property\n");
 428                 return 0;
 429         }
 430
 431         ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
 432         if (ret)
 433                 return 0;
 434
 435         return snprintf(buf, PAGE_SIZE, "%s",
 436                         drm_get_tv_select_name((int)subconnector));
 437 }
 438
 439 static ssize_t dvii_subconnector_show(struct device *device,
 440                                       struct device_attribute *attr,
 441                                       char *buf)
 442 {
 443         struct drm_connector *connector = to_drm_connector(device);
 444         struct drm_device *dev = connector->dev;
 445         struct drm_property *prop;
 446         uint64_t subconnector;
 447         int ret;
 448
 449         prop = dev->mode_config.dvi_i_subconnector_property;
 450         if (!prop) {
 451                 DRM_ERROR("Unable to find subconnector property\n");
 452                 return 0;
 453         }
 454
 455         ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
 456         if (ret)
 457                 return 0;
 458
 459         return snprintf(buf, PAGE_SIZE, "%s",
 460                         drm_get_dvi_i_subconnector_name((int)subconnector));
 461 }
 462
 463 static ssize_t dvii_select_subconnector_show(struct device *device,
 464                                              struct device_attribute *attr,
 465                                              char *buf)
 466 {
 467         struct drm_connector *connector = to_drm_connector(device);
 468         struct drm_device *dev = connector->dev;
 469         struct drm_property *prop;
 470         uint64_t subconnector;
 471         int ret;
 472
 473         prop = dev->mode_config.dvi_i_select_subconnector_property;
 474         if (!prop) {
 475                 DRM_ERROR("Unable to find select subconnector property\n");
 476                 return 0;
 477         }
 478
 479         ret = drm_object_property_get_value(&connector->base, prop, &subconnector);
 480         if (ret)
 481                 return 0;
 482
 483         return snprintf(buf, PAGE_SIZE, "%s",
 484                         drm_get_dvi_i_select_name((int)subconnector));
 485 }
 486
 487 static DEVICE_ATTR_RW(status);
 488 static DEVICE_ATTR_RO(enabled);
 489 static DEVICE_ATTR_RO(dpms);
 490 static DEVICE_ATTR_RO(modes);
 491 static DEVICE_ATTR_RO(mode);
 492 static DEVICE_ATTR_RO(audioformat);
 493
 494 static struct attribute *connector_dev_attrs[] = {
 495         &dev_attr_status.attr,
 496         &dev_attr_enabled.attr,
 497         &dev_attr_dpms.attr,
 498         &dev_attr_modes.attr,
 499         &dev_attr_mode.attr,
 500         &dev_attr_audioformat.attr,
 501         NULL
 502 };
 503
 504 static DEVICE_ATTR_RO(tv_subconnector);
 505 static DEVICE_ATTR_RO(tv_select_subconnector);
 506
 507 static struct attribute *connector_tv_dev_attrs[] = {
 508         &dev_attr_tv_subconnector.attr,
 509         &dev_attr_tv_select_subconnector.attr,
 510         NULL
 511 };
 512
 513 static DEVICE_ATTR_RO(dvii_subconnector);
 514 static DEVICE_ATTR_RO(dvii_select_subconnector);
 515
 516 static struct attribute *connector_dvii_dev_attrs[] = {
 517         &dev_attr_dvii_subconnector.attr,
 518         &dev_attr_dvii_select_subconnector.attr,
 519         NULL
 520 };
 521
 522 /* Connector type related helpers */
 523 static int kobj_connector_type(struct kobject *kobj)
 524 {
 525         struct device *dev = kobj_to_dev(kobj);
 526         struct drm_connector *connector = to_drm_connector(dev);
 527
 528         return connector->connector_type;
 529 }
 530
 531 static umode_t connector_is_dvii(struct kobject *kobj,
 532                                  struct attribute *attr, int idx)
 533 {
 534         return kobj_connector_type(kobj) == DRM_MODE_CONNECTOR_DVII ?
 535                 attr->mode : 0;
 536 }
 537
 538 static umode_t connector_is_tv(struct kobject *kobj,
 539                                struct attribute *attr, int idx)
 540 {
 541         switch (kobj_connector_type(kobj)) {
 542         case DRM_MODE_CONNECTOR_Composite:
 543         case DRM_MODE_CONNECTOR_SVIDEO:
 544         case DRM_MODE_CONNECTOR_Component:
 545         case DRM_MODE_CONNECTOR_TV:
 546                 return attr->mode;
 547         }
 548
 549         return 0;
 550 }
 551
 552 static struct bin_attribute edid_attr = {
 553         .attr.name = "edid",
 554         .attr.mode = 0444,
 555         .size = 0,
 556         .read = edid_show,
 557 };
 558
 559 static struct bin_attribute *connector_bin_attrs[] = {
 560         &edid_attr,
 561         NULL
 562 };
 563
 564 static const struct attribute_group connector_dev_group = {
 565         .attrs = connector_dev_attrs,
 566         .bin_attrs = connector_bin_attrs,
 567 };
 568
 569 static const struct attribute_group connector_tv_dev_group = {
 570         .attrs = connector_tv_dev_attrs,
 571         .is_visible = connector_is_tv,
 572 };
 573
 574 static const struct attribute_group connector_dvii_dev_group = {
 575         .attrs = connector_dvii_dev_attrs,
 576         .is_visible = connector_is_dvii,
 577 };
 578
 579 static const struct attribute_group *connector_dev_groups[] = {
 580         &connector_dev_group,
 581         &connector_tv_dev_group,
 582         &connector_dvii_dev_group,
 583         NULL
 584 };
 585
 586 /**
 587  * drm_sysfs_connector_add - add a connector to sysfs
 588  * @connector: connector to add
 589  *
 590  * Create a connector device in sysfs, along with its associated connector
 591  * properties (so far, connection status, dpms, mode list & edid) and
 592  * generate a hotplug event so userspace knows there's a new connector
 593  * available.
 594  */
 595 int drm_sysfs_connector_add(struct drm_connector *connector)
 596 {
 597         struct drm_device *dev = connector->dev;
 598
 599         if (connector->kdev)
 600                 return 0;
 601
 602         connector->kdev =
 603                 device_create_with_groups(drm_class, dev->primary->kdev, 0,
 604                                           connector, connector_dev_groups,
 605                                           "card%d-%s", dev->primary->index,
 606                                           connector->name);
 607         DRM_DEBUG("adding \"%s\" to sysfs\n",
 608                   connector->name);
 609
 610         if (IS_ERR(connector->kdev)) {
 611                 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
 612                 return PTR_ERR(connector->kdev);
 613         }
 614
 615         /* Let userspace know we have a new connector */
 616         drm_sysfs_hotplug_event(dev);
 617
 618         return 0;
 619 }
 620
 621 /**
 622  * drm_sysfs_connector_remove - remove an connector device from sysfs
 623  * @connector: connector to remove
 624  *
 625  * Remove @connector and its associated attributes from sysfs.  Note that
 626  * the device model core will take care of sending the "remove" uevent
 627  * at this time, so we don't need to do it.
 628  *
 629  * Note:
 630  * This routine should only be called if the connector was previously
 631  * successfully registered.  If @connector hasn't been registered yet,
 632  * you'll likely see a panic somewhere deep in sysfs code when called.
 633  */
 634 void drm_sysfs_connector_remove(struct drm_connector *connector)
 635 {
 636         if (!connector->kdev)
 637                 return;
 638         DRM_DEBUG("removing \"%s\" from sysfs\n",
 639                   connector->name);
 640
 641         device_unregister(connector->kdev);
 642         connector->kdev = NULL;
 643 }
 644
 645 /**
 646  * drm_sysfs_hotplug_event - generate a DRM uevent
 647  * @dev: DRM device
 648  *
 649  * Send a uevent for the DRM device specified by @dev.  Currently we only
 650  * set HOTPLUG=1 in the uevent environment, but this could be expanded to
 651  * deal with other types of events.
 652  */
 653 void drm_sysfs_hotplug_event(struct drm_device *dev)
 654 {
 655         char *event_string = "HOTPLUG=1";
 656         char *envp[] = { event_string, NULL };
 657
 658         DRM_DEBUG("generating hotplug event\n");
 659
 660         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
 661 }
 662 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
 663
 664 static void drm_sysfs_release(struct device *dev)
 665 {
 666         kfree(dev);
 667 }
 668
 669 /**
 670  * drm_sysfs_minor_alloc() - Allocate sysfs device for given minor
 671  * @minor: minor to allocate sysfs device for
 672  *
 673  * This allocates a new sysfs device for @minor and returns it. The device is
 674  * not registered nor linked. The caller has to use device_add() and
 675  * device_del() to register and unregister it.
 676  *
 677  * Note that dev_get_drvdata() on the new device will return the minor.
 678  * However, the device does not hold a ref-count to the minor nor to the
 679  * underlying drm_device. This is unproblematic as long as you access the
 680  * private data only in sysfs callbacks. device_del() disables those
 681  * synchronously, so they cannot be called after you cleanup a minor.
 682  */
 683 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
 684 {
 685         const char *minor_str;
 686         struct device *kdev;
 687         int r;
 688
 689         if (minor->type == DRM_MINOR_CONTROL)
 690                 minor_str = "controlD%d";
 691         else if (minor->type == DRM_MINOR_RENDER)
 692                 minor_str = "renderD%d";
 693         else
 694                 minor_str = "card%d";
 695
 696         kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
 697         if (!kdev)
 698                 return ERR_PTR(-ENOMEM);
 699
 700         device_initialize(kdev);
 701         kdev->devt = MKDEV(DRM_MAJOR, minor->index);
 702         kdev->class = drm_class;
 703         kdev->type = &drm_sysfs_device_minor;
 704         kdev->parent = minor->dev->dev;
 705         kdev->release = drm_sysfs_release;
 706         dev_set_drvdata(kdev, minor);
 707
 708         r = dev_set_name(kdev, minor_str, minor->index);
 709         if (r < 0)
 710                 goto err_free;
 711
 712         return kdev;
 713
 714 err_free:
 715         put_device(kdev);
 716         return ERR_PTR(r);
 717 }
 718
 719 /**
 720  * drm_class_device_register - Register a struct device in the drm class.
 721  *
 722  * @dev: pointer to struct device to register.
 723  *
 724  * @dev should have all relevant members pre-filled with the exception
 725  * of the class member. In particular, the device_type member must
 726  * be set.
 727  */
 728
 729 int drm_class_device_register(struct device *dev)
 730 {
 731         if (!drm_class || IS_ERR(drm_class))
 732                 return -ENOENT;
 733
 734         dev->class = drm_class;
 735         return device_register(dev);
 736 }
 737 EXPORT_SYMBOL_GPL(drm_class_device_register);
 738
 739 void drm_class_device_unregister(struct device *dev)
 740 {
 741         return device_unregister(dev);
 742 }
 743 EXPORT_SYMBOL_GPL(drm_class_device_unregister);