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