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