1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include <linux/ctype.h>
33#include <linux/list.h>
34#include <linux/slab.h>
35#include <linux/export.h>
36#include <linux/dma-fence.h>
37#include <drm/drmP.h>
38#include <drm/drm_crtc.h>
39#include <drm/drm_edid.h>
40#include <drm/drm_fourcc.h>
41#include <drm/drm_modeset_lock.h>
42#include <drm/drm_atomic.h>
43#include <drm/drm_auth.h>
44#include <drm/drm_debugfs_crc.h>
45
46#include "drm_crtc_internal.h"
47#include "drm_internal.h"
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx)
82{
83 struct drm_crtc *crtc;
84
85 drm_for_each_crtc(crtc, dev)
86 if (idx == crtc->index)
87 return crtc;
88
89 return NULL;
90}
91EXPORT_SYMBOL(drm_crtc_from_index);
92
93
94
95
96
97
98
99
100
101
102int drm_crtc_force_disable(struct drm_crtc *crtc)
103{
104 struct drm_mode_set set = {
105 .crtc = crtc,
106 };
107
108 WARN_ON(drm_drv_uses_atomic_modeset(crtc->dev));
109
110 return drm_mode_set_config_internal(&set);
111}
112EXPORT_SYMBOL(drm_crtc_force_disable);
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127int drm_crtc_force_disable_all(struct drm_device *dev)
128{
129 struct drm_crtc *crtc;
130 int ret = 0;
131
132 drm_modeset_lock_all(dev);
133 drm_for_each_crtc(crtc, dev)
134 if (crtc->enabled) {
135 ret = drm_crtc_force_disable(crtc);
136 if (ret)
137 goto out;
138 }
139out:
140 drm_modeset_unlock_all(dev);
141 return ret;
142}
143EXPORT_SYMBOL(drm_crtc_force_disable_all);
144
145static unsigned int drm_num_crtcs(struct drm_device *dev)
146{
147 unsigned int num = 0;
148 struct drm_crtc *tmp;
149
150 drm_for_each_crtc(tmp, dev) {
151 num++;
152 }
153
154 return num;
155}
156
157int drm_crtc_register_all(struct drm_device *dev)
158{
159 struct drm_crtc *crtc;
160 int ret = 0;
161
162 drm_for_each_crtc(crtc, dev) {
163 if (drm_debugfs_crtc_add(crtc))
164 DRM_ERROR("Failed to initialize debugfs entry for CRTC '%s'.\n",
165 crtc->name);
166
167 if (crtc->funcs->late_register)
168 ret = crtc->funcs->late_register(crtc);
169 if (ret)
170 return ret;
171 }
172
173 return 0;
174}
175
176void drm_crtc_unregister_all(struct drm_device *dev)
177{
178 struct drm_crtc *crtc;
179
180 drm_for_each_crtc(crtc, dev) {
181 if (crtc->funcs->early_unregister)
182 crtc->funcs->early_unregister(crtc);
183 drm_debugfs_crtc_remove(crtc);
184 }
185}
186
187static int drm_crtc_crc_init(struct drm_crtc *crtc)
188{
189#ifdef CONFIG_DEBUG_FS
190 spin_lock_init(&crtc->crc.lock);
191 init_waitqueue_head(&crtc->crc.wq);
192 crtc->crc.source = kstrdup("auto", GFP_KERNEL);
193 if (!crtc->crc.source)
194 return -ENOMEM;
195#endif
196 return 0;
197}
198
199static void drm_crtc_crc_fini(struct drm_crtc *crtc)
200{
201#ifdef CONFIG_DEBUG_FS
202 kfree(crtc->crc.source);
203#endif
204}
205
206static const struct dma_fence_ops drm_crtc_fence_ops;
207
208static struct drm_crtc *fence_to_crtc(struct dma_fence *fence)
209{
210 BUG_ON(fence->ops != &drm_crtc_fence_ops);
211 return container_of(fence->lock, struct drm_crtc, fence_lock);
212}
213
214static const char *drm_crtc_fence_get_driver_name(struct dma_fence *fence)
215{
216 struct drm_crtc *crtc = fence_to_crtc(fence);
217
218 return crtc->dev->driver->name;
219}
220
221static const char *drm_crtc_fence_get_timeline_name(struct dma_fence *fence)
222{
223 struct drm_crtc *crtc = fence_to_crtc(fence);
224
225 return crtc->timeline_name;
226}
227
228static bool drm_crtc_fence_enable_signaling(struct dma_fence *fence)
229{
230 return true;
231}
232
233static const struct dma_fence_ops drm_crtc_fence_ops = {
234 .get_driver_name = drm_crtc_fence_get_driver_name,
235 .get_timeline_name = drm_crtc_fence_get_timeline_name,
236 .enable_signaling = drm_crtc_fence_enable_signaling,
237 .wait = dma_fence_default_wait,
238};
239
240struct dma_fence *drm_crtc_create_fence(struct drm_crtc *crtc)
241{
242 struct dma_fence *fence;
243
244 fence = kzalloc(sizeof(*fence), GFP_KERNEL);
245 if (!fence)
246 return NULL;
247
248 dma_fence_init(fence, &drm_crtc_fence_ops, &crtc->fence_lock,
249 crtc->fence_context, ++crtc->fence_seqno);
250
251 return fence;
252}
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
274 struct drm_plane *primary,
275 struct drm_plane *cursor,
276 const struct drm_crtc_funcs *funcs,
277 const char *name, ...)
278{
279 struct drm_mode_config *config = &dev->mode_config;
280 int ret;
281
282 WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
283 WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
284
285
286 if (WARN_ON(config->num_crtc >= 32))
287 return -EINVAL;
288
289 crtc->dev = dev;
290 crtc->funcs = funcs;
291
292 INIT_LIST_HEAD(&crtc->commit_list);
293 spin_lock_init(&crtc->commit_lock);
294
295 drm_modeset_lock_init(&crtc->mutex);
296 ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
297 if (ret)
298 return ret;
299
300 if (name) {
301 va_list ap;
302
303 va_start(ap, name);
304 crtc->name = kvasprintf(GFP_KERNEL, name, ap);
305 va_end(ap);
306 } else {
307 crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
308 drm_num_crtcs(dev));
309 }
310 if (!crtc->name) {
311 drm_mode_object_unregister(dev, &crtc->base);
312 return -ENOMEM;
313 }
314
315 crtc->fence_context = dma_fence_context_alloc(1);
316 spin_lock_init(&crtc->fence_lock);
317 snprintf(crtc->timeline_name, sizeof(crtc->timeline_name),
318 "CRTC:%d-%s", crtc->base.id, crtc->name);
319
320 crtc->base.properties = &crtc->properties;
321
322 list_add_tail(&crtc->head, &config->crtc_list);
323 crtc->index = config->num_crtc++;
324
325 crtc->primary = primary;
326 crtc->cursor = cursor;
327 if (primary && !primary->possible_crtcs)
328 primary->possible_crtcs = 1 << drm_crtc_index(crtc);
329 if (cursor && !cursor->possible_crtcs)
330 cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
331
332 ret = drm_crtc_crc_init(crtc);
333 if (ret) {
334 drm_mode_object_unregister(dev, &crtc->base);
335 return ret;
336 }
337
338 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
339 drm_object_attach_property(&crtc->base, config->prop_active, 0);
340 drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
341 drm_object_attach_property(&crtc->base,
342 config->prop_out_fence_ptr, 0);
343 }
344
345 return 0;
346}
347EXPORT_SYMBOL(drm_crtc_init_with_planes);
348
349
350
351
352
353
354
355
356
357void drm_crtc_cleanup(struct drm_crtc *crtc)
358{
359 struct drm_device *dev = crtc->dev;
360
361
362
363
364
365
366 drm_crtc_crc_fini(crtc);
367
368 kfree(crtc->gamma_store);
369 crtc->gamma_store = NULL;
370
371 drm_modeset_lock_fini(&crtc->mutex);
372
373 drm_mode_object_unregister(dev, &crtc->base);
374 list_del(&crtc->head);
375 dev->mode_config.num_crtc--;
376
377 WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
378 if (crtc->state && crtc->funcs->atomic_destroy_state)
379 crtc->funcs->atomic_destroy_state(crtc, crtc->state);
380
381 kfree(crtc->name);
382
383 memset(crtc, 0, sizeof(*crtc));
384}
385EXPORT_SYMBOL(drm_crtc_cleanup);
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400int drm_mode_getcrtc(struct drm_device *dev,
401 void *data, struct drm_file *file_priv)
402{
403 struct drm_mode_crtc *crtc_resp = data;
404 struct drm_crtc *crtc;
405
406 if (!drm_core_check_feature(dev, DRIVER_MODESET))
407 return -EINVAL;
408
409 crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id);
410 if (!crtc)
411 return -ENOENT;
412
413 crtc_resp->gamma_size = crtc->gamma_size;
414
415 drm_modeset_lock(&crtc->primary->mutex, NULL);
416 if (crtc->primary->state && crtc->primary->state->fb)
417 crtc_resp->fb_id = crtc->primary->state->fb->base.id;
418 else if (!crtc->primary->state && crtc->primary->fb)
419 crtc_resp->fb_id = crtc->primary->fb->base.id;
420 else
421 crtc_resp->fb_id = 0;
422
423 if (crtc->primary->state) {
424 crtc_resp->x = crtc->primary->state->src_x >> 16;
425 crtc_resp->y = crtc->primary->state->src_y >> 16;
426 }
427 drm_modeset_unlock(&crtc->primary->mutex);
428
429 drm_modeset_lock(&crtc->mutex, NULL);
430 if (crtc->state) {
431 if (crtc->state->enable) {
432 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
433 crtc_resp->mode_valid = 1;
434
435 } else {
436 crtc_resp->mode_valid = 0;
437 }
438 } else {
439 crtc_resp->x = crtc->x;
440 crtc_resp->y = crtc->y;
441 if (crtc->enabled) {
442 drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
443 crtc_resp->mode_valid = 1;
444
445 } else {
446 crtc_resp->mode_valid = 0;
447 }
448 }
449 drm_modeset_unlock(&crtc->mutex);
450
451 return 0;
452}
453
454static int __drm_mode_set_config_internal(struct drm_mode_set *set,
455 struct drm_modeset_acquire_ctx *ctx)
456{
457 struct drm_crtc *crtc = set->crtc;
458 struct drm_framebuffer *fb;
459 struct drm_crtc *tmp;
460 int ret;
461
462
463
464
465
466
467 drm_for_each_crtc(tmp, crtc->dev)
468 tmp->primary->old_fb = tmp->primary->fb;
469
470 fb = set->fb;
471
472 ret = crtc->funcs->set_config(set, ctx);
473 if (ret == 0) {
474 crtc->primary->crtc = crtc;
475 crtc->primary->fb = fb;
476 }
477
478 drm_for_each_crtc(tmp, crtc->dev) {
479 if (tmp->primary->fb)
480 drm_framebuffer_get(tmp->primary->fb);
481 if (tmp->primary->old_fb)
482 drm_framebuffer_put(tmp->primary->old_fb);
483 tmp->primary->old_fb = NULL;
484 }
485
486 return ret;
487}
488
489
490
491
492
493
494
495
496
497
498
499
500
501int drm_mode_set_config_internal(struct drm_mode_set *set)
502{
503 WARN_ON(drm_drv_uses_atomic_modeset(set->crtc->dev));
504
505 return __drm_mode_set_config_internal(set, NULL);
506}
507EXPORT_SYMBOL(drm_mode_set_config_internal);
508
509
510
511
512
513
514
515
516
517
518int drm_crtc_check_viewport(const struct drm_crtc *crtc,
519 int x, int y,
520 const struct drm_display_mode *mode,
521 const struct drm_framebuffer *fb)
522
523{
524 int hdisplay, vdisplay;
525
526 drm_mode_get_hv_timing(mode, &hdisplay, &vdisplay);
527
528 if (crtc->state &&
529 drm_rotation_90_or_270(crtc->primary->state->rotation))
530 swap(hdisplay, vdisplay);
531
532 return drm_framebuffer_check_src_coords(x << 16, y << 16,
533 hdisplay << 16, vdisplay << 16,
534 fb);
535}
536EXPORT_SYMBOL(drm_crtc_check_viewport);
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551int drm_mode_setcrtc(struct drm_device *dev, void *data,
552 struct drm_file *file_priv)
553{
554 struct drm_mode_config *config = &dev->mode_config;
555 struct drm_mode_crtc *crtc_req = data;
556 struct drm_crtc *crtc;
557 struct drm_connector **connector_set = NULL, *connector;
558 struct drm_framebuffer *fb = NULL;
559 struct drm_display_mode *mode = NULL;
560 struct drm_mode_set set;
561 uint32_t __user *set_connectors_ptr;
562 struct drm_modeset_acquire_ctx ctx;
563 int ret;
564 int i;
565
566 if (!drm_core_check_feature(dev, DRIVER_MODESET))
567 return -EINVAL;
568
569
570
571
572
573 if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
574 return -ERANGE;
575
576 crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id);
577 if (!crtc) {
578 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
579 return -ENOENT;
580 }
581 DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
582
583 mutex_lock(&crtc->dev->mode_config.mutex);
584 drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
585retry:
586 ret = drm_modeset_lock_all_ctx(crtc->dev, &ctx);
587 if (ret)
588 goto out;
589 if (crtc_req->mode_valid) {
590
591
592 if (crtc_req->fb_id == -1) {
593 if (!crtc->primary->fb) {
594 DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
595 ret = -EINVAL;
596 goto out;
597 }
598 fb = crtc->primary->fb;
599
600 drm_framebuffer_get(fb);
601 } else {
602 fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id);
603 if (!fb) {
604 DRM_DEBUG_KMS("Unknown FB ID%d\n",
605 crtc_req->fb_id);
606 ret = -ENOENT;
607 goto out;
608 }
609 }
610
611 mode = drm_mode_create(dev);
612 if (!mode) {
613 ret = -ENOMEM;
614 goto out;
615 }
616
617 ret = drm_mode_convert_umode(dev, mode, &crtc_req->mode);
618 if (ret) {
619 DRM_DEBUG_KMS("Invalid mode\n");
620 goto out;
621 }
622
623
624
625
626
627
628
629
630 if (!crtc->primary->format_default) {
631 ret = drm_plane_check_pixel_format(crtc->primary,
632 fb->format->format,
633 fb->modifier);
634 if (ret) {
635 struct drm_format_name_buf format_name;
636 DRM_DEBUG_KMS("Invalid pixel format %s, modifier 0x%llx\n",
637 drm_get_format_name(fb->format->format,
638 &format_name),
639 fb->modifier);
640 goto out;
641 }
642 }
643
644 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
645 mode, fb);
646 if (ret)
647 goto out;
648
649 }
650
651 if (crtc_req->count_connectors == 0 && mode) {
652 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
653 ret = -EINVAL;
654 goto out;
655 }
656
657 if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
658 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
659 crtc_req->count_connectors);
660 ret = -EINVAL;
661 goto out;
662 }
663
664 if (crtc_req->count_connectors > 0) {
665 u32 out_id;
666
667
668 if (crtc_req->count_connectors > config->num_connector) {
669 ret = -EINVAL;
670 goto out;
671 }
672
673 connector_set = kmalloc_array(crtc_req->count_connectors,
674 sizeof(struct drm_connector *),
675 GFP_KERNEL);
676 if (!connector_set) {
677 ret = -ENOMEM;
678 goto out;
679 }
680
681 for (i = 0; i < crtc_req->count_connectors; i++) {
682 connector_set[i] = NULL;
683 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
684 if (get_user(out_id, &set_connectors_ptr[i])) {
685 ret = -EFAULT;
686 goto out;
687 }
688
689 connector = drm_connector_lookup(dev, file_priv, out_id);
690 if (!connector) {
691 DRM_DEBUG_KMS("Connector id %d unknown\n",
692 out_id);
693 ret = -ENOENT;
694 goto out;
695 }
696 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
697 connector->base.id,
698 connector->name);
699
700 connector_set[i] = connector;
701 }
702 }
703
704 set.crtc = crtc;
705 set.x = crtc_req->x;
706 set.y = crtc_req->y;
707 set.mode = mode;
708 set.connectors = connector_set;
709 set.num_connectors = crtc_req->count_connectors;
710 set.fb = fb;
711 ret = __drm_mode_set_config_internal(&set, &ctx);
712
713out:
714 if (fb)
715 drm_framebuffer_put(fb);
716
717 if (connector_set) {
718 for (i = 0; i < crtc_req->count_connectors; i++) {
719 if (connector_set[i])
720 drm_connector_put(connector_set[i]);
721 }
722 }
723 kfree(connector_set);
724 drm_mode_destroy(dev, mode);
725 if (ret == -EDEADLK) {
726 ret = drm_modeset_backoff(&ctx);
727 if (!ret)
728 goto retry;
729 }
730 drm_modeset_drop_locks(&ctx);
731 drm_modeset_acquire_fini(&ctx);
732 mutex_unlock(&crtc->dev->mode_config.mutex);
733
734 return ret;
735}
736
737int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
738 struct drm_property *property,
739 uint64_t value)
740{
741 int ret = -EINVAL;
742 struct drm_crtc *crtc = obj_to_crtc(obj);
743
744 if (crtc->funcs->set_property)
745 ret = crtc->funcs->set_property(crtc, property, value);
746 if (!ret)
747 drm_object_property_set_value(obj, property, value);
748
749 return ret;
750}
751