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 sysfs_emit(buf, "%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 sysfs_emit(buf, "%s\n", drm_get_dpms_name(dpms)); 173 } 174 175 static ssize_t enabled_show(struct device *device, 176 struct device_attribute *attr, 177 char *buf) 178 { 179 struct drm_connector *connector = to_drm_connector(device); 180 bool enabled; 181 182 enabled = READ_ONCE(connector->encoder); 183 184 return sysfs_emit(buf, enabled ? "enabled\n" : "disabled\n"); 185 } 186 187 static ssize_t edid_show(struct file *filp, struct kobject *kobj, 188 struct bin_attribute *attr, char *buf, loff_t off, 189 size_t count) 190 { 191 struct device *connector_dev = kobj_to_dev(kobj); 192 struct drm_connector *connector = to_drm_connector(connector_dev); 193 unsigned char *edid; 194 size_t size; 195 ssize_t ret = 0; 196 197 mutex_lock(&connector->dev->mode_config.mutex); 198 if (!connector->edid_blob_ptr) 199 goto unlock; 200 201 edid = connector->edid_blob_ptr->data; 202 size = connector->edid_blob_ptr->length; 203 if (!edid) 204 goto unlock; 205 206 if (off >= size) 207 goto unlock; 208 209 if (off + count > size) 210 count = size - off; 211 memcpy(buf, edid + off, count); 212 213 ret = count; 214 unlock: 215 mutex_unlock(&connector->dev->mode_config.mutex); 216 217 return ret; 218 } 219 220 static ssize_t modes_show(struct device *device, 221 struct device_attribute *attr, 222 char *buf) 223 { 224 struct drm_connector *connector = to_drm_connector(device); 225 struct drm_display_mode *mode; 226 int written = 0; 227 228 mutex_lock(&connector->dev->mode_config.mutex); 229 list_for_each_entry(mode, &connector->modes, head) { 230 written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n", 231 mode->name); 232 } 233 mutex_unlock(&connector->dev->mode_config.mutex); 234 235 return written; 236 } 237 238 static DEVICE_ATTR_RW(status); 239 static DEVICE_ATTR_RO(enabled); 240 static DEVICE_ATTR_RO(dpms); 241 static DEVICE_ATTR_RO(modes); 242 243 static struct attribute *connector_dev_attrs[] = { 244 &dev_attr_status.attr, 245 &dev_attr_enabled.attr, 246 &dev_attr_dpms.attr, 247 &dev_attr_modes.attr, 248 NULL 249 }; 250 251 static struct bin_attribute edid_attr = { 252 .attr.name = "edid", 253 .attr.mode = 0444, 254 .size = 0, 255 .read = edid_show, 256 }; 257 258 static struct bin_attribute *connector_bin_attrs[] = { 259 &edid_attr, 260 NULL 261 }; 262 263 static const struct attribute_group connector_dev_group = { 264 .attrs = connector_dev_attrs, 265 .bin_attrs = connector_bin_attrs, 266 }; 267 268 static const struct attribute_group *connector_dev_groups[] = { 269 &connector_dev_group, 270 NULL 271 }; 272 273 int drm_sysfs_connector_add(struct drm_connector *connector) 274 { 275 struct drm_device *dev = connector->dev; 276 277 if (connector->kdev) 278 return 0; 279 280 connector->kdev = 281 device_create_with_groups(drm_class, dev->primary->kdev, 0, 282 connector, connector_dev_groups, 283 "card%d-%s", dev->primary->index, 284 connector->name); 285 DRM_DEBUG("adding \"%s\" to sysfs\n", 286 connector->name); 287 288 if (IS_ERR(connector->kdev)) { 289 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev)); 290 return PTR_ERR(connector->kdev); 291 } 292 293 if (connector->ddc) 294 return sysfs_create_link(&connector->kdev->kobj, 295 &connector->ddc->dev.kobj, "ddc"); 296 return 0; 297 } 298 299 void drm_sysfs_connector_remove(struct drm_connector *connector) 300 { 301 if (!connector->kdev) 302 return; 303 304 if (connector->ddc) 305 sysfs_remove_link(&connector->kdev->kobj, "ddc"); 306 307 DRM_DEBUG("removing \"%s\" from sysfs\n", 308 connector->name); 309 310 device_unregister(connector->kdev); 311 connector->kdev = NULL; 312 } 313 314 void drm_sysfs_lease_event(struct drm_device *dev) 315 { 316 char *event_string = "LEASE=1"; 317 char *envp[] = { event_string, NULL }; 318 319 DRM_DEBUG("generating lease event\n"); 320 321 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 322 } 323 324 /** 325 * drm_sysfs_hotplug_event - generate a DRM uevent 326 * @dev: DRM device 327 * 328 * Send a uevent for the DRM device specified by @dev. Currently we only 329 * set HOTPLUG=1 in the uevent environment, but this could be expanded to 330 * deal with other types of events. 331 * 332 * Any new uapi should be using the drm_sysfs_connector_status_event() 333 * for uevents on connector status change. 334 */ 335 void drm_sysfs_hotplug_event(struct drm_device *dev) 336 { 337 char *event_string = "HOTPLUG=1"; 338 char *envp[] = { event_string, NULL }; 339 340 DRM_DEBUG("generating hotplug event\n"); 341 342 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 343 } 344 EXPORT_SYMBOL(drm_sysfs_hotplug_event); 345 346 /** 347 * drm_sysfs_connector_status_event - generate a DRM uevent for connector 348 * property status change 349 * @connector: connector on which property status changed 350 * @property: connector property whose status changed. 351 * 352 * Send a uevent for the DRM device specified by @dev. Currently we 353 * set HOTPLUG=1 and connector id along with the attached property id 354 * related to the status change. 355 */ 356 void drm_sysfs_connector_status_event(struct drm_connector *connector, 357 struct drm_property *property) 358 { 359 struct drm_device *dev = connector->dev; 360 char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21]; 361 char *envp[4] = { hotplug_str, conn_id, prop_id, NULL }; 362 363 WARN_ON(!drm_mode_obj_find_prop_id(&connector->base, 364 property->base.id)); 365 366 snprintf(conn_id, ARRAY_SIZE(conn_id), 367 "CONNECTOR=%u", connector->base.id); 368 snprintf(prop_id, ARRAY_SIZE(prop_id), 369 "PROPERTY=%u", property->base.id); 370 371 DRM_DEBUG("generating connector status event\n"); 372 373 kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 374 } 375 EXPORT_SYMBOL(drm_sysfs_connector_status_event); 376 377 static void drm_sysfs_release(struct device *dev) 378 { 379 kfree(dev); 380 } 381 382 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) 383 { 384 const char *minor_str; 385 struct device *kdev; 386 int r; 387 388 if (minor->type == DRM_MINOR_RENDER) 389 minor_str = "renderD%d"; 390 else 391 minor_str = "card%d"; 392 393 kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); 394 if (!kdev) 395 return ERR_PTR(-ENOMEM); 396 397 device_initialize(kdev); 398 kdev->devt = MKDEV(DRM_MAJOR, minor->index); 399 kdev->class = drm_class; 400 kdev->type = &drm_sysfs_device_minor; 401 kdev->parent = minor->dev->dev; 402 kdev->release = drm_sysfs_release; 403 dev_set_drvdata(kdev, minor); 404 405 r = dev_set_name(kdev, minor_str, minor->index); 406 if (r < 0) 407 goto err_free; 408 409 return kdev; 410 411 err_free: 412 put_device(kdev); 413 return ERR_PTR(r); 414 } 415 416 /** 417 * drm_class_device_register - register new device with the DRM sysfs class 418 * @dev: device to register 419 * 420 * Registers a new &struct device within the DRM sysfs class. Essentially only 421 * used by ttm to have a place for its global settings. Drivers should never use 422 * this. 423 */ 424 int drm_class_device_register(struct device *dev) 425 { 426 if (!drm_class || IS_ERR(drm_class)) 427 return -ENOENT; 428 429 dev->class = drm_class; 430 return device_register(dev); 431 } 432 EXPORT_SYMBOL_GPL(drm_class_device_register); 433 434 /** 435 * drm_class_device_unregister - unregister device with the DRM sysfs class 436 * @dev: device to unregister 437 * 438 * Unregisters a &struct device from the DRM sysfs class. Essentially only used 439 * by ttm to have a place for its global settings. Drivers should never use 440 * this. 441 */ 442 void drm_class_device_unregister(struct device *dev) 443 { 444 return device_unregister(dev); 445 } 446 EXPORT_SYMBOL_GPL(drm_class_device_unregister); 447