1 // SPDX-License-Identifier: GPL-2.0-only 2 3 /* 4 * drm_sysfs.c - Modifications to drm_sysfs_class.c to support 5 * extra sysfs attribute from DRM. Normal drm_sysfs_class 6 * does not allow adding attributes. 7 * 8 * Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com> 9 * Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com> 10 * Copyright (c) 2003-2004 IBM Corp. 11 */ 12 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/export.h> 16 #include <linux/gfp.h> 17 #include <linux/i2c.h> 18 #include <linux/kdev_t.h> 19 #include <linux/slab.h> 20 21 #include <drm/drm_connector.h> 22 #include <drm/drm_device.h> 23 #include <drm/drm_file.h> 24 #include <drm/drm_modes.h> 25 #include <drm/drm_print.h> 26 #include <drm/drm_property.h> 27 #include <drm/drm_sysfs.h> 28 29 #include "drm_internal.h" 30 #include "drm_crtc_internal.h" 31 32 #define to_drm_minor(d) dev_get_drvdata(d) 33 #define to_drm_connector(d) dev_get_drvdata(d) 34 35 /** 36 * DOC: overview 37 * 38 * DRM provides very little additional support to drivers for sysfs 39 * interactions, beyond just all the standard stuff. Drivers who want to expose 40 * additional sysfs properties and property groups can attach them at either 41 * &drm_device.dev or &drm_connector.kdev. 42 * 43 * Registration is automatically handled when calling drm_dev_register(), or 44 * drm_connector_register() in case of hot-plugged connectors. Unregistration is 45 * also automatically handled by drm_dev_unregister() and 46 * drm_connector_unregister(). 47 */ 48 49 static struct device_type drm_sysfs_device_minor = { 50 .name = "drm_minor" 51 }; 52 53 struct class *drm_class; 54 55 static char *drm_devnode(struct device *dev, umode_t *mode) 56 { 57 return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); 58 } 59 60 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810"); 61 62 /** 63 * drm_sysfs_init - initialize sysfs helpers 64 * 65 * This is used to create the DRM class, which is the implicit parent of any 66 * other top-level DRM sysfs objects. 67 * 68 * You must call drm_sysfs_destroy() to release the allocated resources. 69 * 70 * Return: 0 on success, negative error code on failure. 71 */ 72 int drm_sysfs_init(void) 73 { 74 int err; 75 76 drm_class = class_create(THIS_MODULE, "drm"); 77 if (IS_ERR(drm_class)) 78 return PTR_ERR(drm_class); 79 80 err = class_create_file(drm_class, &class_attr_version.attr); 81 if (err) { 82 class_destroy(drm_class); 83 drm_class = NULL; 84 return err; 85 } 86 87 drm_class->devnode = drm_devnode; 88 return 0; 89 } 90 91 /** 92 * drm_sysfs_destroy - destroys DRM class 93 * 94 * Destroy the DRM device class. 95 */ 96 void drm_sysfs_destroy(void) 97 { 98 if (IS_ERR_OR_NULL(drm_class)) 99 return; 100 class_remove_file(drm_class, &class_attr_version.attr); 101 class_destroy(drm_class); 102 drm_class = NULL; 103 } 104 105 /* 106 * Connector properties 107 */ 108 static ssize_t status_store(struct device *device, 109 struct device_attribute *attr, 110 const char *buf, size_t count) 111 { 112 struct drm_connector *connector = to_drm_connector(device); 113 struct drm_device *dev = connector->dev; 114 enum drm_connector_force old_force; 115 int ret; 116 117 ret = mutex_lock_interruptible(&dev->mode_config.mutex); 118 if (ret) 119 return ret; 120 121 old_force = connector->force; 122 123 if (sysfs_streq(buf, "detect")) 124 connector->force = 0; 125 else if (sysfs_streq(buf, "on")) 126 connector->force = DRM_FORCE_ON; 127 else if (sysfs_streq(buf, "on-digital")) 128 connector->force = DRM_FORCE_ON_DIGITAL; 129 else if (sysfs_streq(buf, "off")) 130 connector->force = DRM_FORCE_OFF; 131 else 132 ret = -EINVAL; 133 134 if (old_force != connector->force || !connector->force) { 135 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n", 136 connector->base.id, 137 connector->name, 138 old_force, connector->force); 139 140 connector->funcs->fill_modes(connector, 141 dev->mode_config.max_width, 142 dev->mode_config.max_height); 143 } 144 145 mutex_unlock(&dev->mode_config.mutex); 146 147 return ret ? ret : count; 148 } 149 150 static ssize_t status_show(struct device *device, 151 struct device_attribute *attr, 152 char *buf) 153 { 154 struct drm_connector *connector = to_drm_connector(device); 155 enum drm_connector_status status; 156 157 status = READ_ONCE(connector->status); 158 159 return snprintf(buf, PAGE_SIZE, "%s\n", 160 drm_get_connector_status_name(status)); 161 } 162 163 static ssize_t dpms_show(struct device *device, 164 struct device_attribute *attr, 165 char *buf) 166 { 167 struct drm_connector *connector = to_drm_connector(device); 168 int dpms; 169 170 dpms = READ_ONCE(connector->dpms); 171 172 return snprintf(buf, PAGE_SIZE, "%s\n", 173 drm_get_dpms_name(dpms)); 174 } 175 176 static ssize_t enabled_show(struct device *device, 177 struct device_attribute *attr, 178 char *buf) 179 { 180 struct drm_connector *connector = to_drm_connector(device); 181 bool enabled; 182 183 enabled = READ_ONCE(connector->encoder); 184 185 return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n"); 186 } 187 188 static ssize_t edid_show(struct file *filp, struct kobject *kobj, 189 struct bin_attribute *attr, char *buf, loff_t off, 190 size_t count) 191 { 192 struct device *connector_dev = kobj_to_dev(kobj); 193 struct drm_connector *connector = to_drm_connector(connector_dev); 194 unsigned char *edid; 195 size_t size; 196 ssize_t ret = 0; 197 198 mutex_lock(&connector->dev->mode_config.mutex); 199 if (!connector->edid_blob_ptr) 200 goto unlock; 201 202 edid = connector->edid_blob_ptr->data; 203 size = connector->edid_blob_ptr->length; 204 if (!edid) 205 goto unlock; 206 207 if (off >= size) 208 goto unlock; 209 210 if (off + count > size) 211 count = size - off; 212 memcpy(buf, edid + off, count); 213 214 ret = count; 215 unlock: 216 mutex_unlock(&connector->dev->mode_config.mutex); 217 218 return ret; 219 } 220 221 static ssize_t modes_show(struct device *device, 222 struct device_attribute *attr, 223 char *buf) 224 { 225 struct drm_connector *connector = to_drm_connector(device); 226 struct drm_display_mode *mode; 227 int written = 0; 228 229 mutex_lock(&connector->dev->mode_config.mutex); 230 list_for_each_entry(mode, &connector->modes, head) { 231 written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n", 232 mode->name); 233 } 234 mutex_unlock(&connector->dev->mode_config.mutex); 235 236 return written; 237 } 238 239 static DEVICE_ATTR_RW(status); 240 static DEVICE_ATTR_RO(enabled); 241 static DEVICE_ATTR_RO(dpms); 242 static DEVICE_ATTR_RO(modes); 243 244 static struct attribute *connector_dev_attrs[] = { 245 &dev_attr_status.attr, 246 &dev_attr_enabled.attr, 247 &dev_attr_dpms.attr, 248 &dev_attr_modes.attr, 249 NULL 250 }; 251 252 static struct bin_attribute edid_attr = { 253 .attr.name = "edid", 254 .attr.mode = 0444, 255 .size = 0, 256 .read = edid_show, 257 }; 258 259 static struct bin_attribute *connector_bin_attrs[] = { 260 &edid_attr, 261 NULL 262 }; 263 264 static const struct attribute_group connector_dev_group = { 265 .attrs = connector_dev_attrs, 266 .bin_attrs = connector_bin_attrs, 267 }; 268 269 static const struct attribute_group *connector_dev_groups[] = { 270 &connector_dev_group, 271 NULL 272 }; 273 274 int drm_sysfs_connector_add(struct drm_connector *connector) 275 { 276 struct drm_device *dev = connector->dev; 277 278 if (connector->kdev) 279 return 0; 280 281 connector->kdev = 282 device_create_with_groups(drm_class, dev->primary->kdev, 0, 283 connector, connector_dev_groups, 284 "card%d-%s", dev->primary->index, 285 connector->name); 286 DRM_DEBUG("adding \"%s\" to sysfs\n", 287 connector->name); 288 289 if (IS_ERR(connector->kdev)) { 290 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev)); 291 return PTR_ERR(connector->kdev); 292 } 293 294 if (connector->ddc) 295 return sysfs_create_link(&connector->kdev->kobj, 296 &connector->ddc->dev.kobj, "ddc"); 297 return 0; 298 } 299 300 void drm_sysfs_connector_remove(struct drm_connector *connector) 301 { 302 if (!connector->kdev) 303 return; 304 305 if (connector->ddc) 306 sysfs_remove_link(&connector->kdev->kobj, "ddc"); 307 308 DRM_DEBUG("removing \"%s\" from sysfs\n", 309 connector->name); 310 311 device_unregister(connector->kdev); 312 connector->kdev = NULL; 313 } 314 315 void drm_sysfs_lease_event(struct drm_device *dev) 316 { 317 char *event_string = "LEASE=1"; 318 char *envp[] = { event_string, NULL }; 319 320 DRM_DEBUG("generating lease event\n"); 321 322 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 323 } 324 325 /** 326 * drm_sysfs_hotplug_event - generate a DRM uevent 327 * @dev: DRM device 328 * 329 * Send a uevent for the DRM device specified by @dev. Currently we only 330 * set HOTPLUG=1 in the uevent environment, but this could be expanded to 331 * deal with other types of events. 332 * 333 * Any new uapi should be using the drm_sysfs_connector_status_event() 334 * for uevents on connector status change. 335 */ 336 void drm_sysfs_hotplug_event(struct drm_device *dev) 337 { 338 char *event_string = "HOTPLUG=1"; 339 char *envp[] = { event_string, NULL }; 340 341 DRM_DEBUG("generating hotplug event\n"); 342 343 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 344 } 345 EXPORT_SYMBOL(drm_sysfs_hotplug_event); 346 347 /** 348 * drm_sysfs_connector_status_event - generate a DRM uevent for connector 349 * property status change 350 * @connector: connector on which property status changed 351 * @property: connector property whose status changed. 352 * 353 * Send a uevent for the DRM device specified by @dev. Currently we 354 * set HOTPLUG=1 and connector id along with the attached property id 355 * related to the status change. 356 */ 357 void drm_sysfs_connector_status_event(struct drm_connector *connector, 358 struct drm_property *property) 359 { 360 struct drm_device *dev = connector->dev; 361 char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21]; 362 char *envp[4] = { hotplug_str, conn_id, prop_id, NULL }; 363 364 WARN_ON(!drm_mode_obj_find_prop_id(&connector->base, 365 property->base.id)); 366 367 snprintf(conn_id, ARRAY_SIZE(conn_id), 368 "CONNECTOR=%u", connector->base.id); 369 snprintf(prop_id, ARRAY_SIZE(prop_id), 370 "PROPERTY=%u", property->base.id); 371 372 DRM_DEBUG("generating connector status event\n"); 373 374 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 375 } 376 EXPORT_SYMBOL(drm_sysfs_connector_status_event); 377 378 static void drm_sysfs_release(struct device *dev) 379 { 380 kfree(dev); 381 } 382 383 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) 384 { 385 const char *minor_str; 386 struct device *kdev; 387 int r; 388 389 if (minor->type == DRM_MINOR_RENDER) 390 minor_str = "renderD%d"; 391 else 392 minor_str = "card%d"; 393 394 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); 395 if (!kdev) 396 return ERR_PTR(-ENOMEM); 397 398 device_initialize(kdev); 399 kdev->devt = MKDEV(DRM_MAJOR, minor->index); 400 kdev->class = drm_class; 401 kdev->type = &drm_sysfs_device_minor; 402 kdev->parent = minor->dev->dev; 403 kdev->release = drm_sysfs_release; 404 dev_set_drvdata(kdev, minor); 405 406 r = dev_set_name(kdev, minor_str, minor->index); 407 if (r < 0) 408 goto err_free; 409 410 return kdev; 411 412 err_free: 413 put_device(kdev); 414 return ERR_PTR(r); 415 } 416 417 /** 418 * drm_class_device_register - register new device with the DRM sysfs class 419 * @dev: device to register 420 * 421 * Registers a new &struct device within the DRM sysfs class. Essentially only 422 * used by ttm to have a place for its global settings. Drivers should never use 423 * this. 424 */ 425 int drm_class_device_register(struct device *dev) 426 { 427 if (!drm_class || IS_ERR(drm_class)) 428 return -ENOENT; 429 430 dev->class = drm_class; 431 return device_register(dev); 432 } 433 EXPORT_SYMBOL_GPL(drm_class_device_register); 434 435 /** 436 * drm_class_device_unregister - unregister device with the DRM sysfs class 437 * @dev: device to unregister 438 * 439 * Unregisters a &struct device from the DRM sysfs class. Essentially only used 440 * by ttm to have a place for its global settings. Drivers should never use 441 * this. 442 */ 443 void drm_class_device_unregister(struct device *dev) 444 { 445 return device_unregister(dev); 446 } 447 EXPORT_SYMBOL_GPL(drm_class_device_unregister); 448