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 20 #include "drm_sysfs.h" 21 #include "drm_core.h" 22 #include "drmP.h" 23 24 #define to_drm_minor(d) container_of(d, struct drm_minor, kdev) 25 #define to_drm_connector(d) container_of(d, struct drm_connector, kdev) 26 27 static struct device_type drm_sysfs_device_minor = { 28 .name = "drm_minor" 29 }; 30 31 /** 32 * drm_class_suspend - DRM class suspend hook 33 * @dev: Linux device to suspend 34 * @state: power state to enter 35 * 36 * Just figures out what the actual struct drm_device associated with 37 * @dev is and calls its suspend hook, if present. 38 */ 39 static int drm_class_suspend(struct device *dev, pm_message_t state) 40 { 41 if (dev->type == &drm_sysfs_device_minor) { 42 struct drm_minor *drm_minor = to_drm_minor(dev); 43 struct drm_device *drm_dev = drm_minor->dev; 44 45 if (drm_minor->type == DRM_MINOR_LEGACY && 46 !drm_core_check_feature(drm_dev, DRIVER_MODESET) && 47 drm_dev->driver->suspend) 48 return drm_dev->driver->suspend(drm_dev, state); 49 } 50 return 0; 51 } 52 53 /** 54 * drm_class_resume - DRM class resume hook 55 * @dev: Linux device to resume 56 * 57 * Just figures out what the actual struct drm_device associated with 58 * @dev is and calls its resume hook, if present. 59 */ 60 static int drm_class_resume(struct device *dev) 61 { 62 if (dev->type == &drm_sysfs_device_minor) { 63 struct drm_minor *drm_minor = to_drm_minor(dev); 64 struct drm_device *drm_dev = drm_minor->dev; 65 66 if (drm_minor->type == DRM_MINOR_LEGACY && 67 !drm_core_check_feature(drm_dev, DRIVER_MODESET) && 68 drm_dev->driver->resume) 69 return drm_dev->driver->resume(drm_dev); 70 } 71 return 0; 72 } 73 74 static char *drm_devnode(struct device *dev, mode_t *mode) 75 { 76 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); 77 } 78 79 static CLASS_ATTR_STRING(version, S_IRUGO, 80 CORE_NAME " " 81 __stringify(CORE_MAJOR) "." 82 __stringify(CORE_MINOR) "." 83 __stringify(CORE_PATCHLEVEL) " " 84 CORE_DATE); 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.attr); 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.attr); 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 int ret; 162 163 ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex); 164 if (ret) 165 return ret; 166 167 status = connector->funcs->detect(connector, true); 168 mutex_unlock(&connector->dev->mode_config.mutex); 169 170 return snprintf(buf, PAGE_SIZE, "%s\n", 171 drm_get_connector_status_name(status)); 172 } 173 174 static ssize_t dpms_show(struct device *device, 175 struct device_attribute *attr, 176 char *buf) 177 { 178 struct drm_connector *connector = to_drm_connector(device); 179 struct drm_device *dev = connector->dev; 180 uint64_t dpms_status; 181 int ret; 182 183 ret = drm_connector_property_get_value(connector, 184 dev->mode_config.dpms_property, 185 &dpms_status); 186 if (ret) 187 return 0; 188 189 return snprintf(buf, PAGE_SIZE, "%s\n", 190 drm_get_dpms_name((int)dpms_status)); 191 } 192 193 static ssize_t enabled_show(struct device *device, 194 struct device_attribute *attr, 195 char *buf) 196 { 197 struct drm_connector *connector = to_drm_connector(device); 198 199 return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" : 200 "disabled"); 201 } 202 203 static ssize_t edid_show(struct file *filp, struct kobject *kobj, 204 struct bin_attribute *attr, char *buf, loff_t off, 205 size_t count) 206 { 207 struct device *connector_dev = container_of(kobj, struct device, kobj); 208 struct drm_connector *connector = to_drm_connector(connector_dev); 209 unsigned char *edid; 210 size_t size; 211 212 if (!connector->edid_blob_ptr) 213 return 0; 214 215 edid = connector->edid_blob_ptr->data; 216 size = connector->edid_blob_ptr->length; 217 if (!edid) 218 return 0; 219 220 if (off >= size) 221 return 0; 222 223 if (off + count > size) 224 count = size - off; 225 memcpy(buf, edid + off, count); 226 227 return count; 228 } 229 230 static ssize_t modes_show(struct device *device, 231 struct device_attribute *attr, 232 char *buf) 233 { 234 struct drm_connector *connector = to_drm_connector(device); 235 struct drm_display_mode *mode; 236 int written = 0; 237 238 list_for_each_entry(mode, &connector->modes, head) { 239 written += snprintf(buf + written, PAGE_SIZE - written, "%s\n", 240 mode->name); 241 } 242 243 return written; 244 } 245 246 static ssize_t subconnector_show(struct device *device, 247 struct device_attribute *attr, 248 char *buf) 249 { 250 struct drm_connector *connector = to_drm_connector(device); 251 struct drm_device *dev = connector->dev; 252 struct drm_property *prop = NULL; 253 uint64_t subconnector; 254 int is_tv = 0; 255 int ret; 256 257 switch (connector->connector_type) { 258 case DRM_MODE_CONNECTOR_DVII: 259 prop = dev->mode_config.dvi_i_subconnector_property; 260 break; 261 case DRM_MODE_CONNECTOR_Composite: 262 case DRM_MODE_CONNECTOR_SVIDEO: 263 case DRM_MODE_CONNECTOR_Component: 264 case DRM_MODE_CONNECTOR_TV: 265 prop = dev->mode_config.tv_subconnector_property; 266 is_tv = 1; 267 break; 268 default: 269 DRM_ERROR("Wrong connector type for this property\n"); 270 return 0; 271 } 272 273 if (!prop) { 274 DRM_ERROR("Unable to find subconnector property\n"); 275 return 0; 276 } 277 278 ret = drm_connector_property_get_value(connector, prop, &subconnector); 279 if (ret) 280 return 0; 281 282 return snprintf(buf, PAGE_SIZE, "%s", is_tv ? 283 drm_get_tv_subconnector_name((int)subconnector) : 284 drm_get_dvi_i_subconnector_name((int)subconnector)); 285 } 286 287 static ssize_t select_subconnector_show(struct device *device, 288 struct device_attribute *attr, 289 char *buf) 290 { 291 struct drm_connector *connector = to_drm_connector(device); 292 struct drm_device *dev = connector->dev; 293 struct drm_property *prop = NULL; 294 uint64_t subconnector; 295 int is_tv = 0; 296 int ret; 297 298 switch (connector->connector_type) { 299 case DRM_MODE_CONNECTOR_DVII: 300 prop = dev->mode_config.dvi_i_select_subconnector_property; 301 break; 302 case DRM_MODE_CONNECTOR_Composite: 303 case DRM_MODE_CONNECTOR_SVIDEO: 304 case DRM_MODE_CONNECTOR_Component: 305 case DRM_MODE_CONNECTOR_TV: 306 prop = dev->mode_config.tv_select_subconnector_property; 307 is_tv = 1; 308 break; 309 default: 310 DRM_ERROR("Wrong connector type for this property\n"); 311 return 0; 312 } 313 314 if (!prop) { 315 DRM_ERROR("Unable to find select subconnector property\n"); 316 return 0; 317 } 318 319 ret = drm_connector_property_get_value(connector, prop, &subconnector); 320 if (ret) 321 return 0; 322 323 return snprintf(buf, PAGE_SIZE, "%s", is_tv ? 324 drm_get_tv_select_name((int)subconnector) : 325 drm_get_dvi_i_select_name((int)subconnector)); 326 } 327 328 static struct device_attribute connector_attrs[] = { 329 __ATTR_RO(status), 330 __ATTR_RO(enabled), 331 __ATTR_RO(dpms), 332 __ATTR_RO(modes), 333 }; 334 335 /* These attributes are for both DVI-I connectors and all types of tv-out. */ 336 static struct device_attribute connector_attrs_opt1[] = { 337 __ATTR_RO(subconnector), 338 __ATTR_RO(select_subconnector), 339 }; 340 341 static struct bin_attribute edid_attr = { 342 .attr.name = "edid", 343 .attr.mode = 0444, 344 .size = 0, 345 .read = edid_show, 346 }; 347 348 /** 349 * drm_sysfs_connector_add - add an connector to sysfs 350 * @connector: connector to add 351 * 352 * Create an connector device in sysfs, along with its associated connector 353 * properties (so far, connection status, dpms, mode list & edid) and 354 * generate a hotplug event so userspace knows there's a new connector 355 * available. 356 * 357 * Note: 358 * This routine should only be called *once* for each DRM minor registered. 359 * A second call for an already registered device will trigger the BUG_ON 360 * below. 361 */ 362 int drm_sysfs_connector_add(struct drm_connector *connector) 363 { 364 struct drm_device *dev = connector->dev; 365 int attr_cnt = 0; 366 int opt_cnt = 0; 367 int i; 368 int ret = 0; 369 370 /* We shouldn't get called more than once for the same connector */ 371 BUG_ON(device_is_registered(&connector->kdev)); 372 373 connector->kdev.parent = &dev->primary->kdev; 374 connector->kdev.class = drm_class; 375 connector->kdev.release = drm_sysfs_device_release; 376 377 DRM_DEBUG("adding \"%s\" to sysfs\n", 378 drm_get_connector_name(connector)); 379 380 dev_set_name(&connector->kdev, "card%d-%s", 381 dev->primary->index, drm_get_connector_name(connector)); 382 ret = device_register(&connector->kdev); 383 384 if (ret) { 385 DRM_ERROR("failed to register connector device: %d\n", ret); 386 goto out; 387 } 388 389 /* Standard attributes */ 390 391 for (attr_cnt = 0; attr_cnt < ARRAY_SIZE(connector_attrs); attr_cnt++) { 392 ret = device_create_file(&connector->kdev, &connector_attrs[attr_cnt]); 393 if (ret) 394 goto err_out_files; 395 } 396 397 /* Optional attributes */ 398 /* 399 * In the long run it maybe a good idea to make one set of 400 * optionals per connector type. 401 */ 402 switch (connector->connector_type) { 403 case DRM_MODE_CONNECTOR_DVII: 404 case DRM_MODE_CONNECTOR_Composite: 405 case DRM_MODE_CONNECTOR_SVIDEO: 406 case DRM_MODE_CONNECTOR_Component: 407 case DRM_MODE_CONNECTOR_TV: 408 for (opt_cnt = 0; opt_cnt < ARRAY_SIZE(connector_attrs_opt1); opt_cnt++) { 409 ret = device_create_file(&connector->kdev, &connector_attrs_opt1[opt_cnt]); 410 if (ret) 411 goto err_out_files; 412 } 413 break; 414 default: 415 break; 416 } 417 418 ret = sysfs_create_bin_file(&connector->kdev.kobj, &edid_attr); 419 if (ret) 420 goto err_out_files; 421 422 /* Let userspace know we have a new connector */ 423 drm_sysfs_hotplug_event(dev); 424 425 return 0; 426 427 err_out_files: 428 for (i = 0; i < opt_cnt; i++) 429 device_remove_file(&connector->kdev, &connector_attrs_opt1[i]); 430 for (i = 0; i < attr_cnt; i++) 431 device_remove_file(&connector->kdev, &connector_attrs[i]); 432 device_unregister(&connector->kdev); 433 434 out: 435 return ret; 436 } 437 EXPORT_SYMBOL(drm_sysfs_connector_add); 438 439 /** 440 * drm_sysfs_connector_remove - remove an connector device from sysfs 441 * @connector: connector to remove 442 * 443 * Remove @connector and its associated attributes from sysfs. Note that 444 * the device model core will take care of sending the "remove" uevent 445 * at this time, so we don't need to do it. 446 * 447 * Note: 448 * This routine should only be called if the connector was previously 449 * successfully registered. If @connector hasn't been registered yet, 450 * you'll likely see a panic somewhere deep in sysfs code when called. 451 */ 452 void drm_sysfs_connector_remove(struct drm_connector *connector) 453 { 454 int i; 455 456 DRM_DEBUG("removing \"%s\" from sysfs\n", 457 drm_get_connector_name(connector)); 458 459 for (i = 0; i < ARRAY_SIZE(connector_attrs); i++) 460 device_remove_file(&connector->kdev, &connector_attrs[i]); 461 sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr); 462 device_unregister(&connector->kdev); 463 } 464 EXPORT_SYMBOL(drm_sysfs_connector_remove); 465 466 /** 467 * drm_sysfs_hotplug_event - generate a DRM uevent 468 * @dev: DRM device 469 * 470 * Send a uevent for the DRM device specified by @dev. Currently we only 471 * set HOTPLUG=1 in the uevent environment, but this could be expanded to 472 * deal with other types of events. 473 */ 474 void drm_sysfs_hotplug_event(struct drm_device *dev) 475 { 476 char *event_string = "HOTPLUG=1"; 477 char *envp[] = { event_string, NULL }; 478 479 DRM_DEBUG("generating hotplug event\n"); 480 481 kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp); 482 } 483 EXPORT_SYMBOL(drm_sysfs_hotplug_event); 484 485 /** 486 * drm_sysfs_device_add - adds a class device to sysfs for a character driver 487 * @dev: DRM device to be added 488 * @head: DRM head in question 489 * 490 * Add a DRM device to the DRM's device model class. We use @dev's PCI device 491 * as the parent for the Linux device, and make sure it has a file containing 492 * the driver we're using (for userspace compatibility). 493 */ 494 int drm_sysfs_device_add(struct drm_minor *minor) 495 { 496 int err; 497 char *minor_str; 498 499 minor->kdev.parent = minor->dev->dev; 500 501 minor->kdev.class = drm_class; 502 minor->kdev.release = drm_sysfs_device_release; 503 minor->kdev.devt = minor->device; 504 minor->kdev.type = &drm_sysfs_device_minor; 505 if (minor->type == DRM_MINOR_CONTROL) 506 minor_str = "controlD%d"; 507 else if (minor->type == DRM_MINOR_RENDER) 508 minor_str = "renderD%d"; 509 else 510 minor_str = "card%d"; 511 512 dev_set_name(&minor->kdev, minor_str, minor->index); 513 514 err = device_register(&minor->kdev); 515 if (err) { 516 DRM_ERROR("device add failed: %d\n", err); 517 goto err_out; 518 } 519 520 return 0; 521 522 err_out: 523 return err; 524 } 525 526 /** 527 * drm_sysfs_device_remove - remove DRM device 528 * @dev: DRM device to remove 529 * 530 * This call unregisters and cleans up a class device that was created with a 531 * call to drm_sysfs_device_add() 532 */ 533 void drm_sysfs_device_remove(struct drm_minor *minor) 534 { 535 device_unregister(&minor->kdev); 536 } 537 538 539 /** 540 * drm_class_device_register - Register a struct device in the drm class. 541 * 542 * @dev: pointer to struct device to register. 543 * 544 * @dev should have all relevant members pre-filled with the exception 545 * of the class member. In particular, the device_type member must 546 * be set. 547 */ 548 549 int drm_class_device_register(struct device *dev) 550 { 551 dev->class = drm_class; 552 return device_register(dev); 553 } 554 EXPORT_SYMBOL_GPL(drm_class_device_register); 555 556 void drm_class_device_unregister(struct device *dev) 557 { 558 return device_unregister(dev); 559 } 560 EXPORT_SYMBOL_GPL(drm_class_device_unregister); 561