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 12 /** 13 * pixel_offset() - Get the offset of the pixel at coordinates x/y in the first plane 14 * 15 * @frame_info: Buffer metadata 16 * @x: The x coordinate of the wanted pixel in the buffer 17 * @y: The y coordinate of the wanted pixel in the buffer 18 * 19 * The caller must ensure that the framebuffer associated with this request uses a pixel format 20 * where block_h == block_w == 1. 21 * If this requirement is not fulfilled, the resulting offset can point to an other pixel or 22 * outside of the buffer. 23 */ 24 static size_t pixel_offset(const struct vkms_frame_info *frame_info, int x, int y) 25 { 26 return frame_info->offset + (y * frame_info->pitch) 27 + (x * frame_info->cpp); 28 } 29 30 /** 31 * packed_pixels_addr() - Get the pointer to the block containing the pixel at the given 32 * coordinates 33 * 34 * @frame_info: Buffer metadata 35 * @x: The x (width) coordinate inside the plane 36 * @y: The y (height) coordinate inside the plane 37 * 38 * Takes the information stored in the frame_info, a pair of coordinates, and 39 * returns the address of the first color channel. 40 * This function assumes the channels are packed together, i.e. a color channel 41 * comes immediately after another in the memory. And therefore, this function 42 * doesn't work for YUV with chroma subsampling (e.g. YUV420 and NV21). 43 * 44 * The caller must ensure that the framebuffer associated with this request uses a pixel format 45 * where block_h == block_w == 1, otherwise the returned pointer can be outside the buffer. 46 */ 47 static void *packed_pixels_addr(const struct vkms_frame_info *frame_info, 48 int x, int y) 49 { 50 size_t offset = pixel_offset(frame_info, x, y); 51 52 return (u8 *)frame_info->map[0].vaddr + offset; 53 } 54 55 static void *get_packed_src_addr(const struct vkms_frame_info *frame_info, int y) 56 { 57 int x_src = frame_info->src.x1 >> 16; 58 int y_src = y - frame_info->rotated.y1 + (frame_info->src.y1 >> 16); 59 60 return packed_pixels_addr(frame_info, x_src, y_src); 61 } 62 63 static int get_x_position(const struct vkms_frame_info *frame_info, int limit, int x) 64 { 65 if (frame_info->rotation & (DRM_MODE_REFLECT_X | DRM_MODE_ROTATE_270)) 66 return limit - x - 1; 67 return x; 68 } 69 70 /* 71 * The following functions take pixel data from the buffer and convert them to the format 72 * ARGB16161616 in @out_pixel. 73 * 74 * They are used in the vkms_compose_row() function to handle multiple formats. 75 */ 76 77 static void ARGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) 78 { 79 /* 80 * The 257 is the "conversion ratio". This number is obtained by the 81 * (2^16 - 1) / (2^8 - 1) division. Which, in this case, tries to get 82 * the best color value in a pixel format with more possibilities. 83 * A similar idea applies to others RGB color conversions. 84 */ 85 out_pixel->a = (u16)src_pixels[3] * 257; 86 out_pixel->r = (u16)src_pixels[2] * 257; 87 out_pixel->g = (u16)src_pixels[1] * 257; 88 out_pixel->b = (u16)src_pixels[0] * 257; 89 } 90 91 static void XRGB8888_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) 92 { 93 out_pixel->a = (u16)0xffff; 94 out_pixel->r = (u16)src_pixels[2] * 257; 95 out_pixel->g = (u16)src_pixels[1] * 257; 96 out_pixel->b = (u16)src_pixels[0] * 257; 97 } 98 99 static void ARGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) 100 { 101 __le16 *pixels = (__force __le16 *)src_pixels; 102 103 out_pixel->a = le16_to_cpu(pixels[3]); 104 out_pixel->r = le16_to_cpu(pixels[2]); 105 out_pixel->g = le16_to_cpu(pixels[1]); 106 out_pixel->b = le16_to_cpu(pixels[0]); 107 } 108 109 static void XRGB16161616_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) 110 { 111 __le16 *pixels = (__force __le16 *)src_pixels; 112 113 out_pixel->a = (u16)0xffff; 114 out_pixel->r = le16_to_cpu(pixels[2]); 115 out_pixel->g = le16_to_cpu(pixels[1]); 116 out_pixel->b = le16_to_cpu(pixels[0]); 117 } 118 119 static void RGB565_to_argb_u16(u8 *src_pixels, struct pixel_argb_u16 *out_pixel) 120 { 121 __le16 *pixels = (__force __le16 *)src_pixels; 122 123 s64 fp_rb_ratio = drm_fixp_div(drm_int2fixp(65535), drm_int2fixp(31)); 124 s64 fp_g_ratio = drm_fixp_div(drm_int2fixp(65535), drm_int2fixp(63)); 125 126 u16 rgb_565 = le16_to_cpu(*pixels); 127 s64 fp_r = drm_int2fixp((rgb_565 >> 11) & 0x1f); 128 s64 fp_g = drm_int2fixp((rgb_565 >> 5) & 0x3f); 129 s64 fp_b = drm_int2fixp(rgb_565 & 0x1f); 130 131 out_pixel->a = (u16)0xffff; 132 out_pixel->r = drm_fixp2int_round(drm_fixp_mul(fp_r, fp_rb_ratio)); 133 out_pixel->g = drm_fixp2int_round(drm_fixp_mul(fp_g, fp_g_ratio)); 134 out_pixel->b = drm_fixp2int_round(drm_fixp_mul(fp_b, fp_rb_ratio)); 135 } 136 137 /** 138 * vkms_compose_row - compose a single row of a plane 139 * @stage_buffer: output line with the composed pixels 140 * @plane: state of the plane that is being composed 141 * @y: y coordinate of the row 142 * 143 * This function composes a single row of a plane. It gets the source pixels 144 * through the y coordinate (see get_packed_src_addr()) and goes linearly 145 * through the source pixel, reading the pixels and converting it to 146 * ARGB16161616 (see the pixel_read() callback). For rotate-90 and rotate-270, 147 * the source pixels are not traversed linearly. The source pixels are queried 148 * on each iteration in order to traverse the pixels vertically. 149 */ 150 void vkms_compose_row(struct line_buffer *stage_buffer, struct vkms_plane_state *plane, int y) 151 { 152 struct pixel_argb_u16 *out_pixels = stage_buffer->pixels; 153 struct vkms_frame_info *frame_info = plane->frame_info; 154 u8 *src_pixels = get_packed_src_addr(frame_info, y); 155 int limit = min_t(size_t, drm_rect_width(&frame_info->dst), stage_buffer->n_pixels); 156 157 for (size_t x = 0; x < limit; x++, src_pixels += frame_info->cpp) { 158 int x_pos = get_x_position(frame_info, limit, x); 159 160 if (drm_rotation_90_or_270(frame_info->rotation)) 161 src_pixels = get_packed_src_addr(frame_info, x + frame_info->rotated.y1) 162 + frame_info->cpp * y; 163 164 plane->pixel_read(src_pixels, &out_pixels[x_pos]); 165 } 166 } 167 168 /* 169 * The following functions take one &struct pixel_argb_u16 and convert it to a specific format. 170 * The result is stored in @dst_pixels. 171 * 172 * They are used in vkms_writeback_row() to convert and store a pixel from the src_buffer to 173 * the writeback buffer. 174 */ 175 static void argb_u16_to_ARGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) 176 { 177 /* 178 * This sequence below is important because the format's byte order is 179 * in little-endian. In the case of the ARGB8888 the memory is 180 * organized this way: 181 * 182 * | Addr | = blue channel 183 * | Addr + 1 | = green channel 184 * | Addr + 2 | = Red channel 185 * | Addr + 3 | = Alpha channel 186 */ 187 dst_pixels[3] = DIV_ROUND_CLOSEST(in_pixel->a, 257); 188 dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257); 189 dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257); 190 dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257); 191 } 192 193 static void argb_u16_to_XRGB8888(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) 194 { 195 dst_pixels[3] = 0xff; 196 dst_pixels[2] = DIV_ROUND_CLOSEST(in_pixel->r, 257); 197 dst_pixels[1] = DIV_ROUND_CLOSEST(in_pixel->g, 257); 198 dst_pixels[0] = DIV_ROUND_CLOSEST(in_pixel->b, 257); 199 } 200 201 static void argb_u16_to_ARGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) 202 { 203 __le16 *pixels = (__force __le16 *)dst_pixels; 204 205 pixels[3] = cpu_to_le16(in_pixel->a); 206 pixels[2] = cpu_to_le16(in_pixel->r); 207 pixels[1] = cpu_to_le16(in_pixel->g); 208 pixels[0] = cpu_to_le16(in_pixel->b); 209 } 210 211 static void argb_u16_to_XRGB16161616(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) 212 { 213 __le16 *pixels = (__force __le16 *)dst_pixels; 214 215 pixels[3] = cpu_to_le16(0xffff); 216 pixels[2] = cpu_to_le16(in_pixel->r); 217 pixels[1] = cpu_to_le16(in_pixel->g); 218 pixels[0] = cpu_to_le16(in_pixel->b); 219 } 220 221 static void argb_u16_to_RGB565(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel) 222 { 223 __le16 *pixels = (__force __le16 *)dst_pixels; 224 225 s64 fp_rb_ratio = drm_fixp_div(drm_int2fixp(65535), drm_int2fixp(31)); 226 s64 fp_g_ratio = drm_fixp_div(drm_int2fixp(65535), drm_int2fixp(63)); 227 228 s64 fp_r = drm_int2fixp(in_pixel->r); 229 s64 fp_g = drm_int2fixp(in_pixel->g); 230 s64 fp_b = drm_int2fixp(in_pixel->b); 231 232 u16 r = drm_fixp2int(drm_fixp_div(fp_r, fp_rb_ratio)); 233 u16 g = drm_fixp2int(drm_fixp_div(fp_g, fp_g_ratio)); 234 u16 b = drm_fixp2int(drm_fixp_div(fp_b, fp_rb_ratio)); 235 236 *pixels = cpu_to_le16(r << 11 | g << 5 | b); 237 } 238 239 /** 240 * vkms_writeback_row() - Generic loop for all supported writeback format. It is executed just 241 * after the blending to write a line in the writeback buffer. 242 * 243 * @wb: Job where to insert the final image 244 * @src_buffer: Line to write 245 * @y: Row to write in the writeback buffer 246 */ 247 void vkms_writeback_row(struct vkms_writeback_job *wb, 248 const struct line_buffer *src_buffer, int y) 249 { 250 struct vkms_frame_info *frame_info = &wb->wb_frame_info; 251 int x_dst = frame_info->dst.x1; 252 u8 *dst_pixels = packed_pixels_addr(frame_info, x_dst, y); 253 struct pixel_argb_u16 *in_pixels = src_buffer->pixels; 254 int x_limit = min_t(size_t, drm_rect_width(&frame_info->dst), src_buffer->n_pixels); 255 256 for (size_t x = 0; x < x_limit; x++, dst_pixels += frame_info->cpp) 257 wb->pixel_write(dst_pixels, &in_pixels[x]); 258 } 259 260 /** 261 * get_pixel_conversion_function() - Retrieve the correct read_pixel function for a specific 262 * format. The returned pointer is NULL for unsupported pixel formats. The caller must ensure that 263 * the pointer is valid before using it in a vkms_plane_state. 264 * 265 * @format: DRM_FORMAT_* value for which to obtain a conversion function (see [drm_fourcc.h]) 266 */ 267 void *get_pixel_conversion_function(u32 format) 268 { 269 switch (format) { 270 case DRM_FORMAT_ARGB8888: 271 return &ARGB8888_to_argb_u16; 272 case DRM_FORMAT_XRGB8888: 273 return &XRGB8888_to_argb_u16; 274 case DRM_FORMAT_ARGB16161616: 275 return &ARGB16161616_to_argb_u16; 276 case DRM_FORMAT_XRGB16161616: 277 return &XRGB16161616_to_argb_u16; 278 case DRM_FORMAT_RGB565: 279 return &RGB565_to_argb_u16; 280 default: 281 return NULL; 282 } 283 } 284 285 /** 286 * get_pixel_write_function() - Retrieve the correct write_pixel function for a specific format. 287 * The returned pointer is NULL for unsupported pixel formats. The caller must ensure that the 288 * pointer is valid before using it in a vkms_writeback_job. 289 * 290 * @format: DRM_FORMAT_* value for which to obtain a conversion function (see [drm_fourcc.h]) 291 */ 292 void *get_pixel_write_function(u32 format) 293 { 294 switch (format) { 295 case DRM_FORMAT_ARGB8888: 296 return &argb_u16_to_ARGB8888; 297 case DRM_FORMAT_XRGB8888: 298 return &argb_u16_to_XRGB8888; 299 case DRM_FORMAT_ARGB16161616: 300 return &argb_u16_to_ARGB16161616; 301 case DRM_FORMAT_XRGB16161616: 302 return &argb_u16_to_XRGB16161616; 303 case DRM_FORMAT_RGB565: 304 return &argb_u16_to_RGB565; 305 default: 306 return NULL; 307 } 308 } 309