drm_sysfs.c 11 KB

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