nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

drm/fb-helper: Fix single-probe color-format selection

Browse source 
Fix the color-format selection of the single-probe helper. Go
through all user-specified values and test each for compatibility
with the driver. If none is supported, use the driver-provided
default. This guarantees that the console is always available in
any color format at least.

Until now, the format selection of the single-probe helper tried
to either use a user-specified format or a 32-bit default format.
If the user-specified format was not supported by the driver, the
selection failed and the display remained blank.

Signed-off-by: Thomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: Javier Martinez Canillas <javierm@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20230102112927.26565-12-tzimmermann@suse.de
This commit is contained in:
Thomas Zimmermann 2023-01-02 12:29:25 +01:00
parent cff84bac99
commit 37c90d589d
1 changed files with 95 additions and 79 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

170
drivers/gpu/drm/drm_fb_helper.c
View file

@ -1726,6 +1726,70 @@ int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
} }
EXPORT_SYMBOL(drm_fb_helper_pan_display); EXPORT_SYMBOL(drm_fb_helper_pan_display);
static uint32_t drm_fb_helper_find_format(struct drm_fb_helper *fb_helper, const uint32_t *formats,
size_t format_count, uint32_t bpp, uint32_t depth)
{
struct drm_device *dev = fb_helper->dev;
uint32_t format;
size_t i;
/*
* Do not consider YUV or other complicated formats
* for framebuffers. This means only legacy formats
* are supported (fmt->depth is a legacy field), but
* the framebuffer emulation can only deal with such
* formats, specifically RGB/BGA formats.
*/
format = drm_mode_legacy_fb_format(bpp, depth);
if (!format)
goto err;
for (i = 0; i < format_count; ++i) {
if (formats[i] == format)
return format;
}
err:
/* We found nothing. */
drm_warn(dev, "bpp/depth value of %u/%u not supported\n", bpp, depth);
return DRM_FORMAT_INVALID;
}
static uint32_t drm_fb_helper_find_cmdline_format(struct drm_fb_helper *fb_helper,
const uint32_t *formats, size_t format_count,
const struct drm_cmdline_mode *cmdline_mode)
{
struct drm_device *dev = fb_helper->dev;
uint32_t bpp, depth;
if (!cmdline_mode->bpp_specified)
return DRM_FORMAT_INVALID;
switch (cmdline_mode->bpp) {
case 1:
case 2:
case 4:
case 8:
case 16:
case 24:
bpp = depth = cmdline_mode->bpp;
break;
case 15:
bpp = 16;
depth = 15;
break;
case 32:
bpp = 32;
depth = 24;
break;
default:
drm_info(dev, "unsupported bpp value of %d\n", cmdline_mode->bpp);
return DRM_FORMAT_INVALID;
}
return drm_fb_helper_find_format(fb_helper, formats, format_count, bpp, depth);
}
static int __drm_fb_helper_find_sizes(struct drm_fb_helper *fb_helper, int preferred_bpp, static int __drm_fb_helper_find_sizes(struct drm_fb_helper *fb_helper, int preferred_bpp,
struct drm_fb_helper_surface_size *sizes) struct drm_fb_helper_surface_size *sizes)
@ -1736,99 +1800,51 @@ static int __drm_fb_helper_find_sizes(struct drm_fb_helper *fb_helper, int prefe
struct drm_connector_list_iter conn_iter; struct drm_connector_list_iter conn_iter;
struct drm_connector *connector; struct drm_connector *connector;
struct drm_mode_set *mode_set; struct drm_mode_set *mode_set;
int best_depth = 0; uint32_t surface_format = DRM_FORMAT_INVALID;
const struct drm_format_info *info;
memset(sizes, 0, sizeof(struct drm_fb_helper_surface_size)); memset(sizes, 0, sizeof(*sizes));
sizes->surface_depth = 24;
sizes->surface_bpp = 32;
sizes->fb_width = (u32)-1; sizes->fb_width = (u32)-1;
sizes->fb_height = (u32)-1; sizes->fb_height = (u32)-1;
/*
* If driver picks 8 or 16 by default use that for both depth/bpp
* to begin with
*/
if (preferred_bpp != sizes->surface_bpp)
sizes->surface_depth = sizes->surface_bpp = preferred_bpp;
drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
drm_client_for_each_connector_iter(connector, &conn_iter) {
struct drm_cmdline_mode *cmdline_mode;
cmdline_mode = &connector->cmdline_mode;
if (cmdline_mode->bpp_specified) {
switch (cmdline_mode->bpp) {
case 8:
sizes->surface_depth = sizes->surface_bpp = 8;
break;
case 15:
sizes->surface_depth = 15;
sizes->surface_bpp = 16;
break;
case 16:
sizes->surface_depth = sizes->surface_bpp = 16;
break;
case 24:
sizes->surface_depth = sizes->surface_bpp = 24;
break;
case 32:
sizes->surface_depth = 24;
sizes->surface_bpp = 32;
break;
}
break;
}
}
drm_connector_list_iter_end(&conn_iter);
/*
* If we run into a situation where, for example, the primary plane
* supports RGBA5551 (16 bpp, depth 15) but not RGB565 (16 bpp, depth
* 16) we need to scale down the depth of the sizes we request.
*/
drm_client_for_each_modeset(mode_set, client) { drm_client_for_each_modeset(mode_set, client) {
struct drm_crtc *crtc = mode_set->crtc; struct drm_crtc *crtc = mode_set->crtc;
struct drm_plane *plane = crtc->primary; struct drm_plane *plane = crtc->primary;
int j;
drm_dbg_kms(dev, "test CRTC %u primary plane\n", drm_crtc_index(crtc)); drm_dbg_kms(dev, "test CRTC %u primary plane\n", drm_crtc_index(crtc));
for (j = 0; j < plane->format_count; j++) { drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
const struct drm_format_info *fmt; drm_client_for_each_connector_iter(connector, &conn_iter) {
struct drm_cmdline_mode *cmdline_mode = &connector->cmdline_mode;
fmt = drm_format_info(plane->format_types[j]); surface_format = drm_fb_helper_find_cmdline_format(fb_helper,
plane->format_types,
plane->format_count,
cmdline_mode);
if (surface_format != DRM_FORMAT_INVALID)
break; /* found supported format */
}
drm_connector_list_iter_end(&conn_iter);
/* if (surface_format != DRM_FORMAT_INVALID)
* Do not consider YUV or other complicated formats break; /* found supported format */
* for framebuffers. This means only legacy formats
* are supported (fmt->depth is a legacy field) but
* the framebuffer emulation can only deal with such
* formats, specifically RGB/BGA formats.
*/
if (fmt->depth == 0)
continue;
/* We found a perfect fit, great */ /* try preferred bpp/depth */
if (fmt->depth == sizes->surface_depth) { surface_format = drm_fb_helper_find_format(fb_helper, plane->format_types,
best_depth = fmt->depth; plane->format_count, preferred_bpp,
break; dev->mode_config.preferred_depth);
if (surface_format != DRM_FORMAT_INVALID)
break; /* found supported format */
} }
/* Skip depths above what we're looking for */ if (surface_format == DRM_FORMAT_INVALID) {
if (fmt->depth > sizes->surface_depth) drm_warn(dev, "No compatible format found\n");
continue; return -EAGAIN;
}
/* Best depth found so far */ info = drm_format_info(surface_format);
if (fmt->depth > best_depth) sizes->surface_bpp = drm_format_info_bpp(info, 0);
best_depth = fmt->depth; sizes->surface_depth = info->depth;
}
}
if (sizes->surface_depth != best_depth && best_depth) {
drm_info(dev, "requested bpp %d, scaled depth down to %d",
sizes->surface_bpp, best_depth);
sizes->surface_depth = best_depth;
}
/* first up get a count of crtcs now in use and new min/maxes width/heights */ /* first up get a count of crtcs now in use and new min/maxes width/heights */
crtc_count = 0; crtc_count = 0;