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> 175a0e3ad6STejun Heo #include <linux/gfp.h> 18c0e09200SDave Airlie #include <linux/err.h> 192d1a8a48SPaul Gortmaker #include <linux/export.h> 20c0e09200SDave Airlie 21327c225bSThomas Hellstrom #include "drm_sysfs.h" 22c0e09200SDave Airlie #include "drm_core.h" 23c0e09200SDave Airlie #include "drmP.h" 24c0e09200SDave Airlie 25c0e09200SDave Airlie #define to_drm_minor(d) container_of(d, struct drm_minor, kdev) 26f453ba04SDave Airlie #define to_drm_connector(d) container_of(d, struct drm_connector, kdev) 27c0e09200SDave Airlie 2808e4d534SThomas Hellstrom static struct device_type drm_sysfs_device_minor = { 2908e4d534SThomas Hellstrom .name = "drm_minor" 3008e4d534SThomas Hellstrom }; 3108e4d534SThomas Hellstrom 32c0e09200SDave Airlie /** 3308e4d534SThomas Hellstrom * drm_class_suspend - DRM class suspend hook 34c0e09200SDave Airlie * @dev: Linux device to suspend 35c0e09200SDave Airlie * @state: power state to enter 36c0e09200SDave Airlie * 37c0e09200SDave Airlie * Just figures out what the actual struct drm_device associated with 38c0e09200SDave Airlie * @dev is and calls its suspend hook, if present. 39c0e09200SDave Airlie */ 4008e4d534SThomas Hellstrom static int drm_class_suspend(struct device *dev, pm_message_t state) 41c0e09200SDave Airlie { 4208e4d534SThomas Hellstrom if (dev->type == &drm_sysfs_device_minor) { 43c0e09200SDave Airlie struct drm_minor *drm_minor = to_drm_minor(dev); 44c0e09200SDave Airlie struct drm_device *drm_dev = drm_minor->dev; 45c0e09200SDave Airlie 46112b715eSKristian Høgsberg if (drm_minor->type == DRM_MINOR_LEGACY && 47112b715eSKristian Høgsberg !drm_core_check_feature(drm_dev, DRIVER_MODESET) && 48112b715eSKristian Høgsberg drm_dev->driver->suspend) 49c0e09200SDave Airlie return drm_dev->driver->suspend(drm_dev, state); 5008e4d534SThomas Hellstrom } 51c0e09200SDave Airlie return 0; 52c0e09200SDave Airlie } 53c0e09200SDave Airlie 54c0e09200SDave Airlie /** 5508e4d534SThomas Hellstrom * drm_class_resume - DRM class resume hook 56c0e09200SDave Airlie * @dev: Linux device to resume 57c0e09200SDave Airlie * 58c0e09200SDave Airlie * Just figures out what the actual struct drm_device associated with 59c0e09200SDave Airlie * @dev is and calls its resume hook, if present. 60c0e09200SDave Airlie */ 6108e4d534SThomas Hellstrom static int drm_class_resume(struct device *dev) 62c0e09200SDave Airlie { 6308e4d534SThomas Hellstrom if (dev->type == &drm_sysfs_device_minor) { 64c0e09200SDave Airlie struct drm_minor *drm_minor = to_drm_minor(dev); 65c0e09200SDave Airlie struct drm_device *drm_dev = drm_minor->dev; 66c0e09200SDave Airlie 67112b715eSKristian Høgsberg if (drm_minor->type == DRM_MINOR_LEGACY && 68112b715eSKristian Høgsberg !drm_core_check_feature(drm_dev, DRIVER_MODESET) && 69112b715eSKristian Høgsberg drm_dev->driver->resume) 70c0e09200SDave Airlie return drm_dev->driver->resume(drm_dev); 7108e4d534SThomas Hellstrom } 72c0e09200SDave Airlie return 0; 73c0e09200SDave Airlie } 74c0e09200SDave Airlie 752c9ede55SAl Viro static char *drm_devnode(struct device *dev, umode_t *mode) 7602200d06SKay Sievers { 7702200d06SKay Sievers return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); 7802200d06SKay Sievers } 7902200d06SKay Sievers 800933e2d9SAndi Kleen static CLASS_ATTR_STRING(version, S_IRUGO, 810933e2d9SAndi Kleen CORE_NAME " " 820933e2d9SAndi Kleen __stringify(CORE_MAJOR) "." 830933e2d9SAndi Kleen __stringify(CORE_MINOR) "." 840933e2d9SAndi Kleen __stringify(CORE_PATCHLEVEL) " " 850933e2d9SAndi Kleen CORE_DATE); 86c0e09200SDave Airlie 87c0e09200SDave Airlie /** 88c0e09200SDave Airlie * drm_sysfs_create - create a struct drm_sysfs_class structure 89c0e09200SDave Airlie * @owner: pointer to the module that is to "own" this struct drm_sysfs_class 90c0e09200SDave Airlie * @name: pointer to a string for the name of this class. 91c0e09200SDave Airlie * 92c0e09200SDave Airlie * This is used to create DRM class pointer that can then be used 93c0e09200SDave Airlie * in calls to drm_sysfs_device_add(). 94c0e09200SDave Airlie * 95c0e09200SDave Airlie * Note, the pointer created here is to be destroyed when finished by making a 96c0e09200SDave Airlie * call to drm_sysfs_destroy(). 97c0e09200SDave Airlie */ 98c0e09200SDave Airlie struct class *drm_sysfs_create(struct module *owner, char *name) 99c0e09200SDave Airlie { 100c0e09200SDave Airlie struct class *class; 101c0e09200SDave Airlie int err; 102c0e09200SDave Airlie 103c0e09200SDave Airlie class = class_create(owner, name); 104c0e09200SDave Airlie if (IS_ERR(class)) { 105c0e09200SDave Airlie err = PTR_ERR(class); 106c0e09200SDave Airlie goto err_out; 107c0e09200SDave Airlie } 108c0e09200SDave Airlie 10908e4d534SThomas Hellstrom class->suspend = drm_class_suspend; 11008e4d534SThomas Hellstrom class->resume = drm_class_resume; 111c0e09200SDave Airlie 1120933e2d9SAndi Kleen err = class_create_file(class, &class_attr_version.attr); 113c0e09200SDave Airlie if (err) 114c0e09200SDave Airlie goto err_out_class; 115c0e09200SDave Airlie 116e454cea2SKay Sievers class->devnode = drm_devnode; 11702200d06SKay Sievers 118c0e09200SDave Airlie return class; 119c0e09200SDave Airlie 120c0e09200SDave Airlie err_out_class: 121c0e09200SDave Airlie class_destroy(class); 122c0e09200SDave Airlie err_out: 123c0e09200SDave Airlie return ERR_PTR(err); 124c0e09200SDave Airlie } 125c0e09200SDave Airlie 126c0e09200SDave Airlie /** 127c0e09200SDave Airlie * drm_sysfs_destroy - destroys DRM class 128c0e09200SDave Airlie * 129c0e09200SDave Airlie * Destroy the DRM device class. 130c0e09200SDave Airlie */ 131c0e09200SDave Airlie void drm_sysfs_destroy(void) 132c0e09200SDave Airlie { 133c0e09200SDave Airlie if ((drm_class == NULL) || (IS_ERR(drm_class))) 134c0e09200SDave Airlie return; 1350933e2d9SAndi Kleen class_remove_file(drm_class, &class_attr_version.attr); 136c0e09200SDave Airlie class_destroy(drm_class); 13749099c49SDave Airlie drm_class = NULL; 138c0e09200SDave Airlie } 139c0e09200SDave Airlie 140c0e09200SDave Airlie /** 141c0e09200SDave Airlie * drm_sysfs_device_release - do nothing 142c0e09200SDave Airlie * @dev: Linux device 143c0e09200SDave Airlie * 144c0e09200SDave Airlie * Normally, this would free the DRM device associated with @dev, along 145c0e09200SDave Airlie * with cleaning up any other stuff. But we do that in the DRM core, so 146c0e09200SDave Airlie * this function can just return and hope that the core does its job. 147c0e09200SDave Airlie */ 148c0e09200SDave Airlie static void drm_sysfs_device_release(struct device *dev) 149c0e09200SDave Airlie { 15077d26dc9SMa Ling memset(dev, 0, sizeof(struct device)); 151c0e09200SDave Airlie return; 152c0e09200SDave Airlie } 153c0e09200SDave Airlie 154f453ba04SDave Airlie /* 155f453ba04SDave Airlie * Connector properties 156f453ba04SDave Airlie */ 157f453ba04SDave Airlie static ssize_t status_show(struct device *device, 158f453ba04SDave Airlie struct device_attribute *attr, 159f453ba04SDave Airlie char *buf) 160f453ba04SDave Airlie { 161f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 162f453ba04SDave Airlie enum drm_connector_status status; 163007c80a5SChris Wilson int ret; 164007c80a5SChris Wilson 165007c80a5SChris Wilson ret = mutex_lock_interruptible(&connector->dev->mode_config.mutex); 166007c80a5SChris Wilson if (ret) 167007c80a5SChris Wilson return ret; 168f453ba04SDave Airlie 1697b334fcbSChris Wilson status = connector->funcs->detect(connector, true); 170007c80a5SChris Wilson mutex_unlock(&connector->dev->mode_config.mutex); 171007c80a5SChris Wilson 17275185c92SKeith Packard return snprintf(buf, PAGE_SIZE, "%s\n", 173f453ba04SDave Airlie drm_get_connector_status_name(status)); 174f453ba04SDave Airlie } 175f453ba04SDave Airlie 176f453ba04SDave Airlie static ssize_t dpms_show(struct device *device, 177f453ba04SDave Airlie struct device_attribute *attr, 178f453ba04SDave Airlie char *buf) 179f453ba04SDave Airlie { 180f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 181f453ba04SDave Airlie struct drm_device *dev = connector->dev; 182f453ba04SDave Airlie uint64_t dpms_status; 183f453ba04SDave Airlie int ret; 184f453ba04SDave Airlie 185f453ba04SDave Airlie ret = drm_connector_property_get_value(connector, 186f453ba04SDave Airlie dev->mode_config.dpms_property, 187f453ba04SDave Airlie &dpms_status); 188f453ba04SDave Airlie if (ret) 189f453ba04SDave Airlie return 0; 190f453ba04SDave Airlie 19175185c92SKeith Packard return snprintf(buf, PAGE_SIZE, "%s\n", 192f453ba04SDave Airlie drm_get_dpms_name((int)dpms_status)); 193f453ba04SDave Airlie } 194f453ba04SDave Airlie 195f453ba04SDave Airlie static ssize_t enabled_show(struct device *device, 196f453ba04SDave Airlie struct device_attribute *attr, 197f453ba04SDave Airlie char *buf) 198f453ba04SDave Airlie { 199f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 200f453ba04SDave Airlie 20175185c92SKeith Packard return snprintf(buf, PAGE_SIZE, "%s\n", connector->encoder ? "enabled" : 202f453ba04SDave Airlie "disabled"); 203f453ba04SDave Airlie } 204f453ba04SDave Airlie 2052c3c8beaSChris Wright static ssize_t edid_show(struct file *filp, struct kobject *kobj, 2062c3c8beaSChris Wright struct bin_attribute *attr, char *buf, loff_t off, 2072c3c8beaSChris Wright size_t count) 208f453ba04SDave Airlie { 209f453ba04SDave Airlie struct device *connector_dev = container_of(kobj, struct device, kobj); 210f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(connector_dev); 211f453ba04SDave Airlie unsigned char *edid; 212f453ba04SDave Airlie size_t size; 213f453ba04SDave Airlie 214f453ba04SDave Airlie if (!connector->edid_blob_ptr) 215f453ba04SDave Airlie return 0; 216f453ba04SDave Airlie 217f453ba04SDave Airlie edid = connector->edid_blob_ptr->data; 218f453ba04SDave Airlie size = connector->edid_blob_ptr->length; 219f453ba04SDave Airlie if (!edid) 220f453ba04SDave Airlie return 0; 221f453ba04SDave Airlie 222f453ba04SDave Airlie if (off >= size) 223f453ba04SDave Airlie return 0; 224f453ba04SDave Airlie 225f453ba04SDave Airlie if (off + count > size) 226f453ba04SDave Airlie count = size - off; 227f453ba04SDave Airlie memcpy(buf, edid + off, count); 228f453ba04SDave Airlie 229f453ba04SDave Airlie return count; 230f453ba04SDave Airlie } 231f453ba04SDave Airlie 232f453ba04SDave Airlie static ssize_t modes_show(struct device *device, 233f453ba04SDave Airlie struct device_attribute *attr, 234f453ba04SDave Airlie char *buf) 235f453ba04SDave Airlie { 236f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 237f453ba04SDave Airlie struct drm_display_mode *mode; 238f453ba04SDave Airlie int written = 0; 239f453ba04SDave Airlie 240f453ba04SDave Airlie list_for_each_entry(mode, &connector->modes, head) { 241f453ba04SDave Airlie written += snprintf(buf + written, PAGE_SIZE - written, "%s\n", 242f453ba04SDave Airlie mode->name); 243f453ba04SDave Airlie } 244f453ba04SDave Airlie 245f453ba04SDave Airlie return written; 246f453ba04SDave Airlie } 247f453ba04SDave Airlie 248f453ba04SDave Airlie static ssize_t subconnector_show(struct device *device, 249f453ba04SDave Airlie struct device_attribute *attr, 250f453ba04SDave Airlie char *buf) 251f453ba04SDave Airlie { 252f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 253f453ba04SDave Airlie struct drm_device *dev = connector->dev; 254f453ba04SDave Airlie struct drm_property *prop = NULL; 255f453ba04SDave Airlie uint64_t subconnector; 256f453ba04SDave Airlie int is_tv = 0; 257f453ba04SDave Airlie int ret; 258f453ba04SDave Airlie 259f453ba04SDave Airlie switch (connector->connector_type) { 260f453ba04SDave Airlie case DRM_MODE_CONNECTOR_DVII: 261f453ba04SDave Airlie prop = dev->mode_config.dvi_i_subconnector_property; 262f453ba04SDave Airlie break; 263f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Composite: 264f453ba04SDave Airlie case DRM_MODE_CONNECTOR_SVIDEO: 265f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Component: 26674bd3c26SFrancisco Jerez case DRM_MODE_CONNECTOR_TV: 267f453ba04SDave Airlie prop = dev->mode_config.tv_subconnector_property; 268f453ba04SDave Airlie is_tv = 1; 269f453ba04SDave Airlie break; 270f453ba04SDave Airlie default: 271f453ba04SDave Airlie DRM_ERROR("Wrong connector type for this property\n"); 272f453ba04SDave Airlie return 0; 273f453ba04SDave Airlie } 274f453ba04SDave Airlie 275f453ba04SDave Airlie if (!prop) { 276f453ba04SDave Airlie DRM_ERROR("Unable to find subconnector property\n"); 277f453ba04SDave Airlie return 0; 278f453ba04SDave Airlie } 279f453ba04SDave Airlie 280f453ba04SDave Airlie ret = drm_connector_property_get_value(connector, prop, &subconnector); 281f453ba04SDave Airlie if (ret) 282f453ba04SDave Airlie return 0; 283f453ba04SDave Airlie 284f453ba04SDave Airlie return snprintf(buf, PAGE_SIZE, "%s", is_tv ? 285f453ba04SDave Airlie drm_get_tv_subconnector_name((int)subconnector) : 286f453ba04SDave Airlie drm_get_dvi_i_subconnector_name((int)subconnector)); 287f453ba04SDave Airlie } 288f453ba04SDave Airlie 289f453ba04SDave Airlie static ssize_t select_subconnector_show(struct device *device, 290f453ba04SDave Airlie struct device_attribute *attr, 291f453ba04SDave Airlie char *buf) 292f453ba04SDave Airlie { 293f453ba04SDave Airlie struct drm_connector *connector = to_drm_connector(device); 294f453ba04SDave Airlie struct drm_device *dev = connector->dev; 295f453ba04SDave Airlie struct drm_property *prop = NULL; 296f453ba04SDave Airlie uint64_t subconnector; 297f453ba04SDave Airlie int is_tv = 0; 298f453ba04SDave Airlie int ret; 299f453ba04SDave Airlie 300f453ba04SDave Airlie switch (connector->connector_type) { 301f453ba04SDave Airlie case DRM_MODE_CONNECTOR_DVII: 302f453ba04SDave Airlie prop = dev->mode_config.dvi_i_select_subconnector_property; 303f453ba04SDave Airlie break; 304f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Composite: 305f453ba04SDave Airlie case DRM_MODE_CONNECTOR_SVIDEO: 306f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Component: 30774bd3c26SFrancisco Jerez case DRM_MODE_CONNECTOR_TV: 308f453ba04SDave Airlie prop = dev->mode_config.tv_select_subconnector_property; 309f453ba04SDave Airlie is_tv = 1; 310f453ba04SDave Airlie break; 311f453ba04SDave Airlie default: 312f453ba04SDave Airlie DRM_ERROR("Wrong connector type for this property\n"); 313f453ba04SDave Airlie return 0; 314f453ba04SDave Airlie } 315f453ba04SDave Airlie 316f453ba04SDave Airlie if (!prop) { 317f453ba04SDave Airlie DRM_ERROR("Unable to find select subconnector property\n"); 318f453ba04SDave Airlie return 0; 319f453ba04SDave Airlie } 320f453ba04SDave Airlie 321f453ba04SDave Airlie ret = drm_connector_property_get_value(connector, prop, &subconnector); 322f453ba04SDave Airlie if (ret) 323f453ba04SDave Airlie return 0; 324f453ba04SDave Airlie 325f453ba04SDave Airlie return snprintf(buf, PAGE_SIZE, "%s", is_tv ? 326f453ba04SDave Airlie drm_get_tv_select_name((int)subconnector) : 327f453ba04SDave Airlie drm_get_dvi_i_select_name((int)subconnector)); 328f453ba04SDave Airlie } 329f453ba04SDave Airlie 330f453ba04SDave Airlie static struct device_attribute connector_attrs[] = { 331f453ba04SDave Airlie __ATTR_RO(status), 332f453ba04SDave Airlie __ATTR_RO(enabled), 333f453ba04SDave Airlie __ATTR_RO(dpms), 334f453ba04SDave Airlie __ATTR_RO(modes), 335f453ba04SDave Airlie }; 336f453ba04SDave Airlie 337f453ba04SDave Airlie /* These attributes are for both DVI-I connectors and all types of tv-out. */ 338f453ba04SDave Airlie static struct device_attribute connector_attrs_opt1[] = { 339f453ba04SDave Airlie __ATTR_RO(subconnector), 340f453ba04SDave Airlie __ATTR_RO(select_subconnector), 341f453ba04SDave Airlie }; 342f453ba04SDave Airlie 343f453ba04SDave Airlie static struct bin_attribute edid_attr = { 344f453ba04SDave Airlie .attr.name = "edid", 345e36ebaf4SKeith Packard .attr.mode = 0444, 3467466f4ccSAdam Jackson .size = 0, 347f453ba04SDave Airlie .read = edid_show, 348f453ba04SDave Airlie }; 349f453ba04SDave Airlie 350f453ba04SDave Airlie /** 3513b02ab88SLaurent Pinchart * drm_sysfs_connector_add - add a connector to sysfs 352f453ba04SDave Airlie * @connector: connector to add 353f453ba04SDave Airlie * 3543b02ab88SLaurent Pinchart * Create a connector device in sysfs, along with its associated connector 355f453ba04SDave Airlie * properties (so far, connection status, dpms, mode list & edid) and 356f453ba04SDave Airlie * generate a hotplug event so userspace knows there's a new connector 357f453ba04SDave Airlie * available. 358f453ba04SDave Airlie * 359f453ba04SDave Airlie * Note: 3603b02ab88SLaurent Pinchart * This routine should only be called *once* for each registered connector. 3613b02ab88SLaurent Pinchart * A second call for an already registered connector will trigger the BUG_ON 362f453ba04SDave Airlie * below. 363f453ba04SDave Airlie */ 364f453ba04SDave Airlie int drm_sysfs_connector_add(struct drm_connector *connector) 365f453ba04SDave Airlie { 366f453ba04SDave Airlie struct drm_device *dev = connector->dev; 367a1c4560dSDan Carpenter int attr_cnt = 0; 368a1c4560dSDan Carpenter int opt_cnt = 0; 369a1c4560dSDan Carpenter int i; 3704a1b0714SLaurent Pinchart int ret; 371f453ba04SDave Airlie 372f453ba04SDave Airlie /* We shouldn't get called more than once for the same connector */ 373f453ba04SDave Airlie BUG_ON(device_is_registered(&connector->kdev)); 374f453ba04SDave Airlie 375f453ba04SDave Airlie connector->kdev.parent = &dev->primary->kdev; 376f453ba04SDave Airlie connector->kdev.class = drm_class; 377f453ba04SDave Airlie connector->kdev.release = drm_sysfs_device_release; 378f453ba04SDave Airlie 379f453ba04SDave Airlie DRM_DEBUG("adding \"%s\" to sysfs\n", 380f453ba04SDave Airlie drm_get_connector_name(connector)); 381f453ba04SDave Airlie 3822ead054cSKay Sievers dev_set_name(&connector->kdev, "card%d-%s", 383f453ba04SDave Airlie dev->primary->index, drm_get_connector_name(connector)); 384f453ba04SDave Airlie ret = device_register(&connector->kdev); 385f453ba04SDave Airlie 386f453ba04SDave Airlie if (ret) { 387f453ba04SDave Airlie DRM_ERROR("failed to register connector device: %d\n", ret); 388f453ba04SDave Airlie goto out; 389f453ba04SDave Airlie } 390f453ba04SDave Airlie 391f453ba04SDave Airlie /* Standard attributes */ 392f453ba04SDave Airlie 393a1c4560dSDan Carpenter for (attr_cnt = 0; attr_cnt < ARRAY_SIZE(connector_attrs); attr_cnt++) { 394a1c4560dSDan Carpenter ret = device_create_file(&connector->kdev, &connector_attrs[attr_cnt]); 395f453ba04SDave Airlie if (ret) 396f453ba04SDave Airlie goto err_out_files; 397f453ba04SDave Airlie } 398f453ba04SDave Airlie 399f453ba04SDave Airlie /* Optional attributes */ 400f453ba04SDave Airlie /* 401f453ba04SDave Airlie * In the long run it maybe a good idea to make one set of 402f453ba04SDave Airlie * optionals per connector type. 403f453ba04SDave Airlie */ 404f453ba04SDave Airlie switch (connector->connector_type) { 405f453ba04SDave Airlie case DRM_MODE_CONNECTOR_DVII: 406f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Composite: 407f453ba04SDave Airlie case DRM_MODE_CONNECTOR_SVIDEO: 408f453ba04SDave Airlie case DRM_MODE_CONNECTOR_Component: 40974bd3c26SFrancisco Jerez case DRM_MODE_CONNECTOR_TV: 410a1c4560dSDan Carpenter for (opt_cnt = 0; opt_cnt < ARRAY_SIZE(connector_attrs_opt1); opt_cnt++) { 411a1c4560dSDan Carpenter ret = device_create_file(&connector->kdev, &connector_attrs_opt1[opt_cnt]); 412f453ba04SDave Airlie if (ret) 413f453ba04SDave Airlie goto err_out_files; 414f453ba04SDave Airlie } 415f453ba04SDave Airlie break; 416f453ba04SDave Airlie default: 417f453ba04SDave Airlie break; 418f453ba04SDave Airlie } 419f453ba04SDave Airlie 420f453ba04SDave Airlie ret = sysfs_create_bin_file(&connector->kdev.kobj, &edid_attr); 421f453ba04SDave Airlie if (ret) 422f453ba04SDave Airlie goto err_out_files; 423f453ba04SDave Airlie 424f453ba04SDave Airlie /* Let userspace know we have a new connector */ 425f453ba04SDave Airlie drm_sysfs_hotplug_event(dev); 426f453ba04SDave Airlie 427f453ba04SDave Airlie return 0; 428f453ba04SDave Airlie 429f453ba04SDave Airlie err_out_files: 430a1c4560dSDan Carpenter for (i = 0; i < opt_cnt; i++) 431a1c4560dSDan Carpenter device_remove_file(&connector->kdev, &connector_attrs_opt1[i]); 432a1c4560dSDan Carpenter for (i = 0; i < attr_cnt; i++) 433a1c4560dSDan Carpenter device_remove_file(&connector->kdev, &connector_attrs[i]); 434f453ba04SDave Airlie device_unregister(&connector->kdev); 435f453ba04SDave Airlie 436f453ba04SDave Airlie out: 437f453ba04SDave Airlie return ret; 438f453ba04SDave Airlie } 439f453ba04SDave Airlie EXPORT_SYMBOL(drm_sysfs_connector_add); 440f453ba04SDave Airlie 441f453ba04SDave Airlie /** 442f453ba04SDave Airlie * drm_sysfs_connector_remove - remove an connector device from sysfs 443f453ba04SDave Airlie * @connector: connector to remove 444f453ba04SDave Airlie * 445f453ba04SDave Airlie * Remove @connector and its associated attributes from sysfs. Note that 446f453ba04SDave Airlie * the device model core will take care of sending the "remove" uevent 447f453ba04SDave Airlie * at this time, so we don't need to do it. 448f453ba04SDave Airlie * 449f453ba04SDave Airlie * Note: 450f453ba04SDave Airlie * This routine should only be called if the connector was previously 451f453ba04SDave Airlie * successfully registered. If @connector hasn't been registered yet, 452f453ba04SDave Airlie * you'll likely see a panic somewhere deep in sysfs code when called. 453f453ba04SDave Airlie */ 454f453ba04SDave Airlie void drm_sysfs_connector_remove(struct drm_connector *connector) 455f453ba04SDave Airlie { 456f453ba04SDave Airlie int i; 457f453ba04SDave Airlie 4581828fe6cSDave Airlie if (!connector->kdev.parent) 4591828fe6cSDave Airlie return; 460f453ba04SDave Airlie DRM_DEBUG("removing \"%s\" from sysfs\n", 461f453ba04SDave Airlie drm_get_connector_name(connector)); 462f453ba04SDave Airlie 463f453ba04SDave Airlie for (i = 0; i < ARRAY_SIZE(connector_attrs); i++) 464f453ba04SDave Airlie device_remove_file(&connector->kdev, &connector_attrs[i]); 465f453ba04SDave Airlie sysfs_remove_bin_file(&connector->kdev.kobj, &edid_attr); 466f453ba04SDave Airlie device_unregister(&connector->kdev); 4671828fe6cSDave Airlie connector->kdev.parent = NULL; 468f453ba04SDave Airlie } 469f453ba04SDave Airlie EXPORT_SYMBOL(drm_sysfs_connector_remove); 470f453ba04SDave Airlie 471f453ba04SDave Airlie /** 472f453ba04SDave Airlie * drm_sysfs_hotplug_event - generate a DRM uevent 473f453ba04SDave Airlie * @dev: DRM device 474f453ba04SDave Airlie * 475f453ba04SDave Airlie * Send a uevent for the DRM device specified by @dev. Currently we only 476f453ba04SDave Airlie * set HOTPLUG=1 in the uevent environment, but this could be expanded to 477f453ba04SDave Airlie * deal with other types of events. 478f453ba04SDave Airlie */ 479f453ba04SDave Airlie void drm_sysfs_hotplug_event(struct drm_device *dev) 480f453ba04SDave Airlie { 481f453ba04SDave Airlie char *event_string = "HOTPLUG=1"; 482f453ba04SDave Airlie char *envp[] = { event_string, NULL }; 483f453ba04SDave Airlie 484f453ba04SDave Airlie DRM_DEBUG("generating hotplug event\n"); 485f453ba04SDave Airlie 486f453ba04SDave Airlie kobject_uevent_env(&dev->primary->kdev.kobj, KOBJ_CHANGE, envp); 487f453ba04SDave Airlie } 4885ca58282SJesse Barnes EXPORT_SYMBOL(drm_sysfs_hotplug_event); 489f453ba04SDave Airlie 490c0e09200SDave Airlie /** 491c0e09200SDave Airlie * drm_sysfs_device_add - adds a class device to sysfs for a character driver 492c0e09200SDave Airlie * @dev: DRM device to be added 493c0e09200SDave Airlie * @head: DRM head in question 494c0e09200SDave Airlie * 495c0e09200SDave Airlie * Add a DRM device to the DRM's device model class. We use @dev's PCI device 496c0e09200SDave Airlie * as the parent for the Linux device, and make sure it has a file containing 497c0e09200SDave Airlie * the driver we're using (for userspace compatibility). 498c0e09200SDave Airlie */ 499c0e09200SDave Airlie int drm_sysfs_device_add(struct drm_minor *minor) 500c0e09200SDave Airlie { 501c0e09200SDave Airlie int err; 502c0e09200SDave Airlie char *minor_str; 503c0e09200SDave Airlie 504dcdb1674SJordan Crouse minor->kdev.parent = minor->dev->dev; 505dcdb1674SJordan Crouse 506c0e09200SDave Airlie minor->kdev.class = drm_class; 507c0e09200SDave Airlie minor->kdev.release = drm_sysfs_device_release; 508c0e09200SDave Airlie minor->kdev.devt = minor->device; 50908e4d534SThomas Hellstrom minor->kdev.type = &drm_sysfs_device_minor; 510f453ba04SDave Airlie if (minor->type == DRM_MINOR_CONTROL) 511f453ba04SDave Airlie minor_str = "controlD%d"; 512f453ba04SDave Airlie else if (minor->type == DRM_MINOR_RENDER) 513f453ba04SDave Airlie minor_str = "renderD%d"; 514f453ba04SDave Airlie else 515c0e09200SDave Airlie minor_str = "card%d"; 516c0e09200SDave Airlie 5178f4bbd9fSKay Sievers dev_set_name(&minor->kdev, minor_str, minor->index); 518c0e09200SDave Airlie 519c0e09200SDave Airlie err = device_register(&minor->kdev); 520c0e09200SDave Airlie if (err) { 521c0e09200SDave Airlie DRM_ERROR("device add failed: %d\n", err); 522c0e09200SDave Airlie goto err_out; 523c0e09200SDave Airlie } 524c0e09200SDave Airlie 525c0e09200SDave Airlie return 0; 526c0e09200SDave Airlie 527c0e09200SDave Airlie err_out: 528c0e09200SDave Airlie return err; 529c0e09200SDave Airlie } 530c0e09200SDave Airlie 531c0e09200SDave Airlie /** 532c0e09200SDave Airlie * drm_sysfs_device_remove - remove DRM device 533c0e09200SDave Airlie * @dev: DRM device to remove 534c0e09200SDave Airlie * 535c0e09200SDave Airlie * This call unregisters and cleans up a class device that was created with a 536c0e09200SDave Airlie * call to drm_sysfs_device_add() 537c0e09200SDave Airlie */ 538c0e09200SDave Airlie void drm_sysfs_device_remove(struct drm_minor *minor) 539c0e09200SDave Airlie { 5401828fe6cSDave Airlie if (minor->kdev.parent) 541c0e09200SDave Airlie device_unregister(&minor->kdev); 5421828fe6cSDave Airlie minor->kdev.parent = NULL; 543c0e09200SDave Airlie } 544327c225bSThomas Hellstrom 545327c225bSThomas Hellstrom 546327c225bSThomas Hellstrom /** 547327c225bSThomas Hellstrom * drm_class_device_register - Register a struct device in the drm class. 548327c225bSThomas Hellstrom * 549327c225bSThomas Hellstrom * @dev: pointer to struct device to register. 550327c225bSThomas Hellstrom * 551327c225bSThomas Hellstrom * @dev should have all relevant members pre-filled with the exception 552327c225bSThomas Hellstrom * of the class member. In particular, the device_type member must 553327c225bSThomas Hellstrom * be set. 554327c225bSThomas Hellstrom */ 555327c225bSThomas Hellstrom 556327c225bSThomas Hellstrom int drm_class_device_register(struct device *dev) 557327c225bSThomas Hellstrom { 55849099c49SDave Airlie if (!drm_class || IS_ERR(drm_class)) 55949099c49SDave Airlie return -ENOENT; 56049099c49SDave Airlie 561327c225bSThomas Hellstrom dev->class = drm_class; 562327c225bSThomas Hellstrom return device_register(dev); 563327c225bSThomas Hellstrom } 564327c225bSThomas Hellstrom EXPORT_SYMBOL_GPL(drm_class_device_register); 565327c225bSThomas Hellstrom 566327c225bSThomas Hellstrom void drm_class_device_unregister(struct device *dev) 567327c225bSThomas Hellstrom { 568327c225bSThomas Hellstrom return device_unregister(dev); 569327c225bSThomas Hellstrom } 570327c225bSThomas Hellstrom EXPORT_SYMBOL_GPL(drm_class_device_unregister); 571