Commit | Line | Data |
---|---|---|
55716d26 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
0650fd58 | 2 | |
1da177e4 LT |
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. | |
1da177e4 LT |
11 | */ |
12 | ||
48c429c6 | 13 | #include <linux/acpi.h> |
c5c51b24 | 14 | #include <linux/component.h> |
1da177e4 | 15 | #include <linux/device.h> |
1da177e4 | 16 | #include <linux/err.h> |
2d1a8a48 | 17 | #include <linux/export.h> |
0500c04e | 18 | #include <linux/gfp.h> |
e1a29c6c | 19 | #include <linux/i2c.h> |
0500c04e | 20 | #include <linux/kdev_t.h> |
c5c51b24 | 21 | #include <linux/property.h> |
0500c04e SR |
22 | #include <linux/slab.h> |
23 | ||
7428ff70 | 24 | #include <drm/drm_accel.h> |
0500c04e SR |
25 | #include <drm/drm_connector.h> |
26 | #include <drm/drm_device.h> | |
27 | #include <drm/drm_file.h> | |
28 | #include <drm/drm_modes.h> | |
29 | #include <drm/drm_print.h> | |
30 | #include <drm/drm_property.h> | |
760285e7 | 31 | #include <drm/drm_sysfs.h> |
0500c04e | 32 | |
67d0ec4e | 33 | #include "drm_internal.h" |
6fe2ce06 | 34 | #include "drm_crtc_internal.h" |
1da177e4 | 35 | |
5bdebb18 DA |
36 | #define to_drm_minor(d) dev_get_drvdata(d) |
37 | #define to_drm_connector(d) dev_get_drvdata(d) | |
e8b962b6 | 38 | |
e2271704 DV |
39 | /** |
40 | * DOC: overview | |
41 | * | |
42 | * DRM provides very little additional support to drivers for sysfs | |
43 | * interactions, beyond just all the standard stuff. Drivers who want to expose | |
44 | * additional sysfs properties and property groups can attach them at either | |
45 | * &drm_device.dev or &drm_connector.kdev. | |
46 | * | |
47 | * Registration is automatically handled when calling drm_dev_register(), or | |
48 | * drm_connector_register() in case of hot-plugged connectors. Unregistration is | |
49 | * also automatically handled by drm_dev_unregister() and | |
50 | * drm_connector_unregister(). | |
51 | */ | |
52 | ||
08e4d534 TH |
53 | static struct device_type drm_sysfs_device_minor = { |
54 | .name = "drm_minor" | |
55 | }; | |
56 | ||
331de7db HG |
57 | static struct device_type drm_sysfs_device_connector = { |
58 | .name = "drm_connector", | |
59 | }; | |
60 | ||
fcc90213 DH |
61 | struct class *drm_class; |
62 | ||
48c429c6 HG |
63 | #ifdef CONFIG_ACPI |
64 | static bool drm_connector_acpi_bus_match(struct device *dev) | |
65 | { | |
66 | return dev->type == &drm_sysfs_device_connector; | |
67 | } | |
68 | ||
69 | static struct acpi_device *drm_connector_acpi_find_companion(struct device *dev) | |
70 | { | |
71 | struct drm_connector *connector = to_drm_connector(dev); | |
72 | ||
73 | return to_acpi_device_node(connector->fwnode); | |
74 | } | |
75 | ||
76 | static struct acpi_bus_type drm_connector_acpi_bus = { | |
77 | .name = "drm_connector", | |
78 | .match = drm_connector_acpi_bus_match, | |
79 | .find_companion = drm_connector_acpi_find_companion, | |
80 | }; | |
81 | ||
82 | static void drm_sysfs_acpi_register(void) | |
83 | { | |
84 | register_acpi_bus_type(&drm_connector_acpi_bus); | |
85 | } | |
86 | ||
87 | static void drm_sysfs_acpi_unregister(void) | |
88 | { | |
89 | unregister_acpi_bus_type(&drm_connector_acpi_bus); | |
90 | } | |
91 | #else | |
92 | static void drm_sysfs_acpi_register(void) { } | |
93 | static void drm_sysfs_acpi_unregister(void) { } | |
94 | #endif | |
95 | ||
ff62b8e6 | 96 | static char *drm_devnode(const struct device *dev, umode_t *mode) |
02200d06 KS |
97 | { |
98 | return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev)); | |
99 | } | |
100 | ||
c5c51b24 WC |
101 | static int typec_connector_bind(struct device *dev, |
102 | struct device *typec_connector, void *data) | |
103 | { | |
104 | int ret; | |
105 | ||
106 | ret = sysfs_create_link(&dev->kobj, &typec_connector->kobj, "typec_connector"); | |
107 | if (ret) | |
108 | return ret; | |
109 | ||
110 | ret = sysfs_create_link(&typec_connector->kobj, &dev->kobj, "drm_connector"); | |
111 | if (ret) | |
112 | sysfs_remove_link(&dev->kobj, "typec_connector"); | |
113 | ||
114 | return ret; | |
115 | } | |
116 | ||
117 | static void typec_connector_unbind(struct device *dev, | |
118 | struct device *typec_connector, void *data) | |
119 | { | |
120 | sysfs_remove_link(&typec_connector->kobj, "drm_connector"); | |
121 | sysfs_remove_link(&dev->kobj, "typec_connector"); | |
122 | } | |
123 | ||
124 | static const struct component_ops typec_connector_ops = { | |
125 | .bind = typec_connector_bind, | |
126 | .unbind = typec_connector_unbind, | |
127 | }; | |
128 | ||
82d5e73f | 129 | static CLASS_ATTR_STRING(version, S_IRUGO, "drm 1.1.0 20060810"); |
1da177e4 LT |
130 | |
131 | /** | |
fcc90213 DH |
132 | * drm_sysfs_init - initialize sysfs helpers |
133 | * | |
134 | * This is used to create the DRM class, which is the implicit parent of any | |
135 | * other top-level DRM sysfs objects. | |
1da177e4 | 136 | * |
fcc90213 | 137 | * You must call drm_sysfs_destroy() to release the allocated resources. |
1da177e4 | 138 | * |
fcc90213 | 139 | * Return: 0 on success, negative error code on failure. |
1da177e4 | 140 | */ |
fcc90213 | 141 | int drm_sysfs_init(void) |
1da177e4 | 142 | { |
24f73c92 | 143 | int err; |
0650fd58 | 144 | |
1aaba11d | 145 | drm_class = class_create("drm"); |
fcc90213 DH |
146 | if (IS_ERR(drm_class)) |
147 | return PTR_ERR(drm_class); | |
e8b962b6 | 148 | |
fcc90213 DH |
149 | err = class_create_file(drm_class, &class_attr_version.attr); |
150 | if (err) { | |
151 | class_destroy(drm_class); | |
152 | drm_class = NULL; | |
153 | return err; | |
154 | } | |
24f73c92 | 155 | |
fcc90213 | 156 | drm_class->devnode = drm_devnode; |
48c429c6 HG |
157 | |
158 | drm_sysfs_acpi_register(); | |
fcc90213 | 159 | return 0; |
1da177e4 LT |
160 | } |
161 | ||
162 | /** | |
e8b962b6 | 163 | * drm_sysfs_destroy - destroys DRM class |
1da177e4 | 164 | * |
e8b962b6 | 165 | * Destroy the DRM device class. |
1da177e4 | 166 | */ |
e8b962b6 | 167 | void drm_sysfs_destroy(void) |
1da177e4 | 168 | { |
26b91ae4 | 169 | if (IS_ERR_OR_NULL(drm_class)) |
1da177e4 | 170 | return; |
48c429c6 | 171 | drm_sysfs_acpi_unregister(); |
0933e2d9 | 172 | class_remove_file(drm_class, &class_attr_version.attr); |
e8b962b6 | 173 | class_destroy(drm_class); |
49099c49 | 174 | drm_class = NULL; |
1da177e4 LT |
175 | } |
176 | ||
331de7db HG |
177 | static void drm_sysfs_release(struct device *dev) |
178 | { | |
179 | kfree(dev); | |
180 | } | |
181 | ||
f453ba04 DA |
182 | /* |
183 | * Connector properties | |
184 | */ | |
c484f02d | 185 | static ssize_t status_store(struct device *device, |
f453ba04 | 186 | struct device_attribute *attr, |
c484f02d | 187 | const char *buf, size_t count) |
f453ba04 DA |
188 | { |
189 | struct drm_connector *connector = to_drm_connector(device); | |
c484f02d | 190 | struct drm_device *dev = connector->dev; |
ed293f77 | 191 | enum drm_connector_force old_force; |
007c80a5 CW |
192 | int ret; |
193 | ||
c484f02d | 194 | ret = mutex_lock_interruptible(&dev->mode_config.mutex); |
007c80a5 CW |
195 | if (ret) |
196 | return ret; | |
f453ba04 | 197 | |
ed293f77 | 198 | old_force = connector->force; |
c484f02d | 199 | |
ed293f77 | 200 | if (sysfs_streq(buf, "detect")) |
c484f02d | 201 | connector->force = 0; |
ed293f77 | 202 | else if (sysfs_streq(buf, "on")) |
c484f02d | 203 | connector->force = DRM_FORCE_ON; |
ed293f77 | 204 | else if (sysfs_streq(buf, "on-digital")) |
c484f02d | 205 | connector->force = DRM_FORCE_ON_DIGITAL; |
ed293f77 | 206 | else if (sysfs_streq(buf, "off")) |
c484f02d | 207 | connector->force = DRM_FORCE_OFF; |
ed293f77 | 208 | else |
c484f02d CW |
209 | ret = -EINVAL; |
210 | ||
ed293f77 DV |
211 | if (old_force != connector->force || !connector->force) { |
212 | DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force updated from %d to %d or reprobing\n", | |
c484f02d CW |
213 | connector->base.id, |
214 | connector->name, | |
ed293f77 | 215 | old_force, connector->force); |
c484f02d | 216 | |
ed293f77 DV |
217 | connector->funcs->fill_modes(connector, |
218 | dev->mode_config.max_width, | |
219 | dev->mode_config.max_height); | |
c484f02d CW |
220 | } |
221 | ||
222 | mutex_unlock(&dev->mode_config.mutex); | |
223 | ||
38d8571d | 224 | return ret ? ret : count; |
c484f02d CW |
225 | } |
226 | ||
227 | static ssize_t status_show(struct device *device, | |
228 | struct device_attribute *attr, | |
229 | char *buf) | |
230 | { | |
231 | struct drm_connector *connector = to_drm_connector(device); | |
4eb9b945 DV |
232 | enum drm_connector_status status; |
233 | ||
234 | status = READ_ONCE(connector->status); | |
007c80a5 | 235 | |
835bc483 TT |
236 | return sysfs_emit(buf, "%s\n", |
237 | drm_get_connector_status_name(status)); | |
f453ba04 DA |
238 | } |
239 | ||
240 | static ssize_t dpms_show(struct device *device, | |
241 | struct device_attribute *attr, | |
242 | char *buf) | |
243 | { | |
244 | struct drm_connector *connector = to_drm_connector(device); | |
621bd0f6 | 245 | int dpms; |
f453ba04 | 246 | |
621bd0f6 | 247 | dpms = READ_ONCE(connector->dpms); |
f453ba04 | 248 | |
835bc483 | 249 | return sysfs_emit(buf, "%s\n", drm_get_dpms_name(dpms)); |
f453ba04 DA |
250 | } |
251 | ||
252 | static ssize_t enabled_show(struct device *device, | |
253 | struct device_attribute *attr, | |
254 | char *buf) | |
255 | { | |
256 | struct drm_connector *connector = to_drm_connector(device); | |
4eb9b945 DV |
257 | bool enabled; |
258 | ||
259 | enabled = READ_ONCE(connector->encoder); | |
f453ba04 | 260 | |
835bc483 | 261 | return sysfs_emit(buf, enabled ? "enabled\n" : "disabled\n"); |
f453ba04 DA |
262 | } |
263 | ||
2c3c8bea CW |
264 | static ssize_t edid_show(struct file *filp, struct kobject *kobj, |
265 | struct bin_attribute *attr, char *buf, loff_t off, | |
266 | size_t count) | |
f453ba04 | 267 | { |
d122cbf1 | 268 | struct device *connector_dev = kobj_to_dev(kobj); |
f453ba04 DA |
269 | struct drm_connector *connector = to_drm_connector(connector_dev); |
270 | unsigned char *edid; | |
271 | size_t size; | |
a48a62bc | 272 | ssize_t ret = 0; |
f453ba04 | 273 | |
a48a62bc | 274 | mutex_lock(&connector->dev->mode_config.mutex); |
f453ba04 | 275 | if (!connector->edid_blob_ptr) |
a48a62bc | 276 | goto unlock; |
f453ba04 DA |
277 | |
278 | edid = connector->edid_blob_ptr->data; | |
279 | size = connector->edid_blob_ptr->length; | |
280 | if (!edid) | |
a48a62bc | 281 | goto unlock; |
f453ba04 DA |
282 | |
283 | if (off >= size) | |
a48a62bc | 284 | goto unlock; |
f453ba04 DA |
285 | |
286 | if (off + count > size) | |
287 | count = size - off; | |
288 | memcpy(buf, edid + off, count); | |
289 | ||
a48a62bc DV |
290 | ret = count; |
291 | unlock: | |
292 | mutex_unlock(&connector->dev->mode_config.mutex); | |
293 | ||
294 | return ret; | |
f453ba04 DA |
295 | } |
296 | ||
297 | static ssize_t modes_show(struct device *device, | |
298 | struct device_attribute *attr, | |
299 | char *buf) | |
300 | { | |
301 | struct drm_connector *connector = to_drm_connector(device); | |
302 | struct drm_display_mode *mode; | |
303 | int written = 0; | |
304 | ||
a48a62bc | 305 | mutex_lock(&connector->dev->mode_config.mutex); |
f453ba04 | 306 | list_for_each_entry(mode, &connector->modes, head) { |
9b9f2219 | 307 | written += scnprintf(buf + written, PAGE_SIZE - written, "%s\n", |
f453ba04 DA |
308 | mode->name); |
309 | } | |
a48a62bc | 310 | mutex_unlock(&connector->dev->mode_config.mutex); |
f453ba04 DA |
311 | |
312 | return written; | |
313 | } | |
314 | ||
f0038cff WC |
315 | static ssize_t connector_id_show(struct device *device, |
316 | struct device_attribute *attr, | |
317 | char *buf) | |
318 | { | |
319 | struct drm_connector *connector = to_drm_connector(device); | |
320 | ||
321 | return sysfs_emit(buf, "%d\n", connector->base.id); | |
322 | } | |
323 | ||
c484f02d | 324 | static DEVICE_ATTR_RW(status); |
335f1a62 TI |
325 | static DEVICE_ATTR_RO(enabled); |
326 | static DEVICE_ATTR_RO(dpms); | |
327 | static DEVICE_ATTR_RO(modes); | |
f0038cff | 328 | static DEVICE_ATTR_RO(connector_id); |
335f1a62 TI |
329 | |
330 | static struct attribute *connector_dev_attrs[] = { | |
331 | &dev_attr_status.attr, | |
332 | &dev_attr_enabled.attr, | |
333 | &dev_attr_dpms.attr, | |
334 | &dev_attr_modes.attr, | |
f0038cff | 335 | &dev_attr_connector_id.attr, |
335f1a62 | 336 | NULL |
f453ba04 DA |
337 | }; |
338 | ||
f453ba04 DA |
339 | static struct bin_attribute edid_attr = { |
340 | .attr.name = "edid", | |
e36ebaf4 | 341 | .attr.mode = 0444, |
7466f4cc | 342 | .size = 0, |
f453ba04 DA |
343 | .read = edid_show, |
344 | }; | |
345 | ||
335f1a62 TI |
346 | static struct bin_attribute *connector_bin_attrs[] = { |
347 | &edid_attr, | |
348 | NULL | |
349 | }; | |
350 | ||
351 | static const struct attribute_group connector_dev_group = { | |
352 | .attrs = connector_dev_attrs, | |
353 | .bin_attrs = connector_bin_attrs, | |
354 | }; | |
355 | ||
335f1a62 TI |
356 | static const struct attribute_group *connector_dev_groups[] = { |
357 | &connector_dev_group, | |
335f1a62 TI |
358 | NULL |
359 | }; | |
360 | ||
f453ba04 DA |
361 | int drm_sysfs_connector_add(struct drm_connector *connector) |
362 | { | |
363 | struct drm_device *dev = connector->dev; | |
331de7db HG |
364 | struct device *kdev; |
365 | int r; | |
f453ba04 | 366 | |
5bdebb18 DA |
367 | if (connector->kdev) |
368 | return 0; | |
f453ba04 | 369 | |
331de7db HG |
370 | kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); |
371 | if (!kdev) | |
372 | return -ENOMEM; | |
373 | ||
374 | device_initialize(kdev); | |
375 | kdev->class = drm_class; | |
376 | kdev->type = &drm_sysfs_device_connector; | |
377 | kdev->parent = dev->primary->kdev; | |
378 | kdev->groups = connector_dev_groups; | |
379 | kdev->release = drm_sysfs_release; | |
380 | dev_set_drvdata(kdev, connector); | |
381 | ||
382 | r = dev_set_name(kdev, "card%d-%s", dev->primary->index, connector->name); | |
383 | if (r) | |
384 | goto err_free; | |
385 | ||
f453ba04 | 386 | DRM_DEBUG("adding \"%s\" to sysfs\n", |
25933820 | 387 | connector->name); |
f453ba04 | 388 | |
331de7db HG |
389 | r = device_add(kdev); |
390 | if (r) { | |
391 | drm_err(dev, "failed to register connector device: %d\n", r); | |
392 | goto err_free; | |
f453ba04 DA |
393 | } |
394 | ||
331de7db HG |
395 | connector->kdev = kdev; |
396 | ||
c5c51b24 WC |
397 | if (dev_fwnode(kdev)) { |
398 | r = component_add(kdev, &typec_connector_ops); | |
399 | if (r) | |
400 | drm_err(dev, "failed to add component to create link to typec connector\n"); | |
401 | } | |
402 | ||
f453ba04 | 403 | return 0; |
331de7db HG |
404 | |
405 | err_free: | |
406 | put_device(kdev); | |
407 | return r; | |
f453ba04 | 408 | } |
f453ba04 | 409 | |
21b6c281 | 410 | int drm_sysfs_connector_add_late(struct drm_connector *connector) |
f453ba04 | 411 | { |
21b6c281 VS |
412 | if (connector->ddc) |
413 | return sysfs_create_link(&connector->kdev->kobj, | |
414 | &connector->ddc->dev.kobj, "ddc"); | |
415 | ||
416 | return 0; | |
417 | } | |
e1a29c6c | 418 | |
21b6c281 VS |
419 | void drm_sysfs_connector_remove_early(struct drm_connector *connector) |
420 | { | |
e1a29c6c AP |
421 | if (connector->ddc) |
422 | sysfs_remove_link(&connector->kdev->kobj, "ddc"); | |
21b6c281 VS |
423 | } |
424 | ||
425 | void drm_sysfs_connector_remove(struct drm_connector *connector) | |
426 | { | |
427 | if (!connector->kdev) | |
428 | return; | |
e1a29c6c | 429 | |
c5c51b24 WC |
430 | if (dev_fwnode(connector->kdev)) |
431 | component_del(connector->kdev, &typec_connector_ops); | |
432 | ||
f453ba04 | 433 | DRM_DEBUG("removing \"%s\" from sysfs\n", |
25933820 | 434 | connector->name); |
f453ba04 | 435 | |
5bdebb18 DA |
436 | device_unregister(connector->kdev); |
437 | connector->kdev = NULL; | |
f453ba04 | 438 | } |
f453ba04 | 439 | |
ce858828 DV |
440 | void drm_sysfs_lease_event(struct drm_device *dev) |
441 | { | |
442 | char *event_string = "LEASE=1"; | |
443 | char *envp[] = { event_string, NULL }; | |
444 | ||
445 | DRM_DEBUG("generating lease event\n"); | |
446 | ||
447 | kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); | |
448 | } | |
449 | ||
f453ba04 DA |
450 | /** |
451 | * drm_sysfs_hotplug_event - generate a DRM uevent | |
452 | * @dev: DRM device | |
453 | * | |
454 | * Send a uevent for the DRM device specified by @dev. Currently we only | |
455 | * set HOTPLUG=1 in the uevent environment, but this could be expanded to | |
456 | * deal with other types of events. | |
6fe2ce06 R |
457 | * |
458 | * Any new uapi should be using the drm_sysfs_connector_status_event() | |
459 | * for uevents on connector status change. | |
f453ba04 DA |
460 | */ |
461 | void drm_sysfs_hotplug_event(struct drm_device *dev) | |
462 | { | |
463 | char *event_string = "HOTPLUG=1"; | |
464 | char *envp[] = { event_string, NULL }; | |
465 | ||
466 | DRM_DEBUG("generating hotplug event\n"); | |
467 | ||
5bdebb18 | 468 | kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); |
f453ba04 | 469 | } |
5ca58282 | 470 | EXPORT_SYMBOL(drm_sysfs_hotplug_event); |
f453ba04 | 471 | |
0d6a8c5e SS |
472 | /** |
473 | * drm_sysfs_connector_hotplug_event - generate a DRM uevent for any connector | |
474 | * change | |
475 | * @connector: connector which has changed | |
476 | * | |
477 | * Send a uevent for the DRM connector specified by @connector. This will send | |
478 | * a uevent with the properties HOTPLUG=1 and CONNECTOR. | |
479 | */ | |
480 | void drm_sysfs_connector_hotplug_event(struct drm_connector *connector) | |
481 | { | |
482 | struct drm_device *dev = connector->dev; | |
483 | char hotplug_str[] = "HOTPLUG=1", conn_id[21]; | |
484 | char *envp[] = { hotplug_str, conn_id, NULL }; | |
485 | ||
486 | snprintf(conn_id, sizeof(conn_id), | |
487 | "CONNECTOR=%u", connector->base.id); | |
488 | ||
489 | drm_dbg_kms(connector->dev, | |
490 | "[CONNECTOR:%d:%s] generating connector hotplug event\n", | |
491 | connector->base.id, connector->name); | |
492 | ||
493 | kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); | |
494 | } | |
495 | EXPORT_SYMBOL(drm_sysfs_connector_hotplug_event); | |
496 | ||
6fe2ce06 | 497 | /** |
0cf8d292 SS |
498 | * drm_sysfs_connector_property_event - generate a DRM uevent for connector |
499 | * property change | |
500 | * @connector: connector on which property changed | |
501 | * @property: connector property which has changed. | |
6fe2ce06 | 502 | * |
0cf8d292 | 503 | * Send a uevent for the specified DRM connector and property. Currently we |
6fe2ce06 | 504 | * set HOTPLUG=1 and connector id along with the attached property id |
0cf8d292 | 505 | * related to the change. |
6fe2ce06 | 506 | */ |
0cf8d292 SS |
507 | void drm_sysfs_connector_property_event(struct drm_connector *connector, |
508 | struct drm_property *property) | |
6fe2ce06 R |
509 | { |
510 | struct drm_device *dev = connector->dev; | |
511 | char hotplug_str[] = "HOTPLUG=1", conn_id[21], prop_id[21]; | |
512 | char *envp[4] = { hotplug_str, conn_id, prop_id, NULL }; | |
513 | ||
514 | WARN_ON(!drm_mode_obj_find_prop_id(&connector->base, | |
515 | property->base.id)); | |
516 | ||
517 | snprintf(conn_id, ARRAY_SIZE(conn_id), | |
518 | "CONNECTOR=%u", connector->base.id); | |
519 | snprintf(prop_id, ARRAY_SIZE(prop_id), | |
520 | "PROPERTY=%u", property->base.id); | |
521 | ||
0cf8d292 SS |
522 | drm_dbg_kms(connector->dev, |
523 | "[CONNECTOR:%d:%s] generating connector property event for [PROP:%d:%s]\n", | |
524 | connector->base.id, connector->name, | |
525 | property->base.id, property->name); | |
6fe2ce06 R |
526 | |
527 | kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); | |
528 | } | |
0cf8d292 | 529 | EXPORT_SYMBOL(drm_sysfs_connector_property_event); |
6fe2ce06 | 530 | |
e1728075 | 531 | struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) |
1da177e4 | 532 | { |
e1728075 DH |
533 | const char *minor_str; |
534 | struct device *kdev; | |
760c960b | 535 | int r; |
e8b962b6 | 536 | |
e1728075 DH |
537 | kdev = kzalloc(sizeof(*kdev), GFP_KERNEL); |
538 | if (!kdev) | |
539 | return ERR_PTR(-ENOMEM); | |
540 | ||
541 | device_initialize(kdev); | |
7428ff70 OG |
542 | |
543 | if (minor->type == DRM_MINOR_ACCEL) { | |
544 | minor_str = "accel%d"; | |
545 | accel_set_device_instance_params(kdev, minor->index); | |
546 | } else { | |
547 | if (minor->type == DRM_MINOR_RENDER) | |
548 | minor_str = "renderD%d"; | |
549 | else | |
550 | minor_str = "card%d"; | |
551 | ||
552 | kdev->devt = MKDEV(DRM_MAJOR, minor->index); | |
553 | kdev->class = drm_class; | |
554 | kdev->type = &drm_sysfs_device_minor; | |
555 | } | |
556 | ||
e1728075 DH |
557 | kdev->parent = minor->dev->dev; |
558 | kdev->release = drm_sysfs_release; | |
559 | dev_set_drvdata(kdev, minor); | |
560 | ||
561 | r = dev_set_name(kdev, minor_str, minor->index); | |
760c960b | 562 | if (r < 0) |
e1728075 | 563 | goto err_free; |
760c960b | 564 | |
e1728075 | 565 | return kdev; |
1da177e4 | 566 | |
e1728075 DH |
567 | err_free: |
568 | put_device(kdev); | |
569 | return ERR_PTR(r); | |
1da177e4 | 570 | } |
327c225b | 571 | |
327c225b | 572 | /** |
e2271704 DV |
573 | * drm_class_device_register - register new device with the DRM sysfs class |
574 | * @dev: device to register | |
327c225b | 575 | * |
e2271704 DV |
576 | * Registers a new &struct device within the DRM sysfs class. Essentially only |
577 | * used by ttm to have a place for its global settings. Drivers should never use | |
578 | * this. | |
327c225b | 579 | */ |
327c225b TH |
580 | int drm_class_device_register(struct device *dev) |
581 | { | |
49099c49 DA |
582 | if (!drm_class || IS_ERR(drm_class)) |
583 | return -ENOENT; | |
584 | ||
327c225b TH |
585 | dev->class = drm_class; |
586 | return device_register(dev); | |
587 | } | |
588 | EXPORT_SYMBOL_GPL(drm_class_device_register); | |
589 | ||
e2271704 DV |
590 | /** |
591 | * drm_class_device_unregister - unregister device with the DRM sysfs class | |
592 | * @dev: device to unregister | |
593 | * | |
594 | * Unregisters a &struct device from the DRM sysfs class. Essentially only used | |
595 | * by ttm to have a place for its global settings. Drivers should never use | |
596 | * this. | |
597 | */ | |
327c225b TH |
598 | void drm_class_device_unregister(struct device *dev) |
599 | { | |
600 | return device_unregister(dev); | |
601 | } | |
602 | EXPORT_SYMBOL_GPL(drm_class_device_unregister); |