mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-06 00:39:48 +00:00
fe91e41a61
Drivers only emulate XRGB8888 framebuffers. Remove all conversion helpers that do not use XRGB8888 as their source format. Also remove some special cases for alpha formats in the blit helper. 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-14-tzimmermann@suse.de
1134 lines
38 KiB
C
1134 lines
38 KiB
C
// SPDX-License-Identifier: GPL-2.0 or MIT
|
|
/*
|
|
* Copyright (C) 2016 Noralf Trønnes
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/io.h>
|
|
#include <linux/iosys-map.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <drm/drm_device.h>
|
|
#include <drm/drm_format_helper.h>
|
|
#include <drm/drm_framebuffer.h>
|
|
#include <drm/drm_fourcc.h>
|
|
#include <drm/drm_print.h>
|
|
#include <drm/drm_rect.h>
|
|
|
|
static unsigned int clip_offset(const struct drm_rect *clip, unsigned int pitch, unsigned int cpp)
|
|
{
|
|
return clip->y1 * pitch + clip->x1 * cpp;
|
|
}
|
|
|
|
/**
|
|
* drm_fb_clip_offset - Returns the clipping rectangles byte-offset in a framebuffer
|
|
* @pitch: Framebuffer line pitch in byte
|
|
* @format: Framebuffer format
|
|
* @clip: Clip rectangle
|
|
*
|
|
* Returns:
|
|
* The byte offset of the clip rectangle's top-left corner within the framebuffer.
|
|
*/
|
|
unsigned int drm_fb_clip_offset(unsigned int pitch, const struct drm_format_info *format,
|
|
const struct drm_rect *clip)
|
|
{
|
|
return clip_offset(clip, pitch, format->cpp[0]);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_clip_offset);
|
|
|
|
/* TODO: Make this function work with multi-plane formats. */
|
|
static int __drm_fb_xfrm(void *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
|
|
const void *vaddr, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip, bool vaddr_cached_hint,
|
|
void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
|
|
{
|
|
unsigned long linepixels = drm_rect_width(clip);
|
|
unsigned long lines = drm_rect_height(clip);
|
|
size_t sbuf_len = linepixels * fb->format->cpp[0];
|
|
void *stmp = NULL;
|
|
unsigned long i;
|
|
const void *sbuf;
|
|
|
|
/*
|
|
* Some source buffers, such as DMA memory, use write-combine
|
|
* caching, so reads are uncached. Speed up access by fetching
|
|
* one line at a time.
|
|
*/
|
|
if (!vaddr_cached_hint) {
|
|
stmp = kmalloc(sbuf_len, GFP_KERNEL);
|
|
if (!stmp)
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (!dst_pitch)
|
|
dst_pitch = drm_rect_width(clip) * dst_pixsize;
|
|
vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
|
|
|
|
for (i = 0; i < lines; ++i) {
|
|
if (stmp)
|
|
sbuf = memcpy(stmp, vaddr, sbuf_len);
|
|
else
|
|
sbuf = vaddr;
|
|
xfrm_line(dst, sbuf, linepixels);
|
|
vaddr += fb->pitches[0];
|
|
dst += dst_pitch;
|
|
}
|
|
|
|
kfree(stmp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* TODO: Make this function work with multi-plane formats. */
|
|
static int __drm_fb_xfrm_toio(void __iomem *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
|
|
const void *vaddr, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip, bool vaddr_cached_hint,
|
|
void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
|
|
{
|
|
unsigned long linepixels = drm_rect_width(clip);
|
|
unsigned long lines = drm_rect_height(clip);
|
|
size_t dbuf_len = linepixels * dst_pixsize;
|
|
size_t stmp_off = round_up(dbuf_len, ARCH_KMALLOC_MINALIGN); /* for sbuf alignment */
|
|
size_t sbuf_len = linepixels * fb->format->cpp[0];
|
|
void *stmp = NULL;
|
|
unsigned long i;
|
|
const void *sbuf;
|
|
void *dbuf;
|
|
|
|
if (vaddr_cached_hint) {
|
|
dbuf = kmalloc(dbuf_len, GFP_KERNEL);
|
|
} else {
|
|
dbuf = kmalloc(stmp_off + sbuf_len, GFP_KERNEL);
|
|
stmp = dbuf + stmp_off;
|
|
}
|
|
if (!dbuf)
|
|
return -ENOMEM;
|
|
|
|
if (!dst_pitch)
|
|
dst_pitch = linepixels * dst_pixsize;
|
|
vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
|
|
|
|
for (i = 0; i < lines; ++i) {
|
|
if (stmp)
|
|
sbuf = memcpy(stmp, vaddr, sbuf_len);
|
|
else
|
|
sbuf = vaddr;
|
|
xfrm_line(dbuf, sbuf, linepixels);
|
|
memcpy_toio(dst, dbuf, dbuf_len);
|
|
vaddr += fb->pitches[0];
|
|
dst += dst_pitch;
|
|
}
|
|
|
|
kfree(dbuf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* TODO: Make this function work with multi-plane formats. */
|
|
static int drm_fb_xfrm(struct iosys_map *dst,
|
|
const unsigned int *dst_pitch, const u8 *dst_pixsize,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip, bool vaddr_cached_hint,
|
|
void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
|
|
{
|
|
static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
|
|
0, 0, 0, 0
|
|
};
|
|
|
|
if (!dst_pitch)
|
|
dst_pitch = default_dst_pitch;
|
|
|
|
/* TODO: handle src in I/O memory here */
|
|
if (dst[0].is_iomem)
|
|
return __drm_fb_xfrm_toio(dst[0].vaddr_iomem, dst_pitch[0], dst_pixsize[0],
|
|
src[0].vaddr, fb, clip, vaddr_cached_hint, xfrm_line);
|
|
else
|
|
return __drm_fb_xfrm(dst[0].vaddr, dst_pitch[0], dst_pixsize[0],
|
|
src[0].vaddr, fb, clip, vaddr_cached_hint, xfrm_line);
|
|
}
|
|
|
|
/**
|
|
* drm_fb_memcpy - Copy clip buffer
|
|
* @dst: Array of destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory. Destination and
|
|
* framebuffer formats must match. No conversion takes place. The parameters @dst,
|
|
* @dst_pitch and @src refer to arrays. Each array must have at least as many entries
|
|
* as there are planes in @fb's format. Each entry stores the value for the format's
|
|
* respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*/
|
|
void drm_fb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
|
|
0, 0, 0, 0
|
|
};
|
|
|
|
const struct drm_format_info *format = fb->format;
|
|
unsigned int i, y, lines = drm_rect_height(clip);
|
|
|
|
if (!dst_pitch)
|
|
dst_pitch = default_dst_pitch;
|
|
|
|
for (i = 0; i < format->num_planes; ++i) {
|
|
unsigned int bpp_i = drm_format_info_bpp(format, i);
|
|
unsigned int cpp_i = DIV_ROUND_UP(bpp_i, 8);
|
|
size_t len_i = DIV_ROUND_UP(drm_rect_width(clip) * bpp_i, 8);
|
|
unsigned int dst_pitch_i = dst_pitch[i];
|
|
struct iosys_map dst_i = dst[i];
|
|
struct iosys_map src_i = src[i];
|
|
|
|
if (!dst_pitch_i)
|
|
dst_pitch_i = len_i;
|
|
|
|
iosys_map_incr(&src_i, clip_offset(clip, fb->pitches[i], cpp_i));
|
|
for (y = 0; y < lines; y++) {
|
|
/* TODO: handle src_i in I/O memory here */
|
|
iosys_map_memcpy_to(&dst_i, 0, src_i.vaddr, len_i);
|
|
iosys_map_incr(&src_i, fb->pitches[i]);
|
|
iosys_map_incr(&dst_i, dst_pitch_i);
|
|
}
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_memcpy);
|
|
|
|
static void drm_fb_swab16_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u16 *dbuf16 = dbuf;
|
|
const u16 *sbuf16 = sbuf;
|
|
const u16 *send16 = sbuf16 + pixels;
|
|
|
|
while (sbuf16 < send16)
|
|
*dbuf16++ = swab16(*sbuf16++);
|
|
}
|
|
|
|
static void drm_fb_swab32_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u32 *dbuf32 = dbuf;
|
|
const u32 *sbuf32 = sbuf;
|
|
const u32 *send32 = sbuf32 + pixels;
|
|
|
|
while (sbuf32 < send32)
|
|
*dbuf32++ = swab32(*sbuf32++);
|
|
}
|
|
|
|
/**
|
|
* drm_fb_swab - Swap bytes into clip buffer
|
|
* @dst: Array of destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
* @cached: Source buffer is mapped cached (eg. not write-combined)
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and swaps per-pixel
|
|
* bytes during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index. If @cached is
|
|
* false a temporary buffer is used to cache one pixel line at a time to speed up
|
|
* slow uncached reads.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*/
|
|
void drm_fb_swab(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip, bool cached)
|
|
{
|
|
const struct drm_format_info *format = fb->format;
|
|
u8 cpp = DIV_ROUND_UP(drm_format_info_bpp(format, 0), 8);
|
|
void (*swab_line)(void *dbuf, const void *sbuf, unsigned int npixels);
|
|
|
|
switch (cpp) {
|
|
case 4:
|
|
swab_line = drm_fb_swab32_line;
|
|
break;
|
|
case 2:
|
|
swab_line = drm_fb_swab16_line;
|
|
break;
|
|
default:
|
|
drm_warn_once(fb->dev, "Format %p4cc has unsupported pixel size.\n",
|
|
&format->format);
|
|
return;
|
|
}
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, &cpp, src, fb, clip, cached, swab_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_swab);
|
|
|
|
static void drm_fb_xrgb8888_to_rgb332_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u8 *dbuf8 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
dbuf8[x] = ((pix & 0x00e00000) >> 16) |
|
|
((pix & 0x0000e000) >> 11) |
|
|
((pix & 0x000000c0) >> 6);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_rgb332 - Convert XRGB8888 to RGB332 clip buffer
|
|
* @dst: Array of RGB332 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for RGB332 devices that don't support XRGB8888 natively.
|
|
*/
|
|
void drm_fb_xrgb8888_to_rgb332(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
1,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_rgb332_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb332);
|
|
|
|
static void drm_fb_xrgb8888_to_rgb565_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le16 *dbuf16 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u16 val16;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val16 = ((pix & 0x00F80000) >> 8) |
|
|
((pix & 0x0000FC00) >> 5) |
|
|
((pix & 0x000000F8) >> 3);
|
|
dbuf16[x] = cpu_to_le16(val16);
|
|
}
|
|
}
|
|
|
|
/* TODO: implement this helper as conversion to RGB565|BIG_ENDIAN */
|
|
static void drm_fb_xrgb8888_to_rgb565_swab_line(void *dbuf, const void *sbuf,
|
|
unsigned int pixels)
|
|
{
|
|
__le16 *dbuf16 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u16 val16;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val16 = ((pix & 0x00F80000) >> 8) |
|
|
((pix & 0x0000FC00) >> 5) |
|
|
((pix & 0x000000F8) >> 3);
|
|
dbuf16[x] = cpu_to_le16(swab16(val16));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
|
|
* @dst: Array of RGB565 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffer
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
* @swab: Swap bytes
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for RGB565 devices that don't support XRGB8888 natively.
|
|
*/
|
|
void drm_fb_xrgb8888_to_rgb565(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip, bool swab)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
2,
|
|
};
|
|
|
|
void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels);
|
|
|
|
if (swab)
|
|
xfrm_line = drm_fb_xrgb8888_to_rgb565_swab_line;
|
|
else
|
|
xfrm_line = drm_fb_xrgb8888_to_rgb565_line;
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, xfrm_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb565);
|
|
|
|
static void drm_fb_xrgb8888_to_xrgb1555_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le16 *dbuf16 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u16 val16;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val16 = ((pix & 0x00f80000) >> 9) |
|
|
((pix & 0x0000f800) >> 6) |
|
|
((pix & 0x000000f8) >> 3);
|
|
dbuf16[x] = cpu_to_le16(val16);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_xrgb1555 - Convert XRGB8888 to XRGB1555 clip buffer
|
|
* @dst: Array of XRGB1555 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffer
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts
|
|
* the color format during the process. The parameters @dst, @dst_pitch and
|
|
* @src refer to arrays. Each array must have at least as many entries as
|
|
* there are planes in @fb's format. Each entry stores the value for the
|
|
* format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for XRGB1555 devices that don't support
|
|
* XRGB8888 natively.
|
|
*/
|
|
void drm_fb_xrgb8888_to_xrgb1555(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
2,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_xrgb1555_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb1555);
|
|
|
|
static void drm_fb_xrgb8888_to_argb1555_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le16 *dbuf16 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u16 val16;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val16 = BIT(15) | /* set alpha bit */
|
|
((pix & 0x00f80000) >> 9) |
|
|
((pix & 0x0000f800) >> 6) |
|
|
((pix & 0x000000f8) >> 3);
|
|
dbuf16[x] = cpu_to_le16(val16);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_argb1555 - Convert XRGB8888 to ARGB1555 clip buffer
|
|
* @dst: Array of ARGB1555 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffer
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts
|
|
* the color format during the process. The parameters @dst, @dst_pitch and
|
|
* @src refer to arrays. Each array must have at least as many entries as
|
|
* there are planes in @fb's format. Each entry stores the value for the
|
|
* format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for ARGB1555 devices that don't support
|
|
* XRGB8888 natively. It sets an opaque alpha channel as part of the conversion.
|
|
*/
|
|
void drm_fb_xrgb8888_to_argb1555(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
2,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_argb1555_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb1555);
|
|
|
|
static void drm_fb_xrgb8888_to_rgba5551_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le16 *dbuf16 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u16 val16;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val16 = ((pix & 0x00f80000) >> 8) |
|
|
((pix & 0x0000f800) >> 5) |
|
|
((pix & 0x000000f8) >> 2) |
|
|
BIT(0); /* set alpha bit */
|
|
dbuf16[x] = cpu_to_le16(val16);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_rgba5551 - Convert XRGB8888 to RGBA5551 clip buffer
|
|
* @dst: Array of RGBA5551 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffer
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts
|
|
* the color format during the process. The parameters @dst, @dst_pitch and
|
|
* @src refer to arrays. Each array must have at least as many entries as
|
|
* there are planes in @fb's format. Each entry stores the value for the
|
|
* format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for RGBA5551 devices that don't support
|
|
* XRGB8888 natively. It sets an opaque alpha channel as part of the conversion.
|
|
*/
|
|
void drm_fb_xrgb8888_to_rgba5551(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
2,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_rgba5551_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgba5551);
|
|
|
|
static void drm_fb_xrgb8888_to_rgb888_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u8 *dbuf8 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
/* write blue-green-red to output in little endianness */
|
|
*dbuf8++ = (pix & 0x000000FF) >> 0;
|
|
*dbuf8++ = (pix & 0x0000FF00) >> 8;
|
|
*dbuf8++ = (pix & 0x00FF0000) >> 16;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_rgb888 - Convert XRGB8888 to RGB888 clip buffer
|
|
* @dst: Array of RGB888 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for RGB888 devices that don't natively
|
|
* support XRGB8888.
|
|
*/
|
|
void drm_fb_xrgb8888_to_rgb888(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
3,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_rgb888_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb888);
|
|
|
|
static void drm_fb_xrgb8888_to_argb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le32 *dbuf32 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
pix |= GENMASK(31, 24); /* fill alpha bits */
|
|
dbuf32[x] = cpu_to_le32(pix);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_argb8888 - Convert XRGB8888 to ARGB8888 clip buffer
|
|
* @dst: Array of ARGB8888 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffer
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. The parameters @dst, @dst_pitch and @src refer
|
|
* to arrays. Each array must have at least as many entries as there are planes in
|
|
* @fb's format. Each entry stores the value for the format's respective color plane
|
|
* at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for ARGB8888 devices that don't support XRGB8888
|
|
* natively. It sets an opaque alpha channel as part of the conversion.
|
|
*/
|
|
void drm_fb_xrgb8888_to_argb8888(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
4,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_argb8888_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb8888);
|
|
|
|
static void drm_fb_xrgb8888_to_xrgb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le32 *dbuf32 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u32 val32;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val32 = ((pix & 0x000000FF) << 2) |
|
|
((pix & 0x0000FF00) << 4) |
|
|
((pix & 0x00FF0000) << 6);
|
|
pix = val32 | ((val32 >> 8) & 0x00300C03);
|
|
*dbuf32++ = cpu_to_le32(pix);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_xrgb2101010 - Convert XRGB8888 to XRGB2101010 clip buffer
|
|
* @dst: Array of XRGB2101010 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for XRGB2101010 devices that don't support XRGB8888
|
|
* natively.
|
|
*/
|
|
void drm_fb_xrgb8888_to_xrgb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
4,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_xrgb2101010_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb2101010);
|
|
|
|
static void drm_fb_xrgb8888_to_argb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
__le32 *dbuf32 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
u32 val32;
|
|
u32 pix;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
pix = le32_to_cpu(sbuf32[x]);
|
|
val32 = ((pix & 0x000000ff) << 2) |
|
|
((pix & 0x0000ff00) << 4) |
|
|
((pix & 0x00ff0000) << 6);
|
|
pix = GENMASK(31, 30) | /* set alpha bits */
|
|
val32 | ((val32 >> 8) & 0x00300c03);
|
|
*dbuf32++ = cpu_to_le32(pix);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_argb2101010 - Convert XRGB8888 to ARGB2101010 clip buffer
|
|
* @dst: Array of ARGB2101010 destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts
|
|
* the color format during the process. The parameters @dst, @dst_pitch and
|
|
* @src refer to arrays. Each array must have at least as many entries as
|
|
* there are planes in @fb's format. Each entry stores the value for the
|
|
* format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Drivers can use this function for ARGB2101010 devices that don't support XRGB8888
|
|
* natively.
|
|
*/
|
|
void drm_fb_xrgb8888_to_argb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
4,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_argb2101010_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb2101010);
|
|
|
|
static void drm_fb_xrgb8888_to_gray8_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u8 *dbuf8 = dbuf;
|
|
const __le32 *sbuf32 = sbuf;
|
|
unsigned int x;
|
|
|
|
for (x = 0; x < pixels; x++) {
|
|
u32 pix = le32_to_cpu(sbuf32[x]);
|
|
u8 r = (pix & 0x00ff0000) >> 16;
|
|
u8 g = (pix & 0x0000ff00) >> 8;
|
|
u8 b = pix & 0x000000ff;
|
|
|
|
/* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
|
|
*dbuf8++ = (3 * r + 6 * g + b) / 10;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
|
|
* @dst: Array of 8-bit grayscale destination buffers
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* DRM doesn't have native monochrome or grayscale support. Drivers can use this
|
|
* function for grayscale devices that don't support XRGB8888 natively.Such
|
|
* drivers can announce the commonly supported XR24 format to userspace and use
|
|
* this function to convert to the native format. Monochrome drivers will use the
|
|
* most significant bit, where 1 means foreground color and 0 background color.
|
|
* ITU BT.601 is being used for the RGB -> luma (brightness) conversion.
|
|
*/
|
|
void drm_fb_xrgb8888_to_gray8(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
|
|
1,
|
|
};
|
|
|
|
drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
|
|
drm_fb_xrgb8888_to_gray8_line);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_gray8);
|
|
|
|
/**
|
|
* drm_fb_blit - Copy parts of a framebuffer to display memory
|
|
* @dst: Array of display-memory addresses to copy to
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @dst_format: FOURCC code of the display's color format
|
|
* @src: The framebuffer memory to copy from
|
|
* @fb: The framebuffer to copy from
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory. If the
|
|
* formats of the display and the framebuffer mismatch, the blit function
|
|
* will attempt to convert between them during the process. The parameters @dst,
|
|
* @dst_pitch and @src refer to arrays. Each array must have at least as many
|
|
* entries as there are planes in @dst_format's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner).
|
|
*
|
|
* Returns:
|
|
* 0 on success, or
|
|
* -EINVAL if the color-format conversion failed, or
|
|
* a negative error code otherwise.
|
|
*/
|
|
int drm_fb_blit(struct iosys_map *dst, const unsigned int *dst_pitch, uint32_t dst_format,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
uint32_t fb_format = fb->format->format;
|
|
|
|
if (fb_format == dst_format) {
|
|
drm_fb_memcpy(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (fb_format == (dst_format | DRM_FORMAT_BIG_ENDIAN)) {
|
|
drm_fb_swab(dst, dst_pitch, src, fb, clip, false);
|
|
return 0;
|
|
} else if (fb_format == (dst_format & ~DRM_FORMAT_BIG_ENDIAN)) {
|
|
drm_fb_swab(dst, dst_pitch, src, fb, clip, false);
|
|
return 0;
|
|
} else if (fb_format == DRM_FORMAT_XRGB8888) {
|
|
if (dst_format == DRM_FORMAT_RGB565) {
|
|
drm_fb_xrgb8888_to_rgb565(dst, dst_pitch, src, fb, clip, false);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_XRGB1555) {
|
|
drm_fb_xrgb8888_to_xrgb1555(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_ARGB1555) {
|
|
drm_fb_xrgb8888_to_argb1555(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_RGBA5551) {
|
|
drm_fb_xrgb8888_to_rgba5551(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_RGB888) {
|
|
drm_fb_xrgb8888_to_rgb888(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_ARGB8888) {
|
|
drm_fb_xrgb8888_to_argb8888(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_XRGB2101010) {
|
|
drm_fb_xrgb8888_to_xrgb2101010(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_ARGB2101010) {
|
|
drm_fb_xrgb8888_to_argb2101010(dst, dst_pitch, src, fb, clip);
|
|
return 0;
|
|
} else if (dst_format == DRM_FORMAT_BGRX8888) {
|
|
drm_fb_swab(dst, dst_pitch, src, fb, clip, false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
drm_warn_once(fb->dev, "No conversion helper from %p4cc to %p4cc found.\n",
|
|
&fb_format, &dst_format);
|
|
|
|
return -EINVAL;
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_blit);
|
|
|
|
static void drm_fb_gray8_to_mono_line(void *dbuf, const void *sbuf, unsigned int pixels)
|
|
{
|
|
u8 *dbuf8 = dbuf;
|
|
const u8 *sbuf8 = sbuf;
|
|
|
|
while (pixels) {
|
|
unsigned int i, bits = min(pixels, 8U);
|
|
u8 byte = 0;
|
|
|
|
for (i = 0; i < bits; i++, pixels--) {
|
|
if (*sbuf8++ >= 128)
|
|
byte |= BIT(i);
|
|
}
|
|
*dbuf8++ = byte;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_fb_xrgb8888_to_mono - Convert XRGB8888 to monochrome
|
|
* @dst: Array of monochrome destination buffers (0=black, 1=white)
|
|
* @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
|
|
* within @dst; can be NULL if scanlines are stored next to each other.
|
|
* @src: Array of XRGB8888 source buffers
|
|
* @fb: DRM framebuffer
|
|
* @clip: Clip rectangle area to copy
|
|
*
|
|
* This function copies parts of a framebuffer to display memory and converts the
|
|
* color format during the process. Destination and framebuffer formats must match. The
|
|
* parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
|
|
* least as many entries as there are planes in @fb's format. Each entry stores the
|
|
* value for the format's respective color plane at the same index.
|
|
*
|
|
* This function does not apply clipping on @dst (i.e. the destination is at the
|
|
* top-left corner). The first pixel (upper left corner of the clip rectangle) will
|
|
* be converted and copied to the first bit (LSB) in the first byte of the monochrome
|
|
* destination buffer. If the caller requires that the first pixel in a byte must
|
|
* be located at an x-coordinate that is a multiple of 8, then the caller must take
|
|
* care itself of supplying a suitable clip rectangle.
|
|
*
|
|
* DRM doesn't have native monochrome support. Drivers can use this function for
|
|
* monochrome devices that don't support XRGB8888 natively. Such drivers can
|
|
* announce the commonly supported XR24 format to userspace and use this function
|
|
* to convert to the native format.
|
|
*
|
|
* This function uses drm_fb_xrgb8888_to_gray8() to convert to grayscale and
|
|
* then the result is converted from grayscale to monochrome.
|
|
*/
|
|
void drm_fb_xrgb8888_to_mono(struct iosys_map *dst, const unsigned int *dst_pitch,
|
|
const struct iosys_map *src, const struct drm_framebuffer *fb,
|
|
const struct drm_rect *clip)
|
|
{
|
|
static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
|
|
0, 0, 0, 0
|
|
};
|
|
unsigned int linepixels = drm_rect_width(clip);
|
|
unsigned int lines = drm_rect_height(clip);
|
|
unsigned int cpp = fb->format->cpp[0];
|
|
unsigned int len_src32 = linepixels * cpp;
|
|
struct drm_device *dev = fb->dev;
|
|
void *vaddr = src[0].vaddr;
|
|
unsigned int dst_pitch_0;
|
|
unsigned int y;
|
|
u8 *mono = dst[0].vaddr, *gray8;
|
|
u32 *src32;
|
|
|
|
if (drm_WARN_ON(dev, fb->format->format != DRM_FORMAT_XRGB8888))
|
|
return;
|
|
|
|
if (!dst_pitch)
|
|
dst_pitch = default_dst_pitch;
|
|
dst_pitch_0 = dst_pitch[0];
|
|
|
|
/*
|
|
* The mono destination buffer contains 1 bit per pixel
|
|
*/
|
|
if (!dst_pitch_0)
|
|
dst_pitch_0 = DIV_ROUND_UP(linepixels, 8);
|
|
|
|
/*
|
|
* The dma memory is write-combined so reads are uncached.
|
|
* Speed up by fetching one line at a time.
|
|
*
|
|
* Also, format conversion from XR24 to monochrome are done
|
|
* line-by-line but are converted to 8-bit grayscale as an
|
|
* intermediate step.
|
|
*
|
|
* Allocate a buffer to be used for both copying from the cma
|
|
* memory and to store the intermediate grayscale line pixels.
|
|
*/
|
|
src32 = kmalloc(len_src32 + linepixels, GFP_KERNEL);
|
|
if (!src32)
|
|
return;
|
|
|
|
gray8 = (u8 *)src32 + len_src32;
|
|
|
|
vaddr += clip_offset(clip, fb->pitches[0], cpp);
|
|
for (y = 0; y < lines; y++) {
|
|
src32 = memcpy(src32, vaddr, len_src32);
|
|
drm_fb_xrgb8888_to_gray8_line(gray8, src32, linepixels);
|
|
drm_fb_gray8_to_mono_line(mono, gray8, linepixels);
|
|
vaddr += fb->pitches[0];
|
|
mono += dst_pitch_0;
|
|
}
|
|
|
|
kfree(src32);
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_xrgb8888_to_mono);
|
|
|
|
static uint32_t drm_fb_nonalpha_fourcc(uint32_t fourcc)
|
|
{
|
|
/* only handle formats with depth != 0 and alpha channel */
|
|
switch (fourcc) {
|
|
case DRM_FORMAT_ARGB1555:
|
|
return DRM_FORMAT_XRGB1555;
|
|
case DRM_FORMAT_ABGR1555:
|
|
return DRM_FORMAT_XBGR1555;
|
|
case DRM_FORMAT_RGBA5551:
|
|
return DRM_FORMAT_RGBX5551;
|
|
case DRM_FORMAT_BGRA5551:
|
|
return DRM_FORMAT_BGRX5551;
|
|
case DRM_FORMAT_ARGB8888:
|
|
return DRM_FORMAT_XRGB8888;
|
|
case DRM_FORMAT_ABGR8888:
|
|
return DRM_FORMAT_XBGR8888;
|
|
case DRM_FORMAT_RGBA8888:
|
|
return DRM_FORMAT_RGBX8888;
|
|
case DRM_FORMAT_BGRA8888:
|
|
return DRM_FORMAT_BGRX8888;
|
|
case DRM_FORMAT_ARGB2101010:
|
|
return DRM_FORMAT_XRGB2101010;
|
|
case DRM_FORMAT_ABGR2101010:
|
|
return DRM_FORMAT_XBGR2101010;
|
|
case DRM_FORMAT_RGBA1010102:
|
|
return DRM_FORMAT_RGBX1010102;
|
|
case DRM_FORMAT_BGRA1010102:
|
|
return DRM_FORMAT_BGRX1010102;
|
|
}
|
|
|
|
return fourcc;
|
|
}
|
|
|
|
static bool is_listed_fourcc(const uint32_t *fourccs, size_t nfourccs, uint32_t fourcc)
|
|
{
|
|
const uint32_t *fourccs_end = fourccs + nfourccs;
|
|
|
|
while (fourccs < fourccs_end) {
|
|
if (*fourccs == fourcc)
|
|
return true;
|
|
++fourccs;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* drm_fb_build_fourcc_list - Filters a list of supported color formats against
|
|
* the device's native formats
|
|
* @dev: DRM device
|
|
* @native_fourccs: 4CC codes of natively supported color formats
|
|
* @native_nfourccs: The number of entries in @native_fourccs
|
|
* @fourccs_out: Returns 4CC codes of supported color formats
|
|
* @nfourccs_out: The number of available entries in @fourccs_out
|
|
*
|
|
* This function create a list of supported color format from natively
|
|
* supported formats and additional emulated formats.
|
|
* At a minimum, most userspace programs expect at least support for
|
|
* XRGB8888 on the primary plane. Devices that have to emulate the
|
|
* format, and possibly others, can use drm_fb_build_fourcc_list() to
|
|
* create a list of supported color formats. The returned list can
|
|
* be handed over to drm_universal_plane_init() et al. Native formats
|
|
* will go before emulated formats. Native formats with alpha channel
|
|
* will be replaced by such without, as primary planes usually don't
|
|
* support alpha. Other heuristics might be applied
|
|
* to optimize the order. Formats near the beginning of the list are
|
|
* usually preferred over formats near the end of the list.
|
|
*
|
|
* Returns:
|
|
* The number of color-formats 4CC codes returned in @fourccs_out.
|
|
*/
|
|
size_t drm_fb_build_fourcc_list(struct drm_device *dev,
|
|
const u32 *native_fourccs, size_t native_nfourccs,
|
|
u32 *fourccs_out, size_t nfourccs_out)
|
|
{
|
|
/*
|
|
* XRGB8888 is the default fallback format for most of userspace
|
|
* and it's currently the only format that should be emulated for
|
|
* the primary plane. Only if there's ever another default fallback,
|
|
* it should be added here.
|
|
*/
|
|
static const uint32_t extra_fourccs[] = {
|
|
DRM_FORMAT_XRGB8888,
|
|
};
|
|
static const size_t extra_nfourccs = ARRAY_SIZE(extra_fourccs);
|
|
|
|
u32 *fourccs = fourccs_out;
|
|
const u32 *fourccs_end = fourccs_out + nfourccs_out;
|
|
size_t i;
|
|
|
|
/*
|
|
* The device's native formats go first.
|
|
*/
|
|
|
|
for (i = 0; i < native_nfourccs; ++i) {
|
|
/*
|
|
* Several DTs, boot loaders and firmware report native
|
|
* alpha formats that are non-alpha formats instead. So
|
|
* replace alpha formats by non-alpha formats.
|
|
*/
|
|
u32 fourcc = drm_fb_nonalpha_fourcc(native_fourccs[i]);
|
|
|
|
if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
|
|
continue; /* skip duplicate entries */
|
|
} else if (fourccs == fourccs_end) {
|
|
drm_warn(dev, "Ignoring native format %p4cc\n", &fourcc);
|
|
continue; /* end of available output buffer */
|
|
}
|
|
|
|
drm_dbg_kms(dev, "adding native format %p4cc\n", &fourcc);
|
|
|
|
*fourccs = fourcc;
|
|
++fourccs;
|
|
}
|
|
|
|
/*
|
|
* The extra formats, emulated by the driver, go second.
|
|
*/
|
|
|
|
for (i = 0; (i < extra_nfourccs) && (fourccs < fourccs_end); ++i) {
|
|
u32 fourcc = extra_fourccs[i];
|
|
|
|
if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
|
|
continue; /* skip duplicate and native entries */
|
|
} else if (fourccs == fourccs_end) {
|
|
drm_warn(dev, "Ignoring emulated format %p4cc\n", &fourcc);
|
|
continue; /* end of available output buffer */
|
|
}
|
|
|
|
drm_dbg_kms(dev, "adding emulated format %p4cc\n", &fourcc);
|
|
|
|
*fourccs = fourcc;
|
|
++fourccs;
|
|
}
|
|
|
|
return fourccs - fourccs_out;
|
|
}
|
|
EXPORT_SYMBOL(drm_fb_build_fourcc_list);
|