drivers/gpu/drm/drm_sysfs.c

   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 #include <linux/export.h>
  20
  21 #include <drm/drm_sysfs.h>
  22 #include <drm/drmP.h>
  23 #include "drm_internal.h"
  24
  25 #define to_drm_minor(d) dev_get_drvdata(d)
  26 #define to_drm_connector(d) dev_get_drvdata(d)
  27
  28 static struct device_type drm_sysfs_device_minor = {
  29         .name = "drm_minor"
  30 };
  31
  32 struct class *drm_class;
  33
  34 static char *drm_devnode(struct device *dev, umode_t *mode)
  35 {
  36         return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
  37 }
  38
  39 static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810");
  40
  41 /**
  42  * drm_sysfs_init - initialize sysfs helpers
  43  *
  44  * This is used to create the DRM class, which is the implicit parent of any
  45  * other top-level DRM sysfs objects.
  46  *
  47  * You must call drm_sysfs_destroy() to release the allocated resources.
  48  *
  49  * Return: 0 on success, negative error code on failure.
  50  */
  51 int drm_sysfs_init(void)
  52 {
  53         int err;
  54
  55         drm_class = class_create(THIS_MODULE, "drm");
  56         if (IS_ERR(drm_class))
  57                 return PTR_ERR(drm_class);
  58
  59         err = class_create_file(drm_class, &class_attr_version.attr);
  60         if (err) {
  61                 class_destroy(drm_class);
  62                 drm_class = NULL;
  63                 return err;
  64         }
  65
  66         drm_class->devnode = drm_devnode;
  67         return 0;
  68 }
  69
  70 /**
  71  * drm_sysfs_destroy - destroys DRM class
  72  *
  73  * Destroy the DRM device class.
  74  */
  75 void drm_sysfs_destroy(void)
  76 {
  77         if (IS_ERR_OR_NULL(drm_class))
  78                 return;
  79         class_remove_file(drm_class, &class_attr_version.attr);
  80         class_destroy(drm_class);
  81         drm_class = NULL;
  82 }
  83
  84 /*
  85  * Connector properties
  86  */
  87 static ssize_t status_store(struct device *device,
  88                            struct device_attribute *attr,
  89                            const char *buf, size_t count)
  90 {
  91         struct drm_connector *connector = to_drm_connector(device);
  92         struct drm_device *dev = connector->dev;
  93         enum drm_connector_force old_force;
  94         int ret;
  95
  96         ret = mutex_lock_interruptible(&dev->mode_config.mutex);
  97         if (ret)
  98                 return ret;
  99
 100         old_force = connector->force;
 101
 102         if (sysfs_streq(buf, "detect"))
 103                 connector->force = 0;
 104         else if (sysfs_streq(buf, "on"))
 105                 connector->force = DRM_FORCE_ON;
 106         else if (sysfs_streq(buf, "on-digital"))
 107                 connector->force = DRM_FORCE_ON_DIGITAL;
 108         else if (sysfs_streq(buf, "off"))
 109                 connector->force = DRM_FORCE_OFF;
 110         else
 111                 ret = -EINVAL;
 112
 113         if (old_force != connector->force || !connector->force) {
 114                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n",
 115                               connector->base.id,
 116                               connector->name,
 117                               old_force, connector->force);
 118
 119                 connector->funcs->fill_modes(connector,
 120                                              dev->mode_config.max_width,
 121                                              dev->mode_config.max_height);
 122         }
 123
 124         mutex_unlock(&dev->mode_config.mutex);
 125
 126         return ret ? ret : count;
 127 }
 128
 129 static ssize_t status_show(struct device *device,
 130                            struct device_attribute *attr,
 131                            char *buf)
 132 {
 133         struct drm_connector *connector = to_drm_connector(device);
 134         enum drm_connector_status status;
 135
 136         status = READ_ONCE(connector->status);
 137
 138         return snprintf(buf, PAGE_SIZE, "%s\n",
 139                         drm_get_connector_status_name(status));
 140 }
 141
 142 static ssize_t dpms_show(struct device *device,
 143                            struct device_attribute *attr,
 144                            char *buf)
 145 {
 146         struct drm_connector *connector = to_drm_connector(device);
 147         int dpms;
 148
 149         dpms = READ_ONCE(connector->dpms);
 150
 151         return snprintf(buf, PAGE_SIZE, "%s\n",
 152                         drm_get_dpms_name(dpms));
 153 }
 154
 155 static ssize_t enabled_show(struct device *device,
 156                             struct device_attribute *attr,
 157                            char *buf)
 158 {
 159         struct drm_connector *connector = to_drm_connector(device);
 160         bool enabled;
 161
 162         enabled = READ_ONCE(connector->encoder);
 163
 164         return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n");
 165 }
 166
 167 static ssize_t edid_show(struct file *filp, struct kobject *kobj,
 168                          struct bin_attribute *attr, char *buf, loff_t off,
 169                          size_t count)
 170 {
 171         struct device *connector_dev = kobj_to_dev(kobj);
 172         struct drm_connector *connector = to_drm_connector(connector_dev);
 173         unsigned char *edid;
 174         size_t size;
 175         ssize_t ret = 0;
 176
 177         mutex_lock(&connector->dev->mode_config.mutex);
 178         if (!connector->edid_blob_ptr)
 179                 goto unlock;
 180
 181         edid = connector->edid_blob_ptr->data;
 182         size = connector->edid_blob_ptr->length;
 183         if (!edid)
 184                 goto unlock;
 185
 186         if (off >= size)
 187                 goto unlock;
 188
 189         if (off + count > size)
 190                 count = size - off;
 191         memcpy(buf, edid + off, count);
 192
 193         ret = count;
 194 unlock:
 195         mutex_unlock(&connector->dev->mode_config.mutex);
 196
 197         return ret;
 198 }
 199
 200 static ssize_t modes_show(struct device *device,
 201                            struct device_attribute *attr,
 202                            char *buf)
 203 {
 204         struct drm_connector *connector = to_drm_connector(device);
 205         struct drm_display_mode *mode;
 206         int written = 0;
 207
 208         mutex_lock(&connector->dev->mode_config.mutex);
 209         list_for_each_entry(mode, &connector->modes, head) {
 210                 written += snprintf(buf + written, PAGE_SIZE - written, "%s\n",
 211                                     mode->name);
 212         }
 213         mutex_unlock(&connector->dev->mode_config.mutex);
 214
 215         return written;
 216 }
 217
 218 static DEVICE_ATTR_RW(status);
 219 static DEVICE_ATTR_RO(enabled);
 220 static DEVICE_ATTR_RO(dpms);
 221 static DEVICE_ATTR_RO(modes);
 222
 223 static struct attribute *connector_dev_attrs[] = {
 224         &dev_attr_status.attr,
 225         &dev_attr_enabled.attr,
 226         &dev_attr_dpms.attr,
 227         &dev_attr_modes.attr,
 228         NULL
 229 };
 230
 231 static struct bin_attribute edid_attr = {
 232         .attr.name = "edid",
 233         .attr.mode = 0444,
 234         .size = 0,
 235         .read = edid_show,
 236 };
 237
 238 static struct bin_attribute *connector_bin_attrs[] = {
 239         &edid_attr,
 240         NULL
 241 };
 242
 243 static const struct attribute_group connector_dev_group = {
 244         .attrs = connector_dev_attrs,
 245         .bin_attrs = connector_bin_attrs,
 246 };
 247
 248 static const struct attribute_group *connector_dev_groups[] = {
 249         &connector_dev_group,
 250         NULL
 251 };
 252
 253 /**
 254  * drm_sysfs_connector_add - add a connector to sysfs
 255  * @connector: connector to add
 256  *
 257  * Create a connector device in sysfs, along with its associated connector
 258  * properties (so far, connection status, dpms, mode list & edid) and
 259  * generate a hotplug event so userspace knows there's a new connector
 260  * available.
 261  */
 262 int drm_sysfs_connector_add(struct drm_connector *connector)
 263 {
 264         struct drm_device *dev = connector->dev;
 265
 266         if (connector->kdev)
 267                 return 0;
 268
 269         connector->kdev =
 270                 device_create_with_groups(drm_class, dev->primary->kdev, 0,
 271                                           connector, connector_dev_groups,
 272                                           "card%d-%s", dev->primary->index,
 273                                           connector->name);
 274         DRM_DEBUG("adding \"%s\" to sysfs\n",
 275                   connector->name);
 276
 277         if (IS_ERR(connector->kdev)) {
 278                 DRM_ERROR("failed to register connector device: %ld\n", PTR_ERR(connector->kdev));
 279                 return PTR_ERR(connector->kdev);
 280         }
 281
 282         /* Let userspace know we have a new connector */
 283         drm_sysfs_hotplug_event(dev);
 284
 285         return 0;
 286 }
 287
 288 /**
 289  * drm_sysfs_connector_remove - remove an connector device from sysfs
 290  * @connector: connector to remove
 291  *
 292  * Remove @connector and its associated attributes from sysfs.  Note that
 293  * the device model core will take care of sending the "remove" uevent
 294  * at this time, so we don't need to do it.
 295  *
 296  * Note:
 297  * This routine should only be called if the connector was previously
 298  * successfully registered.  If @connector hasn't been registered yet,
 299  * you'll likely see a panic somewhere deep in sysfs code when called.
 300  */
 301 void drm_sysfs_connector_remove(struct drm_connector *connector)
 302 {
 303         if (!connector->kdev)
 304                 return;
 305         DRM_DEBUG("removing \"%s\" from sysfs\n",
 306                   connector->name);
 307
 308         device_unregister(connector->kdev);
 309         connector->kdev = NULL;
 310 }
 311
 312 /**
 313  * drm_sysfs_hotplug_event - generate a DRM uevent
 314  * @dev: DRM device
 315  *
 316  * Send a uevent for the DRM device specified by @dev.  Currently we only
 317  * set HOTPLUG=1 in the uevent environment, but this could be expanded to
 318  * deal with other types of events.
 319  */
 320 void drm_sysfs_hotplug_event(struct drm_device *dev)
 321 {
 322         char *event_string = "HOTPLUG=1";
 323         char *envp[] = { event_string, NULL };
 324
 325         DRM_DEBUG("generating hotplug event\n");
 326
 327         kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
 328 }
 329 EXPORT_SYMBOL(drm_sysfs_hotplug_event);
 330
 331 static void drm_sysfs_release(struct device *dev)
 332 {
 333         kfree(dev);
 334 }
 335
 336 /**
 337  * drm_sysfs_minor_alloc() - Allocate sysfs device for given minor
 338  * @minor: minor to allocate sysfs device for
 339  *
 340  * This allocates a new sysfs device for @minor and returns it. The device is
 341  * not registered nor linked. The caller has to use device_add() and
 342  * device_del() to register and unregister it.
 343  *
 344  * Note that dev_get_drvdata() on the new device will return the minor.
 345  * However, the device does not hold a ref-count to the minor nor to the
 346  * underlying drm_device. This is unproblematic as long as you access the
 347  * private data only in sysfs callbacks. device_del() disables those
 348  * synchronously, so they cannot be called after you cleanup a minor.
 349  */
 350 struct device *drm_sysfs_minor_alloc(struct drm_minor *minor)
 351 {
 352         const char *minor_str;
 353         struct device *kdev;
 354         int r;
 355
 356         if (minor->type == DRM_MINOR_CONTROL)
 357                 minor_str = "controlD%d";
 358         else if (minor->type == DRM_MINOR_RENDER)
 359                 minor_str = "renderD%d";
 360         else
 361                 minor_str = "card%d";
 362
 363         kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
 364         if (!kdev)
 365                 return ERR_PTR(-ENOMEM);
 366
 367         device_initialize(kdev);
 368         kdev->devt = MKDEV(DRM_MAJOR, minor->index);
 369         kdev->class = drm_class;
 370         kdev->type = &drm_sysfs_device_minor;
 371         kdev->parent = minor->dev->dev;
 372         kdev->release = drm_sysfs_release;
 373         dev_set_drvdata(kdev, minor);
 374
 375         r = dev_set_name(kdev, minor_str, minor->index);
 376         if (r < 0)
 377                 goto err_free;
 378
 379         return kdev;
 380
 381 err_free:
 382         put_device(kdev);
 383         return ERR_PTR(r);
 384 }
 385
 386 /**
 387  * drm_class_device_register - Register a struct device in the drm class.
 388  *
 389  * @dev: pointer to struct device to register.
 390  *
 391  * @dev should have all relevant members pre-filled with the exception
 392  * of the class member. In particular, the device_type member must
 393  * be set.
 394  */
 395
 396 int drm_class_device_register(struct device *dev)
 397 {
 398         if (!drm_class || IS_ERR(drm_class))
 399                 return -ENOENT;
 400
 401         dev->class = drm_class;
 402         return device_register(dev);
 403 }
 404 EXPORT_SYMBOL_GPL(drm_class_device_register);
 405
 406 void drm_class_device_unregister(struct device *dev)
 407 {
 408         return device_unregister(dev);
 409 }
 410 EXPORT_SYMBOL_GPL(drm_class_device_unregister);