1 // SPDX-License-Identifier: MIT
3 * Copyright 2018 Noralf Trønnes
4 * Copyright (c) 2006-2009 Red Hat Inc.
5 * Copyright (c) 2006-2008 Intel Corporation
6 * Jesse Barnes <jesse.barnes@intel.com>
7 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
14 #include <drm/drm_atomic.h>
15 #include <drm/drm_client.h>
16 #include <drm/drm_connector.h>
17 #include <drm/drm_crtc.h>
18 #include <drm/drm_device.h>
19 #include <drm/drm_drv.h>
20 #include <drm/drm_encoder.h>
21 #include <drm/drm_print.h>
23 #include "drm_crtc_internal.h"
24 #include "drm_internal.h"
26 #define DRM_CLIENT_MAX_CLONED_CONNECTORS 8
28 struct drm_client_offset
{
32 int drm_client_modeset_create(struct drm_client_dev
*client
)
34 struct drm_device
*dev
= client
->dev
;
35 unsigned int num_crtc
= dev
->mode_config
.num_crtc
;
36 unsigned int max_connector_count
= 1;
37 struct drm_mode_set
*modeset
;
38 struct drm_crtc
*crtc
;
41 /* Add terminating zero entry to enable index less iteration */
42 client
->modesets
= kcalloc(num_crtc
+ 1, sizeof(*client
->modesets
), GFP_KERNEL
);
43 if (!client
->modesets
)
46 mutex_init(&client
->modeset_mutex
);
48 drm_for_each_crtc(crtc
, dev
)
49 client
->modesets
[i
++].crtc
= crtc
;
51 /* Cloning is only supported in the single crtc case. */
53 max_connector_count
= DRM_CLIENT_MAX_CLONED_CONNECTORS
;
55 for (modeset
= client
->modesets
; modeset
->crtc
; modeset
++) {
56 modeset
->connectors
= kcalloc(max_connector_count
,
57 sizeof(*modeset
->connectors
), GFP_KERNEL
);
58 if (!modeset
->connectors
)
65 drm_client_modeset_free(client
);
70 static void drm_client_modeset_release(struct drm_client_dev
*client
)
72 struct drm_mode_set
*modeset
;
75 drm_client_for_each_modeset(modeset
, client
) {
76 drm_mode_destroy(client
->dev
, modeset
->mode
);
80 for (i
= 0; i
< modeset
->num_connectors
; i
++) {
81 drm_connector_put(modeset
->connectors
[i
]);
82 modeset
->connectors
[i
] = NULL
;
84 modeset
->num_connectors
= 0;
88 void drm_client_modeset_free(struct drm_client_dev
*client
)
90 struct drm_mode_set
*modeset
;
92 mutex_lock(&client
->modeset_mutex
);
94 drm_client_modeset_release(client
);
96 drm_client_for_each_modeset(modeset
, client
)
97 kfree(modeset
->connectors
);
99 mutex_unlock(&client
->modeset_mutex
);
101 mutex_destroy(&client
->modeset_mutex
);
102 kfree(client
->modesets
);
105 static struct drm_mode_set
*
106 drm_client_find_modeset(struct drm_client_dev
*client
, struct drm_crtc
*crtc
)
108 struct drm_mode_set
*modeset
;
110 drm_client_for_each_modeset(modeset
, client
)
111 if (modeset
->crtc
== crtc
)
117 static struct drm_display_mode
*
118 drm_connector_get_tiled_mode(struct drm_connector
*connector
)
120 struct drm_display_mode
*mode
;
122 list_for_each_entry(mode
, &connector
->modes
, head
) {
123 if (mode
->hdisplay
== connector
->tile_h_size
&&
124 mode
->vdisplay
== connector
->tile_v_size
)
130 static struct drm_display_mode
*
131 drm_connector_fallback_non_tiled_mode(struct drm_connector
*connector
)
133 struct drm_display_mode
*mode
;
135 list_for_each_entry(mode
, &connector
->modes
, head
) {
136 if (mode
->hdisplay
== connector
->tile_h_size
&&
137 mode
->vdisplay
== connector
->tile_v_size
)
144 static struct drm_display_mode
*
145 drm_connector_has_preferred_mode(struct drm_connector
*connector
, int width
, int height
)
147 struct drm_display_mode
*mode
;
149 list_for_each_entry(mode
, &connector
->modes
, head
) {
150 if (mode
->hdisplay
> width
||
151 mode
->vdisplay
> height
)
153 if (mode
->type
& DRM_MODE_TYPE_PREFERRED
)
159 static struct drm_display_mode
*
160 drm_connector_pick_cmdline_mode(struct drm_connector
*connector
)
162 struct drm_cmdline_mode
*cmdline_mode
;
163 struct drm_display_mode
*mode
;
164 bool prefer_non_interlace
;
166 cmdline_mode
= &connector
->cmdline_mode
;
167 if (cmdline_mode
->specified
== false)
170 /* attempt to find a matching mode in the list of modes
171 * we have gotten so far, if not add a CVT mode that conforms
173 if (cmdline_mode
->rb
|| cmdline_mode
->margins
)
176 prefer_non_interlace
= !cmdline_mode
->interlace
;
178 list_for_each_entry(mode
, &connector
->modes
, head
) {
179 /* Check (optional) mode name first */
180 if (!strcmp(mode
->name
, cmdline_mode
->name
))
183 /* check width/height */
184 if (mode
->hdisplay
!= cmdline_mode
->xres
||
185 mode
->vdisplay
!= cmdline_mode
->yres
)
188 if (cmdline_mode
->refresh_specified
) {
189 if (mode
->vrefresh
!= cmdline_mode
->refresh
)
193 if (cmdline_mode
->interlace
) {
194 if (!(mode
->flags
& DRM_MODE_FLAG_INTERLACE
))
196 } else if (prefer_non_interlace
) {
197 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
203 if (prefer_non_interlace
) {
204 prefer_non_interlace
= false;
209 mode
= drm_mode_create_from_cmdline_mode(connector
->dev
, cmdline_mode
);
211 list_add(&mode
->head
, &connector
->modes
);
216 static bool drm_connector_enabled(struct drm_connector
*connector
, bool strict
)
220 if (connector
->display_info
.non_desktop
)
224 enable
= connector
->status
== connector_status_connected
;
226 enable
= connector
->status
!= connector_status_disconnected
;
231 static void drm_client_connectors_enabled(struct drm_connector
**connectors
,
232 unsigned int connector_count
,
235 bool any_enabled
= false;
236 struct drm_connector
*connector
;
239 for (i
= 0; i
< connector_count
; i
++) {
240 connector
= connectors
[i
];
241 enabled
[i
] = drm_connector_enabled(connector
, true);
242 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector
->base
.id
,
243 connector
->display_info
.non_desktop
? "non desktop" : enabled
[i
] ? "yes" : "no");
245 any_enabled
|= enabled
[i
];
251 for (i
= 0; i
< connector_count
; i
++)
252 enabled
[i
] = drm_connector_enabled(connectors
[i
], false);
255 static bool drm_client_target_cloned(struct drm_device
*dev
,
256 struct drm_connector
**connectors
,
257 unsigned int connector_count
,
258 struct drm_display_mode
**modes
,
259 struct drm_client_offset
*offsets
,
260 bool *enabled
, int width
, int height
)
263 bool can_clone
= false;
264 struct drm_display_mode
*dmt_mode
, *mode
;
266 /* only contemplate cloning in the single crtc case */
267 if (dev
->mode_config
.num_crtc
> 1)
271 for (i
= 0; i
< connector_count
; i
++) {
276 /* only contemplate cloning if more than one connector is enabled */
280 /* check the command line or if nothing common pick 1024x768 */
282 for (i
= 0; i
< connector_count
; i
++) {
285 modes
[i
] = drm_connector_pick_cmdline_mode(connectors
[i
]);
290 for (j
= 0; j
< i
; j
++) {
293 if (!drm_mode_match(modes
[j
], modes
[i
],
294 DRM_MODE_MATCH_TIMINGS
|
295 DRM_MODE_MATCH_CLOCK
|
296 DRM_MODE_MATCH_FLAGS
|
297 DRM_MODE_MATCH_3D_FLAGS
))
303 DRM_DEBUG_KMS("can clone using command line\n");
307 /* try and find a 1024x768 mode on each connector */
309 dmt_mode
= drm_mode_find_dmt(dev
, 1024, 768, 60, false);
311 for (i
= 0; i
< connector_count
; i
++) {
315 list_for_each_entry(mode
, &connectors
[i
]->modes
, head
) {
316 if (drm_mode_match(mode
, dmt_mode
,
317 DRM_MODE_MATCH_TIMINGS
|
318 DRM_MODE_MATCH_CLOCK
|
319 DRM_MODE_MATCH_FLAGS
|
320 DRM_MODE_MATCH_3D_FLAGS
))
328 DRM_DEBUG_KMS("can clone using 1024x768\n");
331 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
335 static int drm_client_get_tile_offsets(struct drm_connector
**connectors
,
336 unsigned int connector_count
,
337 struct drm_display_mode
**modes
,
338 struct drm_client_offset
*offsets
,
340 int h_idx
, int v_idx
)
342 struct drm_connector
*connector
;
344 int hoffset
= 0, voffset
= 0;
346 for (i
= 0; i
< connector_count
; i
++) {
347 connector
= connectors
[i
];
348 if (!connector
->has_tile
)
351 if (!modes
[i
] && (h_idx
|| v_idx
)) {
352 DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i
,
356 if (connector
->tile_h_loc
< h_idx
)
357 hoffset
+= modes
[i
]->hdisplay
;
359 if (connector
->tile_v_loc
< v_idx
)
360 voffset
+= modes
[i
]->vdisplay
;
362 offsets
[idx
].x
= hoffset
;
363 offsets
[idx
].y
= voffset
;
364 DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset
, voffset
, h_idx
, v_idx
);
368 static bool drm_client_target_preferred(struct drm_connector
**connectors
,
369 unsigned int connector_count
,
370 struct drm_display_mode
**modes
,
371 struct drm_client_offset
*offsets
,
372 bool *enabled
, int width
, int height
)
374 const u64 mask
= BIT_ULL(connector_count
) - 1;
375 struct drm_connector
*connector
;
376 u64 conn_configured
= 0;
378 int num_tiled_conns
= 0;
381 for (i
= 0; i
< connector_count
; i
++) {
382 if (connectors
[i
]->has_tile
&&
383 connectors
[i
]->status
== connector_status_connected
)
388 for (i
= 0; i
< connector_count
; i
++) {
389 connector
= connectors
[i
];
391 if (conn_configured
& BIT_ULL(i
))
394 if (enabled
[i
] == false) {
395 conn_configured
|= BIT_ULL(i
);
399 /* first pass over all the untiled connectors */
400 if (tile_pass
== 0 && connector
->has_tile
)
403 if (tile_pass
== 1) {
404 if (connector
->tile_h_loc
!= 0 ||
405 connector
->tile_v_loc
!= 0)
409 if (connector
->tile_h_loc
!= tile_pass
- 1 &&
410 connector
->tile_v_loc
!= tile_pass
- 1)
411 /* if this tile_pass doesn't cover any of the tiles - keep going */
415 * find the tile offsets for this pass - need to find
416 * all tiles left and above
418 drm_client_get_tile_offsets(connectors
, connector_count
, modes
, offsets
, i
,
419 connector
->tile_h_loc
, connector
->tile_v_loc
);
421 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
424 /* got for command line mode first */
425 modes
[i
] = drm_connector_pick_cmdline_mode(connector
);
427 DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n",
428 connector
->base
.id
, connector
->tile_group
? connector
->tile_group
->id
: 0);
429 modes
[i
] = drm_connector_has_preferred_mode(connector
, width
, height
);
431 /* No preferred modes, pick one off the list */
432 if (!modes
[i
] && !list_empty(&connector
->modes
)) {
433 list_for_each_entry(modes
[i
], &connector
->modes
, head
)
437 * In case of tiled mode if all tiles not present fallback to
438 * first available non tiled mode.
439 * After all tiles are present, try to find the tiled mode
440 * for all and if tiled mode not present due to fbcon size
441 * limitations, use first non tiled mode only for
442 * tile 0,0 and set to no mode for all other tiles.
444 if (connector
->has_tile
) {
445 if (num_tiled_conns
<
446 connector
->num_h_tile
* connector
->num_v_tile
||
447 (connector
->tile_h_loc
== 0 &&
448 connector
->tile_v_loc
== 0 &&
449 !drm_connector_get_tiled_mode(connector
))) {
450 DRM_DEBUG_KMS("Falling back to non tiled mode on Connector %d\n",
452 modes
[i
] = drm_connector_fallback_non_tiled_mode(connector
);
454 modes
[i
] = drm_connector_get_tiled_mode(connector
);
458 DRM_DEBUG_KMS("found mode %s\n", modes
[i
] ? modes
[i
]->name
:
460 conn_configured
|= BIT_ULL(i
);
463 if ((conn_configured
& mask
) != mask
) {
470 static bool connector_has_possible_crtc(struct drm_connector
*connector
,
471 struct drm_crtc
*crtc
)
473 struct drm_encoder
*encoder
;
475 drm_connector_for_each_possible_encoder(connector
, encoder
) {
476 if (encoder
->possible_crtcs
& drm_crtc_mask(crtc
))
483 static int drm_client_pick_crtcs(struct drm_client_dev
*client
,
484 struct drm_connector
**connectors
,
485 unsigned int connector_count
,
486 struct drm_crtc
**best_crtcs
,
487 struct drm_display_mode
**modes
,
488 int n
, int width
, int height
)
490 struct drm_device
*dev
= client
->dev
;
491 struct drm_connector
*connector
;
492 int my_score
, best_score
, score
;
493 struct drm_crtc
**crtcs
, *crtc
;
494 struct drm_mode_set
*modeset
;
497 if (n
== connector_count
)
500 connector
= connectors
[n
];
502 best_crtcs
[n
] = NULL
;
503 best_score
= drm_client_pick_crtcs(client
, connectors
, connector_count
,
504 best_crtcs
, modes
, n
+ 1, width
, height
);
505 if (modes
[n
] == NULL
)
508 crtcs
= kcalloc(connector_count
, sizeof(*crtcs
), GFP_KERNEL
);
513 if (connector
->status
== connector_status_connected
)
515 if (connector
->cmdline_mode
.specified
)
517 if (drm_connector_has_preferred_mode(connector
, width
, height
))
521 * select a crtc for this connector and then attempt to configure
522 * remaining connectors
524 drm_client_for_each_modeset(modeset
, client
) {
525 crtc
= modeset
->crtc
;
527 if (!connector_has_possible_crtc(connector
, crtc
))
530 for (o
= 0; o
< n
; o
++)
531 if (best_crtcs
[o
] == crtc
)
535 /* ignore cloning unless only a single crtc */
536 if (dev
->mode_config
.num_crtc
> 1)
539 if (!drm_mode_equal(modes
[o
], modes
[n
]))
544 memcpy(crtcs
, best_crtcs
, n
* sizeof(*crtcs
));
545 score
= my_score
+ drm_client_pick_crtcs(client
, connectors
, connector_count
,
546 crtcs
, modes
, n
+ 1, width
, height
);
547 if (score
> best_score
) {
549 memcpy(best_crtcs
, crtcs
, connector_count
* sizeof(*crtcs
));
557 /* Try to read the BIOS display configuration and use it for the initial config */
558 static bool drm_client_firmware_config(struct drm_client_dev
*client
,
559 struct drm_connector
**connectors
,
560 unsigned int connector_count
,
561 struct drm_crtc
**crtcs
,
562 struct drm_display_mode
**modes
,
563 struct drm_client_offset
*offsets
,
564 bool *enabled
, int width
, int height
)
566 unsigned int count
= min_t(unsigned int, connector_count
, BITS_PER_LONG
);
567 unsigned long conn_configured
, conn_seq
, mask
;
568 struct drm_device
*dev
= client
->dev
;
571 bool fallback
= true, ret
= true;
572 int num_connectors_enabled
= 0;
573 int num_connectors_detected
= 0;
574 int num_tiled_conns
= 0;
575 struct drm_modeset_acquire_ctx ctx
;
577 if (!drm_drv_uses_atomic_modeset(dev
))
580 save_enabled
= kcalloc(count
, sizeof(bool), GFP_KERNEL
);
584 drm_modeset_acquire_init(&ctx
, 0);
586 while (drm_modeset_lock_all_ctx(dev
, &ctx
) != 0)
587 drm_modeset_backoff(&ctx
);
589 memcpy(save_enabled
, enabled
, count
);
590 mask
= GENMASK(count
- 1, 0);
592 for (i
= 0; i
< count
; i
++) {
593 if (connectors
[i
]->has_tile
&&
594 connectors
[i
]->status
== connector_status_connected
)
598 conn_seq
= conn_configured
;
599 for (i
= 0; i
< count
; i
++) {
600 struct drm_connector
*connector
;
601 struct drm_encoder
*encoder
;
602 struct drm_crtc
*new_crtc
;
604 connector
= connectors
[i
];
606 if (conn_configured
& BIT(i
))
609 if (conn_seq
== 0 && !connector
->has_tile
)
612 if (connector
->status
== connector_status_connected
)
613 num_connectors_detected
++;
616 DRM_DEBUG_KMS("connector %s not enabled, skipping\n",
618 conn_configured
|= BIT(i
);
622 if (connector
->force
== DRM_FORCE_OFF
) {
623 DRM_DEBUG_KMS("connector %s is disabled by user, skipping\n",
629 encoder
= connector
->state
->best_encoder
;
630 if (!encoder
|| WARN_ON(!connector
->state
->crtc
)) {
631 if (connector
->force
> DRM_FORCE_OFF
)
634 DRM_DEBUG_KMS("connector %s has no encoder or crtc, skipping\n",
637 conn_configured
|= BIT(i
);
641 num_connectors_enabled
++;
643 new_crtc
= connector
->state
->crtc
;
646 * Make sure we're not trying to drive multiple connectors
647 * with a single CRTC, since our cloning support may not
650 for (j
= 0; j
< count
; j
++) {
651 if (crtcs
[j
] == new_crtc
) {
652 DRM_DEBUG_KMS("fallback: cloned configuration\n");
657 DRM_DEBUG_KMS("looking for cmdline mode on connector %s\n",
660 /* go for command line mode first */
661 modes
[i
] = drm_connector_pick_cmdline_mode(connector
);
663 /* try for preferred next */
665 DRM_DEBUG_KMS("looking for preferred mode on connector %s %d\n",
666 connector
->name
, connector
->has_tile
);
667 modes
[i
] = drm_connector_has_preferred_mode(connector
, width
, height
);
670 /* No preferred mode marked by the EDID? Are there any modes? */
671 if (!modes
[i
] && !list_empty(&connector
->modes
)) {
672 DRM_DEBUG_KMS("using first mode listed on connector %s\n",
674 modes
[i
] = list_first_entry(&connector
->modes
,
675 struct drm_display_mode
,
679 /* last resort: use current mode */
682 * IMPORTANT: We want to use the adjusted mode (i.e.
683 * after the panel fitter upscaling) as the initial
684 * config, not the input mode, which is what crtc->mode
685 * usually contains. But since our current
686 * code puts a mode derived from the post-pfit timings
687 * into crtc->mode this works out correctly.
689 * This is crtc->mode and not crtc->state->mode for the
690 * fastboot check to work correctly.
692 DRM_DEBUG_KMS("looking for current mode on connector %s\n",
694 modes
[i
] = &connector
->state
->crtc
->mode
;
697 * In case of tiled modes, if all tiles are not present
698 * then fallback to a non tiled mode.
700 if (connector
->has_tile
&&
701 num_tiled_conns
< connector
->num_h_tile
* connector
->num_v_tile
) {
702 DRM_DEBUG_KMS("Falling back to non tiled mode on Connector %d\n",
704 modes
[i
] = drm_connector_fallback_non_tiled_mode(connector
);
708 DRM_DEBUG_KMS("connector %s on [CRTC:%d:%s]: %dx%d%s\n",
710 connector
->state
->crtc
->base
.id
,
711 connector
->state
->crtc
->name
,
712 modes
[i
]->hdisplay
, modes
[i
]->vdisplay
,
713 modes
[i
]->flags
& DRM_MODE_FLAG_INTERLACE
? "i" : "");
716 conn_configured
|= BIT(i
);
719 if ((conn_configured
& mask
) != mask
&& conn_configured
!= conn_seq
)
723 * If the BIOS didn't enable everything it could, fall back to have the
724 * same user experiencing of lighting up as much as possible like the
725 * fbdev helper library.
727 if (num_connectors_enabled
!= num_connectors_detected
&&
728 num_connectors_enabled
< dev
->mode_config
.num_crtc
) {
729 DRM_DEBUG_KMS("fallback: Not all outputs enabled\n");
730 DRM_DEBUG_KMS("Enabled: %i, detected: %i\n", num_connectors_enabled
,
731 num_connectors_detected
);
737 DRM_DEBUG_KMS("Not using firmware configuration\n");
738 memcpy(enabled
, save_enabled
, count
);
742 drm_modeset_drop_locks(&ctx
);
743 drm_modeset_acquire_fini(&ctx
);
750 * drm_client_modeset_probe() - Probe for displays
751 * @client: DRM client
752 * @width: Maximum display mode width (optional)
753 * @height: Maximum display mode height (optional)
755 * This function sets up display pipelines for enabled connectors and stores the
756 * config in the client's modeset array.
759 * Zero on success or negative error code on failure.
761 int drm_client_modeset_probe(struct drm_client_dev
*client
, unsigned int width
, unsigned int height
)
763 struct drm_connector
*connector
, **connectors
= NULL
;
764 struct drm_connector_list_iter conn_iter
;
765 struct drm_device
*dev
= client
->dev
;
766 unsigned int total_modes_count
= 0;
767 struct drm_client_offset
*offsets
;
768 unsigned int connector_count
= 0;
769 struct drm_display_mode
**modes
;
770 struct drm_crtc
**crtcs
;
777 width
= dev
->mode_config
.max_width
;
779 height
= dev
->mode_config
.max_height
;
781 drm_connector_list_iter_begin(dev
, &conn_iter
);
782 drm_client_for_each_connector_iter(connector
, &conn_iter
) {
783 struct drm_connector
**tmp
;
785 tmp
= krealloc(connectors
, (connector_count
+ 1) * sizeof(*connectors
), GFP_KERNEL
);
788 goto free_connectors
;
792 drm_connector_get(connector
);
793 connectors
[connector_count
++] = connector
;
795 drm_connector_list_iter_end(&conn_iter
);
797 if (!connector_count
)
800 crtcs
= kcalloc(connector_count
, sizeof(*crtcs
), GFP_KERNEL
);
801 modes
= kcalloc(connector_count
, sizeof(*modes
), GFP_KERNEL
);
802 offsets
= kcalloc(connector_count
, sizeof(*offsets
), GFP_KERNEL
);
803 enabled
= kcalloc(connector_count
, sizeof(bool), GFP_KERNEL
);
804 if (!crtcs
|| !modes
|| !enabled
|| !offsets
) {
805 DRM_ERROR("Memory allocation failed\n");
810 mutex_lock(&client
->modeset_mutex
);
812 mutex_lock(&dev
->mode_config
.mutex
);
813 for (i
= 0; i
< connector_count
; i
++)
814 total_modes_count
+= connectors
[i
]->funcs
->fill_modes(connectors
[i
], width
, height
);
815 if (!total_modes_count
)
816 DRM_DEBUG_KMS("No connectors reported connected with modes\n");
817 drm_client_connectors_enabled(connectors
, connector_count
, enabled
);
819 if (!drm_client_firmware_config(client
, connectors
, connector_count
, crtcs
,
820 modes
, offsets
, enabled
, width
, height
)) {
821 memset(modes
, 0, connector_count
* sizeof(*modes
));
822 memset(crtcs
, 0, connector_count
* sizeof(*crtcs
));
823 memset(offsets
, 0, connector_count
* sizeof(*offsets
));
825 if (!drm_client_target_cloned(dev
, connectors
, connector_count
, modes
,
826 offsets
, enabled
, width
, height
) &&
827 !drm_client_target_preferred(connectors
, connector_count
, modes
,
828 offsets
, enabled
, width
, height
))
829 DRM_ERROR("Unable to find initial modes\n");
831 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n",
834 drm_client_pick_crtcs(client
, connectors
, connector_count
,
835 crtcs
, modes
, 0, width
, height
);
837 mutex_unlock(&dev
->mode_config
.mutex
);
839 drm_client_modeset_release(client
);
841 for (i
= 0; i
< connector_count
; i
++) {
842 struct drm_display_mode
*mode
= modes
[i
];
843 struct drm_crtc
*crtc
= crtcs
[i
];
844 struct drm_client_offset
*offset
= &offsets
[i
];
847 struct drm_mode_set
*modeset
= drm_client_find_modeset(client
, crtc
);
848 struct drm_connector
*connector
= connectors
[i
];
850 DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n",
851 mode
->name
, crtc
->base
.id
, offset
->x
, offset
->y
);
853 if (WARN_ON_ONCE(modeset
->num_connectors
== DRM_CLIENT_MAX_CLONED_CONNECTORS
||
854 (dev
->mode_config
.num_crtc
> 1 && modeset
->num_connectors
== 1))) {
859 modeset
->mode
= drm_mode_duplicate(dev
, mode
);
860 drm_connector_get(connector
);
861 modeset
->connectors
[modeset
->num_connectors
++] = connector
;
862 modeset
->x
= offset
->x
;
863 modeset
->y
= offset
->y
;
867 mutex_unlock(&client
->modeset_mutex
);
874 for (i
= 0; i
< connector_count
; i
++)
875 drm_connector_put(connectors
[i
]);
880 EXPORT_SYMBOL(drm_client_modeset_probe
);
883 * drm_client_rotation() - Check the initial rotation value
884 * @modeset: DRM modeset
885 * @rotation: Returned rotation value
887 * This function checks if the primary plane in @modeset can hw rotate
888 * to match the rotation needed on its connector.
890 * Note: Currently only 0 and 180 degrees are supported.
893 * True if the plane can do the rotation, false otherwise.
895 bool drm_client_rotation(struct drm_mode_set
*modeset
, unsigned int *rotation
)
897 struct drm_connector
*connector
= modeset
->connectors
[0];
898 struct drm_plane
*plane
= modeset
->crtc
->primary
;
899 struct drm_cmdline_mode
*cmdline
;
903 if (!modeset
->num_connectors
)
906 switch (connector
->display_info
.panel_orientation
) {
907 case DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP
:
908 *rotation
= DRM_MODE_ROTATE_180
;
910 case DRM_MODE_PANEL_ORIENTATION_LEFT_UP
:
911 *rotation
= DRM_MODE_ROTATE_90
;
913 case DRM_MODE_PANEL_ORIENTATION_RIGHT_UP
:
914 *rotation
= DRM_MODE_ROTATE_270
;
917 *rotation
= DRM_MODE_ROTATE_0
;
921 * The panel already defined the default rotation
922 * through its orientation. Whatever has been provided
923 * on the command line needs to be added to that.
925 * Unfortunately, the rotations are at different bit
926 * indices, so the math to add them up are not as
927 * trivial as they could.
929 * Reflections on the other hand are pretty trivial to deal with, a
930 * simple XOR between the two handle the addition nicely.
932 cmdline
= &connector
->cmdline_mode
;
933 if (cmdline
->specified
&& cmdline
->rotation_reflection
) {
934 unsigned int cmdline_rest
, panel_rest
;
935 unsigned int cmdline_rot
, panel_rot
;
936 unsigned int sum_rot
, sum_rest
;
938 panel_rot
= ilog2(*rotation
& DRM_MODE_ROTATE_MASK
);
939 cmdline_rot
= ilog2(cmdline
->rotation_reflection
& DRM_MODE_ROTATE_MASK
);
940 sum_rot
= (panel_rot
+ cmdline_rot
) % 4;
942 panel_rest
= *rotation
& ~DRM_MODE_ROTATE_MASK
;
943 cmdline_rest
= cmdline
->rotation_reflection
& ~DRM_MODE_ROTATE_MASK
;
944 sum_rest
= panel_rest
^ cmdline_rest
;
946 *rotation
= (1 << sum_rot
) | sum_rest
;
950 * TODO: support 90 / 270 degree hardware rotation,
951 * depending on the hardware this may require the framebuffer
952 * to be in a specific tiling format.
954 if ((*rotation
& DRM_MODE_ROTATE_MASK
) != DRM_MODE_ROTATE_180
||
955 !plane
->rotation_property
)
958 for (i
= 0; i
< plane
->rotation_property
->num_values
; i
++)
959 valid_mask
|= (1ULL << plane
->rotation_property
->values
[i
]);
961 if (!(*rotation
& valid_mask
))
966 EXPORT_SYMBOL(drm_client_rotation
);
968 static int drm_client_modeset_commit_atomic(struct drm_client_dev
*client
, bool active
)
970 struct drm_device
*dev
= client
->dev
;
971 struct drm_plane
*plane
;
972 struct drm_atomic_state
*state
;
973 struct drm_modeset_acquire_ctx ctx
;
974 struct drm_mode_set
*mode_set
;
977 drm_modeset_acquire_init(&ctx
, 0);
979 state
= drm_atomic_state_alloc(dev
);
985 state
->acquire_ctx
= &ctx
;
987 drm_for_each_plane(plane
, dev
) {
988 struct drm_plane_state
*plane_state
;
990 plane_state
= drm_atomic_get_plane_state(state
, plane
);
991 if (IS_ERR(plane_state
)) {
992 ret
= PTR_ERR(plane_state
);
996 plane_state
->rotation
= DRM_MODE_ROTATE_0
;
998 /* disable non-primary: */
999 if (plane
->type
== DRM_PLANE_TYPE_PRIMARY
)
1002 ret
= __drm_atomic_helper_disable_plane(plane
, plane_state
);
1007 drm_client_for_each_modeset(mode_set
, client
) {
1008 struct drm_plane
*primary
= mode_set
->crtc
->primary
;
1009 unsigned int rotation
;
1011 if (drm_client_rotation(mode_set
, &rotation
)) {
1012 struct drm_plane_state
*plane_state
;
1014 /* Cannot fail as we've already gotten the plane state above */
1015 plane_state
= drm_atomic_get_new_plane_state(state
, primary
);
1016 plane_state
->rotation
= rotation
;
1019 ret
= __drm_atomic_helper_set_config(mode_set
, state
);
1024 * __drm_atomic_helper_set_config() sets active when a
1025 * mode is set, unconditionally clear it if we force DPMS off
1028 struct drm_crtc
*crtc
= mode_set
->crtc
;
1029 struct drm_crtc_state
*crtc_state
= drm_atomic_get_new_crtc_state(state
, crtc
);
1031 crtc_state
->active
= false;
1035 ret
= drm_atomic_commit(state
);
1038 if (ret
== -EDEADLK
)
1041 drm_atomic_state_put(state
);
1043 drm_modeset_drop_locks(&ctx
);
1044 drm_modeset_acquire_fini(&ctx
);
1049 drm_atomic_state_clear(state
);
1050 drm_modeset_backoff(&ctx
);
1055 static int drm_client_modeset_commit_legacy(struct drm_client_dev
*client
)
1057 struct drm_device
*dev
= client
->dev
;
1058 struct drm_mode_set
*mode_set
;
1059 struct drm_plane
*plane
;
1062 drm_modeset_lock_all(dev
);
1063 drm_for_each_plane(plane
, dev
) {
1064 if (plane
->type
!= DRM_PLANE_TYPE_PRIMARY
)
1065 drm_plane_force_disable(plane
);
1067 if (plane
->rotation_property
)
1068 drm_mode_plane_set_obj_prop(plane
,
1069 plane
->rotation_property
,
1073 drm_client_for_each_modeset(mode_set
, client
) {
1074 struct drm_crtc
*crtc
= mode_set
->crtc
;
1076 if (crtc
->funcs
->cursor_set2
) {
1077 ret
= crtc
->funcs
->cursor_set2(crtc
, NULL
, 0, 0, 0, 0, 0);
1080 } else if (crtc
->funcs
->cursor_set
) {
1081 ret
= crtc
->funcs
->cursor_set(crtc
, NULL
, 0, 0, 0);
1086 ret
= drm_mode_set_config_internal(mode_set
);
1091 drm_modeset_unlock_all(dev
);
1097 * drm_client_modeset_commit_force() - Force commit CRTC configuration
1098 * @client: DRM client
1100 * Commit modeset configuration to crtcs without checking if there is a DRM master.
1103 * Zero on success or negative error code on failure.
1105 int drm_client_modeset_commit_force(struct drm_client_dev
*client
)
1107 struct drm_device
*dev
= client
->dev
;
1110 mutex_lock(&client
->modeset_mutex
);
1111 if (drm_drv_uses_atomic_modeset(dev
))
1112 ret
= drm_client_modeset_commit_atomic(client
, true);
1114 ret
= drm_client_modeset_commit_legacy(client
);
1115 mutex_unlock(&client
->modeset_mutex
);
1119 EXPORT_SYMBOL(drm_client_modeset_commit_force
);
1122 * drm_client_modeset_commit() - Commit CRTC configuration
1123 * @client: DRM client
1125 * Commit modeset configuration to crtcs.
1128 * Zero on success or negative error code on failure.
1130 int drm_client_modeset_commit(struct drm_client_dev
*client
)
1132 struct drm_device
*dev
= client
->dev
;
1135 if (!drm_master_internal_acquire(dev
))
1138 ret
= drm_client_modeset_commit_force(client
);
1140 drm_master_internal_release(dev
);
1144 EXPORT_SYMBOL(drm_client_modeset_commit
);
1146 static void drm_client_modeset_dpms_legacy(struct drm_client_dev
*client
, int dpms_mode
)
1148 struct drm_device
*dev
= client
->dev
;
1149 struct drm_connector
*connector
;
1150 struct drm_mode_set
*modeset
;
1153 drm_modeset_lock_all(dev
);
1154 drm_client_for_each_modeset(modeset
, client
) {
1155 if (!modeset
->crtc
->enabled
)
1158 for (j
= 0; j
< modeset
->num_connectors
; j
++) {
1159 connector
= modeset
->connectors
[j
];
1160 connector
->funcs
->dpms(connector
, dpms_mode
);
1161 drm_object_property_set_value(&connector
->base
,
1162 dev
->mode_config
.dpms_property
, dpms_mode
);
1165 drm_modeset_unlock_all(dev
);
1169 * drm_client_modeset_dpms() - Set DPMS mode
1170 * @client: DRM client
1173 * Note: For atomic drivers @mode is reduced to on/off.
1176 * Zero on success or negative error code on failure.
1178 int drm_client_modeset_dpms(struct drm_client_dev
*client
, int mode
)
1180 struct drm_device
*dev
= client
->dev
;
1183 if (!drm_master_internal_acquire(dev
))
1186 mutex_lock(&client
->modeset_mutex
);
1187 if (drm_drv_uses_atomic_modeset(dev
))
1188 ret
= drm_client_modeset_commit_atomic(client
, mode
== DRM_MODE_DPMS_ON
);
1190 drm_client_modeset_dpms_legacy(client
, mode
);
1191 mutex_unlock(&client
->modeset_mutex
);
1193 drm_master_internal_release(dev
);
1197 EXPORT_SYMBOL(drm_client_modeset_dpms
);