1// SPDX-License-Identifier: GPL-2.0+
2
3#include <linux/kernel.h>
4#include <linux/minmax.h>
5
6#include <drm/drm_blend.h>
7#include <drm/drm_rect.h>
8#include <drm/drm_fixed.h>
9
10#include "vkms_formats.h"
11
12static size_t pixel_offset(const struct vkms_frame_info *frame_info, int x, int y)
13{
14 return frame_info->offset + (y * frame_info->pitch)
15 + (x * frame_info->cpp);
16}
17
18/*
19 * packed_pixels_addr - Get the pointer to pixel of a given pair of coordinates
20 *
21 * @frame_info: Buffer metadata
22 * @x: The x(width) coordinate of the 2D buffer
23 * @y: The y(Heigth) coordinate of the 2D buffer
24 *
25 * Takes the information stored in the frame_info, a pair of coordinates, and
26 * returns the address of the first color channel.
27 * This function assumes the channels are packed together, i.e. a color channel
28 * comes immediately after another in the memory. And therefore, this function
29 * doesn't work for YUV with chroma subsampling (e.g. YUV420 and NV21).
30 */
31static void *packed_pixels_addr(const struct vkms_frame_info *frame_info,
32 int x, int y)
33{
34 size_t offset = pixel_offset(frame_info, x, y);
35
36 return (u8 *)frame_info->map[0].vaddr + offset;
37}
38
39static void *get_packed_src_addr(const struct vkms_frame_info *frame_info, int y)
40{
41 int x_src = frame_info->src.x1 >> 16;
42 int y_src = y - frame_info->rotated.y1 + (frame_info->src.y1 >> 16);
43
44 return packed_pixels_addr(frame_info, x: x_src, y: y_src);
45}
46
47static int get_x_position(const struct vkms_frame_info *frame_info, int limit, int x)
48{
49 if (frame_info->rotation & (DRM_MODE_REFLECT_X | DRM_MODE_ROTATE_270))
50 return limit - x - 1;
51 return x;
52}
53
54static void ARGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel)
55{
56 /*
57 * The 257 is the "conversion ratio". This number is obtained by the
58 * (2^16 - 1) / (2^8 - 1) division. Which, in this case, tries to get
59 * the best color value in a pixel format with more possibilities.
60 * A similar idea applies to others RGB color conversions.
61 */
62 out_pixel->a = (u16)src_pixels[3] * 257;
63 out_pixel->r = (u16)src_pixels[2] * 257;
64 out_pixel->g = (u16)src_pixels[1] * 257;
65 out_pixel->b = (u16)src_pixels[0] * 257;
66}
67
68static void XRGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel)
69{
70 out_pixel->a = (u16)0xffff;
71 out_pixel->r = (u16)src_pixels[2] * 257;
72 out_pixel->g = (u16)src_pixels[1] * 257;
73 out_pixel->b = (u16)src_pixels[0] * 257;
74}
75
76static void ARGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel)
77{
78 u16 *pixels = (u16 *)src_pixels;
79
80 out_pixel->a = le16_to_cpu(pixels[3]);
81 out_pixel->r = le16_to_cpu(pixels[2]);
82 out_pixel->g = le16_to_cpu(pixels[1]);
83 out_pixel->b = le16_to_cpu(pixels[0]);
84}
85
86static void XRGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel)
87{
88 u16 *pixels = (u16 *)src_pixels;
89
90 out_pixel->a = (u16)0xffff;
91 out_pixel->r = le16_to_cpu(pixels[2]);
92 out_pixel->g = le16_to_cpu(pixels[1]);
93 out_pixel->b = le16_to_cpu(pixels[0]);
94}
95
96static void RGB565_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel)
97{
98 u16 *pixels = (u16 *)src_pixels;
99
100 s64 fp_rb_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 31));
101 s64 fp_g_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 63));
102
103 u16 rgb_565 = le16_to_cpu(*pixels);
104 s64 fp_r = drm_int2fixp(a: (rgb_565 >> 11) & 0x1f);
105 s64 fp_g = drm_int2fixp(a: (rgb_565 >> 5) & 0x3f);
106 s64 fp_b = drm_int2fixp(a: rgb_565 & 0x1f);
107
108 out_pixel->a = (u16)0xffff;
109 out_pixel->r = drm_fixp2int_round(a: drm_fixp_mul(a: fp_r, b: fp_rb_ratio));
110 out_pixel->g = drm_fixp2int_round(a: drm_fixp_mul(a: fp_g, b: fp_g_ratio));
111 out_pixel->b = drm_fixp2int_round(a: drm_fixp_mul(a: fp_b, b: fp_rb_ratio));
112}
113
114/**
115 * vkms_compose_row - compose a single row of a plane
116 * @stage_buffer: output line with the composed pixels
117 * @plane: state of the plane that is being composed
118 * @y: y coordinate of the row
119 *
120 * This function composes a single row of a plane. It gets the source pixels
121 * through the y coordinate (see get_packed_src_addr()) and goes linearly
122 * through the source pixel, reading the pixels and converting it to
123 * ARGB16161616 (see the pixel_read() callback). For rotate-90 and rotate-270,
124 * the source pixels are not traversed linearly. The source pixels are queried
125 * on each iteration in order to traverse the pixels vertically.
126 */
127void vkms_compose_row(struct line_buffer *stage_buffer, struct vkms_plane_state *plane, int y)
128{
129 struct pixel_argb_u16 *out_pixels = stage_buffer->pixels;
130 struct vkms_frame_info *frame_info = plane->frame_info;
131 u8 *src_pixels = get_packed_src_addr(frame_info, y);
132 int limit = min_t(size_t, drm_rect_width(&frame_info->dst), stage_buffer->n_pixels);
133
134 for (size_t x = 0; x < limit; x++, src_pixels += frame_info->cpp) {
135 int x_pos = get_x_position(frame_info, limit, x);
136
137 if (drm_rotation_90_or_270(rotation: frame_info->rotation))
138 src_pixels = get_packed_src_addr(frame_info, y: x + frame_info->rotated.y1)
139 + frame_info->cpp * y;
140
141 plane->pixel_read(src_pixels, &out_pixels[x_pos]);
142 }
143}
144
145/*
146 * The following functions take an line of argb_u16 pixels from the
147 * src_buffer, convert them to a specific format, and store them in the
148 * destination.
149 *
150 * They are used in the `compose_active_planes` to convert and store a line
151 * from the src_buffer to the writeback buffer.
152 */
153static void argb_u16_to_ARGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel)
154{
155 /*
156 * This sequence below is important because the format's byte order is
157 * in little-endian. In the case of the ARGB8888 the memory is
158 * organized this way:
159 *
160 * | Addr | = blue channel
161 * | Addr + 1 | = green channel
162 * | Addr + 2 | = Red channel
163 * | Addr + 3 | = Alpha channel
164 */
165 dst_pixels[3] = DIV_ROUND_CLOSEST(in_pixel->a, 257);
166 dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257);
167 dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257);
168 dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257);
169}
170
171static void argb_u16_to_XRGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel)
172{
173 dst_pixels[3] = 0xff;
174 dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257);
175 dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257);
176 dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257);
177}
178
179static void argb_u16_to_ARGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel)
180{
181 u16 *pixels = (u16 *)dst_pixels;
182
183 pixels[3] = cpu_to_le16(in_pixel->a);
184 pixels[2] = cpu_to_le16(in_pixel->r);
185 pixels[1] = cpu_to_le16(in_pixel->g);
186 pixels[0] = cpu_to_le16(in_pixel->b);
187}
188
189static void argb_u16_to_XRGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel)
190{
191 u16 *pixels = (u16 *)dst_pixels;
192
193 pixels[3] = 0xffff;
194 pixels[2] = cpu_to_le16(in_pixel->r);
195 pixels[1] = cpu_to_le16(in_pixel->g);
196 pixels[0] = cpu_to_le16(in_pixel->b);
197}
198
199static void argb_u16_to_RGB565(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel)
200{
201 u16 *pixels = (u16 *)dst_pixels;
202
203 s64 fp_rb_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 31));
204 s64 fp_g_ratio = drm_fixp_div(a: drm_int2fixp(a: 65535), b: drm_int2fixp(a: 63));
205
206 s64 fp_r = drm_int2fixp(a: in_pixel->r);
207 s64 fp_g = drm_int2fixp(a: in_pixel->g);
208 s64 fp_b = drm_int2fixp(a: in_pixel->b);
209
210 u16 r = drm_fixp2int(a: drm_fixp_div(a: fp_r, b: fp_rb_ratio));
211 u16 g = drm_fixp2int(a: drm_fixp_div(a: fp_g, b: fp_g_ratio));
212 u16 b = drm_fixp2int(a: drm_fixp_div(a: fp_b, b: fp_rb_ratio));
213
214 *pixels = cpu_to_le16(r << 11 | g << 5 | b);
215}
216
217void vkms_writeback_row(struct vkms_writeback_job *wb,
218 const struct line_buffer *src_buffer, int y)
219{
220 struct vkms_frame_info *frame_info = &wb->wb_frame_info;
221 int x_dst = frame_info->dst.x1;
222 u8 *dst_pixels = packed_pixels_addr(frame_info, x: x_dst, y);
223 struct pixel_argb_u16 *in_pixels = src_buffer->pixels;
224 int x_limit = min_t(size_t, drm_rect_width(&frame_info->dst), src_buffer->n_pixels);
225
226 for (size_t x = 0; x < x_limit; x++, dst_pixels += frame_info->cpp)
227 wb->pixel_write(dst_pixels, &in_pixels[x]);
228}
229
230void *get_pixel_conversion_function(u32 format)
231{
232 switch (format) {
233 case DRM_FORMAT_ARGB8888:
234 return &ARGB8888_to_argb_u16;
235 case DRM_FORMAT_XRGB8888:
236 return &XRGB8888_to_argb_u16;
237 case DRM_FORMAT_ARGB16161616:
238 return &ARGB16161616_to_argb_u16;
239 case DRM_FORMAT_XRGB16161616:
240 return &XRGB16161616_to_argb_u16;
241 case DRM_FORMAT_RGB565:
242 return &RGB565_to_argb_u16;
243 default:
244 return NULL;
245 }
246}
247
248void *get_pixel_write_function(u32 format)
249{
250 switch (format) {
251 case DRM_FORMAT_ARGB8888:
252 return &argb_u16_to_ARGB8888;
253 case DRM_FORMAT_XRGB8888:
254 return &argb_u16_to_XRGB8888;
255 case DRM_FORMAT_ARGB16161616:
256 return &argb_u16_to_ARGB16161616;
257 case DRM_FORMAT_XRGB16161616:
258 return &argb_u16_to_XRGB16161616;
259 case DRM_FORMAT_RGB565:
260 return &argb_u16_to_RGB565;
261 default:
262 return NULL;
263 }
264}
265

source code of linux/drivers/gpu/drm/vkms/vkms_formats.c