Loading...
1// SPDX-License-Identifier: GPL-2.0 or MIT
2/*
3 * Copyright (C) 2016 Noralf Trønnes
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 */
10
11#include <linux/io.h>
12#include <linux/iosys-map.h>
13#include <linux/module.h>
14#include <linux/slab.h>
15
16#include <drm/drm_device.h>
17#include <drm/drm_format_helper.h>
18#include <drm/drm_framebuffer.h>
19#include <drm/drm_fourcc.h>
20#include <drm/drm_print.h>
21#include <drm/drm_rect.h>
22
23/**
24 * drm_format_conv_state_init - Initialize format-conversion state
25 * @state: The state to initialize
26 *
27 * Clears all fields in struct drm_format_conv_state. The state will
28 * be empty with no preallocated resources.
29 */
30void drm_format_conv_state_init(struct drm_format_conv_state *state)
31{
32 state->tmp.mem = NULL;
33 state->tmp.size = 0;
34 state->tmp.preallocated = false;
35}
36EXPORT_SYMBOL(drm_format_conv_state_init);
37
38/**
39 * drm_format_conv_state_copy - Copy format-conversion state
40 * @state: Destination state
41 * @old_state: Source state
42 *
43 * Copies format-conversion state from @old_state to @state; except for
44 * temporary storage.
45 */
46void drm_format_conv_state_copy(struct drm_format_conv_state *state,
47 const struct drm_format_conv_state *old_state)
48{
49 /*
50 * So far, there's only temporary storage here, which we don't
51 * duplicate. Just clear the fields.
52 */
53 state->tmp.mem = NULL;
54 state->tmp.size = 0;
55 state->tmp.preallocated = false;
56}
57EXPORT_SYMBOL(drm_format_conv_state_copy);
58
59/**
60 * drm_format_conv_state_reserve - Allocates storage for format conversion
61 * @state: The format-conversion state
62 * @new_size: The minimum allocation size
63 * @flags: Flags for kmalloc()
64 *
65 * Allocates at least @new_size bytes and returns a pointer to the memory
66 * range. After calling this function, previously returned memory blocks
67 * are invalid. It's best to collect all memory requirements of a format
68 * conversion and call this function once to allocate the range.
69 *
70 * Returns:
71 * A pointer to the allocated memory range, or NULL otherwise.
72 */
73void *drm_format_conv_state_reserve(struct drm_format_conv_state *state,
74 size_t new_size, gfp_t flags)
75{
76 void *mem;
77
78 if (new_size <= state->tmp.size)
79 goto out;
80 else if (state->tmp.preallocated)
81 return NULL;
82
83 mem = krealloc(state->tmp.mem, new_size, flags);
84 if (!mem)
85 return NULL;
86
87 state->tmp.mem = mem;
88 state->tmp.size = new_size;
89
90out:
91 return state->tmp.mem;
92}
93EXPORT_SYMBOL(drm_format_conv_state_reserve);
94
95/**
96 * drm_format_conv_state_release - Releases an format-conversion storage
97 * @state: The format-conversion state
98 *
99 * Releases the memory range references by the format-conversion state.
100 * After this call, all pointers to the memory are invalid. Prefer
101 * drm_format_conv_state_init() for cleaning up and unloading a driver.
102 */
103void drm_format_conv_state_release(struct drm_format_conv_state *state)
104{
105 if (state->tmp.preallocated)
106 return;
107
108 kfree(state->tmp.mem);
109 state->tmp.mem = NULL;
110 state->tmp.size = 0;
111}
112EXPORT_SYMBOL(drm_format_conv_state_release);
113
114static unsigned int clip_offset(const struct drm_rect *clip, unsigned int pitch, unsigned int cpp)
115{
116 return clip->y1 * pitch + clip->x1 * cpp;
117}
118
119/**
120 * drm_fb_clip_offset - Returns the clipping rectangles byte-offset in a framebuffer
121 * @pitch: Framebuffer line pitch in byte
122 * @format: Framebuffer format
123 * @clip: Clip rectangle
124 *
125 * Returns:
126 * The byte offset of the clip rectangle's top-left corner within the framebuffer.
127 */
128unsigned int drm_fb_clip_offset(unsigned int pitch, const struct drm_format_info *format,
129 const struct drm_rect *clip)
130{
131 return clip_offset(clip, pitch, format->cpp[0]);
132}
133EXPORT_SYMBOL(drm_fb_clip_offset);
134
135/* TODO: Make this function work with multi-plane formats. */
136static int __drm_fb_xfrm(void *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
137 const void *vaddr, const struct drm_framebuffer *fb,
138 const struct drm_rect *clip, bool vaddr_cached_hint,
139 struct drm_format_conv_state *state,
140 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
141{
142 unsigned long linepixels = drm_rect_width(clip);
143 unsigned long lines = drm_rect_height(clip);
144 size_t sbuf_len = linepixels * fb->format->cpp[0];
145 void *stmp = NULL;
146 unsigned long i;
147 const void *sbuf;
148
149 /*
150 * Some source buffers, such as DMA memory, use write-combine
151 * caching, so reads are uncached. Speed up access by fetching
152 * one line at a time.
153 */
154 if (!vaddr_cached_hint) {
155 stmp = drm_format_conv_state_reserve(state, sbuf_len, GFP_KERNEL);
156 if (!stmp)
157 return -ENOMEM;
158 }
159
160 if (!dst_pitch)
161 dst_pitch = drm_rect_width(clip) * dst_pixsize;
162 vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
163
164 for (i = 0; i < lines; ++i) {
165 if (stmp)
166 sbuf = memcpy(stmp, vaddr, sbuf_len);
167 else
168 sbuf = vaddr;
169 xfrm_line(dst, sbuf, linepixels);
170 vaddr += fb->pitches[0];
171 dst += dst_pitch;
172 }
173
174 return 0;
175}
176
177/* TODO: Make this function work with multi-plane formats. */
178static int __drm_fb_xfrm_toio(void __iomem *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
179 const void *vaddr, const struct drm_framebuffer *fb,
180 const struct drm_rect *clip, bool vaddr_cached_hint,
181 struct drm_format_conv_state *state,
182 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
183{
184 unsigned long linepixels = drm_rect_width(clip);
185 unsigned long lines = drm_rect_height(clip);
186 size_t dbuf_len = linepixels * dst_pixsize;
187 size_t stmp_off = round_up(dbuf_len, ARCH_KMALLOC_MINALIGN); /* for sbuf alignment */
188 size_t sbuf_len = linepixels * fb->format->cpp[0];
189 void *stmp = NULL;
190 unsigned long i;
191 const void *sbuf;
192 void *dbuf;
193
194 if (vaddr_cached_hint) {
195 dbuf = drm_format_conv_state_reserve(state, dbuf_len, GFP_KERNEL);
196 } else {
197 dbuf = drm_format_conv_state_reserve(state, stmp_off + sbuf_len, GFP_KERNEL);
198 stmp = dbuf + stmp_off;
199 }
200 if (!dbuf)
201 return -ENOMEM;
202
203 if (!dst_pitch)
204 dst_pitch = linepixels * dst_pixsize;
205 vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
206
207 for (i = 0; i < lines; ++i) {
208 if (stmp)
209 sbuf = memcpy(stmp, vaddr, sbuf_len);
210 else
211 sbuf = vaddr;
212 xfrm_line(dbuf, sbuf, linepixels);
213 memcpy_toio(dst, dbuf, dbuf_len);
214 vaddr += fb->pitches[0];
215 dst += dst_pitch;
216 }
217
218 return 0;
219}
220
221/* TODO: Make this function work with multi-plane formats. */
222static int drm_fb_xfrm(struct iosys_map *dst,
223 const unsigned int *dst_pitch, const u8 *dst_pixsize,
224 const struct iosys_map *src, const struct drm_framebuffer *fb,
225 const struct drm_rect *clip, bool vaddr_cached_hint,
226 struct drm_format_conv_state *state,
227 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
228{
229 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
230 0, 0, 0, 0
231 };
232
233 if (!dst_pitch)
234 dst_pitch = default_dst_pitch;
235
236 /* TODO: handle src in I/O memory here */
237 if (dst[0].is_iomem)
238 return __drm_fb_xfrm_toio(dst[0].vaddr_iomem, dst_pitch[0], dst_pixsize[0],
239 src[0].vaddr, fb, clip, vaddr_cached_hint, state,
240 xfrm_line);
241 else
242 return __drm_fb_xfrm(dst[0].vaddr, dst_pitch[0], dst_pixsize[0],
243 src[0].vaddr, fb, clip, vaddr_cached_hint, state,
244 xfrm_line);
245}
246
247/**
248 * drm_fb_memcpy - Copy clip buffer
249 * @dst: Array of destination buffers
250 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
251 * within @dst; can be NULL if scanlines are stored next to each other.
252 * @src: Array of source buffers
253 * @fb: DRM framebuffer
254 * @clip: Clip rectangle area to copy
255 *
256 * This function copies parts of a framebuffer to display memory. Destination and
257 * framebuffer formats must match. No conversion takes place. The parameters @dst,
258 * @dst_pitch and @src refer to arrays. Each array must have at least as many entries
259 * as there are planes in @fb's format. Each entry stores the value for the format's
260 * respective color plane at the same index.
261 *
262 * This function does not apply clipping on @dst (i.e. the destination is at the
263 * top-left corner).
264 */
265void drm_fb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,
266 const struct iosys_map *src, const struct drm_framebuffer *fb,
267 const struct drm_rect *clip)
268{
269 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
270 0, 0, 0, 0
271 };
272
273 const struct drm_format_info *format = fb->format;
274 unsigned int i, y, lines = drm_rect_height(clip);
275
276 if (!dst_pitch)
277 dst_pitch = default_dst_pitch;
278
279 for (i = 0; i < format->num_planes; ++i) {
280 unsigned int bpp_i = drm_format_info_bpp(format, i);
281 unsigned int cpp_i = DIV_ROUND_UP(bpp_i, 8);
282 size_t len_i = DIV_ROUND_UP(drm_rect_width(clip) * bpp_i, 8);
283 unsigned int dst_pitch_i = dst_pitch[i];
284 struct iosys_map dst_i = dst[i];
285 struct iosys_map src_i = src[i];
286
287 if (!dst_pitch_i)
288 dst_pitch_i = len_i;
289
290 iosys_map_incr(&src_i, clip_offset(clip, fb->pitches[i], cpp_i));
291 for (y = 0; y < lines; y++) {
292 /* TODO: handle src_i in I/O memory here */
293 iosys_map_memcpy_to(&dst_i, 0, src_i.vaddr, len_i);
294 iosys_map_incr(&src_i, fb->pitches[i]);
295 iosys_map_incr(&dst_i, dst_pitch_i);
296 }
297 }
298}
299EXPORT_SYMBOL(drm_fb_memcpy);
300
301static void drm_fb_swab16_line(void *dbuf, const void *sbuf, unsigned int pixels)
302{
303 u16 *dbuf16 = dbuf;
304 const u16 *sbuf16 = sbuf;
305 const u16 *send16 = sbuf16 + pixels;
306
307 while (sbuf16 < send16)
308 *dbuf16++ = swab16(*sbuf16++);
309}
310
311static void drm_fb_swab32_line(void *dbuf, const void *sbuf, unsigned int pixels)
312{
313 u32 *dbuf32 = dbuf;
314 const u32 *sbuf32 = sbuf;
315 const u32 *send32 = sbuf32 + pixels;
316
317 while (sbuf32 < send32)
318 *dbuf32++ = swab32(*sbuf32++);
319}
320
321/**
322 * drm_fb_swab - Swap bytes into clip buffer
323 * @dst: Array of destination buffers
324 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
325 * within @dst; can be NULL if scanlines are stored next to each other.
326 * @src: Array of source buffers
327 * @fb: DRM framebuffer
328 * @clip: Clip rectangle area to copy
329 * @cached: Source buffer is mapped cached (eg. not write-combined)
330 * @state: Transform and conversion state
331 *
332 * This function copies parts of a framebuffer to display memory and swaps per-pixel
333 * bytes during the process. Destination and framebuffer formats must match. The
334 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
335 * least as many entries as there are planes in @fb's format. Each entry stores the
336 * value for the format's respective color plane at the same index. If @cached is
337 * false a temporary buffer is used to cache one pixel line at a time to speed up
338 * slow uncached reads.
339 *
340 * This function does not apply clipping on @dst (i.e. the destination is at the
341 * top-left corner).
342 */
343void drm_fb_swab(struct iosys_map *dst, const unsigned int *dst_pitch,
344 const struct iosys_map *src, const struct drm_framebuffer *fb,
345 const struct drm_rect *clip, bool cached,
346 struct drm_format_conv_state *state)
347{
348 const struct drm_format_info *format = fb->format;
349 u8 cpp = DIV_ROUND_UP(drm_format_info_bpp(format, 0), 8);
350 void (*swab_line)(void *dbuf, const void *sbuf, unsigned int npixels);
351
352 switch (cpp) {
353 case 4:
354 swab_line = drm_fb_swab32_line;
355 break;
356 case 2:
357 swab_line = drm_fb_swab16_line;
358 break;
359 default:
360 drm_warn_once(fb->dev, "Format %p4cc has unsupported pixel size.\n",
361 &format->format);
362 return;
363 }
364
365 drm_fb_xfrm(dst, dst_pitch, &cpp, src, fb, clip, cached, state, swab_line);
366}
367EXPORT_SYMBOL(drm_fb_swab);
368
369static void drm_fb_xrgb8888_to_rgb332_line(void *dbuf, const void *sbuf, unsigned int pixels)
370{
371 u8 *dbuf8 = dbuf;
372 const __le32 *sbuf32 = sbuf;
373 unsigned int x;
374 u32 pix;
375
376 for (x = 0; x < pixels; x++) {
377 pix = le32_to_cpu(sbuf32[x]);
378 dbuf8[x] = ((pix & 0x00e00000) >> 16) |
379 ((pix & 0x0000e000) >> 11) |
380 ((pix & 0x000000c0) >> 6);
381 }
382}
383
384/**
385 * drm_fb_xrgb8888_to_rgb332 - Convert XRGB8888 to RGB332 clip buffer
386 * @dst: Array of RGB332 destination buffers
387 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
388 * within @dst; can be NULL if scanlines are stored next to each other.
389 * @src: Array of XRGB8888 source buffers
390 * @fb: DRM framebuffer
391 * @clip: Clip rectangle area to copy
392 * @state: Transform and conversion state
393 *
394 * This function copies parts of a framebuffer to display memory and converts the
395 * color format during the process. Destination and framebuffer formats must match. The
396 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
397 * least as many entries as there are planes in @fb's format. Each entry stores the
398 * value for the format's respective color plane at the same index.
399 *
400 * This function does not apply clipping on @dst (i.e. the destination is at the
401 * top-left corner).
402 *
403 * Drivers can use this function for RGB332 devices that don't support XRGB8888 natively.
404 */
405void drm_fb_xrgb8888_to_rgb332(struct iosys_map *dst, const unsigned int *dst_pitch,
406 const struct iosys_map *src, const struct drm_framebuffer *fb,
407 const struct drm_rect *clip, struct drm_format_conv_state *state)
408{
409 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
410 1,
411 };
412
413 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
414 drm_fb_xrgb8888_to_rgb332_line);
415}
416EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb332);
417
418static void drm_fb_xrgb8888_to_rgb565_line(void *dbuf, const void *sbuf, unsigned int pixels)
419{
420 __le16 *dbuf16 = dbuf;
421 const __le32 *sbuf32 = sbuf;
422 unsigned int x;
423 u16 val16;
424 u32 pix;
425
426 for (x = 0; x < pixels; x++) {
427 pix = le32_to_cpu(sbuf32[x]);
428 val16 = ((pix & 0x00F80000) >> 8) |
429 ((pix & 0x0000FC00) >> 5) |
430 ((pix & 0x000000F8) >> 3);
431 dbuf16[x] = cpu_to_le16(val16);
432 }
433}
434
435/* TODO: implement this helper as conversion to RGB565|BIG_ENDIAN */
436static void drm_fb_xrgb8888_to_rgb565_swab_line(void *dbuf, const void *sbuf,
437 unsigned int pixels)
438{
439 __le16 *dbuf16 = dbuf;
440 const __le32 *sbuf32 = sbuf;
441 unsigned int x;
442 u16 val16;
443 u32 pix;
444
445 for (x = 0; x < pixels; x++) {
446 pix = le32_to_cpu(sbuf32[x]);
447 val16 = ((pix & 0x00F80000) >> 8) |
448 ((pix & 0x0000FC00) >> 5) |
449 ((pix & 0x000000F8) >> 3);
450 dbuf16[x] = cpu_to_le16(swab16(val16));
451 }
452}
453
454/**
455 * drm_fb_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
456 * @dst: Array of RGB565 destination buffers
457 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
458 * within @dst; can be NULL if scanlines are stored next to each other.
459 * @src: Array of XRGB8888 source buffer
460 * @fb: DRM framebuffer
461 * @clip: Clip rectangle area to copy
462 * @state: Transform and conversion state
463 * @swab: Swap bytes
464 *
465 * This function copies parts of a framebuffer to display memory and converts the
466 * color format during the process. Destination and framebuffer formats must match. The
467 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
468 * least as many entries as there are planes in @fb's format. Each entry stores the
469 * value for the format's respective color plane at the same index.
470 *
471 * This function does not apply clipping on @dst (i.e. the destination is at the
472 * top-left corner).
473 *
474 * Drivers can use this function for RGB565 devices that don't support XRGB8888 natively.
475 */
476void drm_fb_xrgb8888_to_rgb565(struct iosys_map *dst, const unsigned int *dst_pitch,
477 const struct iosys_map *src, const struct drm_framebuffer *fb,
478 const struct drm_rect *clip, struct drm_format_conv_state *state,
479 bool swab)
480{
481 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
482 2,
483 };
484
485 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels);
486
487 if (swab)
488 xfrm_line = drm_fb_xrgb8888_to_rgb565_swab_line;
489 else
490 xfrm_line = drm_fb_xrgb8888_to_rgb565_line;
491
492 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state, xfrm_line);
493}
494EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb565);
495
496static void drm_fb_xrgb8888_to_xrgb1555_line(void *dbuf, const void *sbuf, unsigned int pixels)
497{
498 __le16 *dbuf16 = dbuf;
499 const __le32 *sbuf32 = sbuf;
500 unsigned int x;
501 u16 val16;
502 u32 pix;
503
504 for (x = 0; x < pixels; x++) {
505 pix = le32_to_cpu(sbuf32[x]);
506 val16 = ((pix & 0x00f80000) >> 9) |
507 ((pix & 0x0000f800) >> 6) |
508 ((pix & 0x000000f8) >> 3);
509 dbuf16[x] = cpu_to_le16(val16);
510 }
511}
512
513/**
514 * drm_fb_xrgb8888_to_xrgb1555 - Convert XRGB8888 to XRGB1555 clip buffer
515 * @dst: Array of XRGB1555 destination buffers
516 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
517 * within @dst; can be NULL if scanlines are stored next to each other.
518 * @src: Array of XRGB8888 source buffer
519 * @fb: DRM framebuffer
520 * @clip: Clip rectangle area to copy
521 * @state: Transform and conversion state
522 *
523 * This function copies parts of a framebuffer to display memory and converts
524 * the color format during the process. The parameters @dst, @dst_pitch and
525 * @src refer to arrays. Each array must have at least as many entries as
526 * there are planes in @fb's format. Each entry stores the value for the
527 * format's respective color plane at the same index.
528 *
529 * This function does not apply clipping on @dst (i.e. the destination is at the
530 * top-left corner).
531 *
532 * Drivers can use this function for XRGB1555 devices that don't support
533 * XRGB8888 natively.
534 */
535void drm_fb_xrgb8888_to_xrgb1555(struct iosys_map *dst, const unsigned int *dst_pitch,
536 const struct iosys_map *src, const struct drm_framebuffer *fb,
537 const struct drm_rect *clip, struct drm_format_conv_state *state)
538{
539 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
540 2,
541 };
542
543 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
544 drm_fb_xrgb8888_to_xrgb1555_line);
545}
546EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb1555);
547
548static void drm_fb_xrgb8888_to_argb1555_line(void *dbuf, const void *sbuf, unsigned int pixels)
549{
550 __le16 *dbuf16 = dbuf;
551 const __le32 *sbuf32 = sbuf;
552 unsigned int x;
553 u16 val16;
554 u32 pix;
555
556 for (x = 0; x < pixels; x++) {
557 pix = le32_to_cpu(sbuf32[x]);
558 val16 = BIT(15) | /* set alpha bit */
559 ((pix & 0x00f80000) >> 9) |
560 ((pix & 0x0000f800) >> 6) |
561 ((pix & 0x000000f8) >> 3);
562 dbuf16[x] = cpu_to_le16(val16);
563 }
564}
565
566/**
567 * drm_fb_xrgb8888_to_argb1555 - Convert XRGB8888 to ARGB1555 clip buffer
568 * @dst: Array of ARGB1555 destination buffers
569 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
570 * within @dst; can be NULL if scanlines are stored next to each other.
571 * @src: Array of XRGB8888 source buffer
572 * @fb: DRM framebuffer
573 * @clip: Clip rectangle area to copy
574 * @state: Transform and conversion state
575 *
576 * This function copies parts of a framebuffer to display memory and converts
577 * the color format during the process. The parameters @dst, @dst_pitch and
578 * @src refer to arrays. Each array must have at least as many entries as
579 * there are planes in @fb's format. Each entry stores the value for the
580 * format's respective color plane at the same index.
581 *
582 * This function does not apply clipping on @dst (i.e. the destination is at the
583 * top-left corner).
584 *
585 * Drivers can use this function for ARGB1555 devices that don't support
586 * XRGB8888 natively. It sets an opaque alpha channel as part of the conversion.
587 */
588void drm_fb_xrgb8888_to_argb1555(struct iosys_map *dst, const unsigned int *dst_pitch,
589 const struct iosys_map *src, const struct drm_framebuffer *fb,
590 const struct drm_rect *clip, struct drm_format_conv_state *state)
591{
592 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
593 2,
594 };
595
596 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
597 drm_fb_xrgb8888_to_argb1555_line);
598}
599EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb1555);
600
601static void drm_fb_xrgb8888_to_rgba5551_line(void *dbuf, const void *sbuf, unsigned int pixels)
602{
603 __le16 *dbuf16 = dbuf;
604 const __le32 *sbuf32 = sbuf;
605 unsigned int x;
606 u16 val16;
607 u32 pix;
608
609 for (x = 0; x < pixels; x++) {
610 pix = le32_to_cpu(sbuf32[x]);
611 val16 = ((pix & 0x00f80000) >> 8) |
612 ((pix & 0x0000f800) >> 5) |
613 ((pix & 0x000000f8) >> 2) |
614 BIT(0); /* set alpha bit */
615 dbuf16[x] = cpu_to_le16(val16);
616 }
617}
618
619/**
620 * drm_fb_xrgb8888_to_rgba5551 - Convert XRGB8888 to RGBA5551 clip buffer
621 * @dst: Array of RGBA5551 destination buffers
622 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
623 * within @dst; can be NULL if scanlines are stored next to each other.
624 * @src: Array of XRGB8888 source buffer
625 * @fb: DRM framebuffer
626 * @clip: Clip rectangle area to copy
627 * @state: Transform and conversion state
628 *
629 * This function copies parts of a framebuffer to display memory and converts
630 * the color format during the process. The parameters @dst, @dst_pitch and
631 * @src refer to arrays. Each array must have at least as many entries as
632 * there are planes in @fb's format. Each entry stores the value for the
633 * format's respective color plane at the same index.
634 *
635 * This function does not apply clipping on @dst (i.e. the destination is at the
636 * top-left corner).
637 *
638 * Drivers can use this function for RGBA5551 devices that don't support
639 * XRGB8888 natively. It sets an opaque alpha channel as part of the conversion.
640 */
641void drm_fb_xrgb8888_to_rgba5551(struct iosys_map *dst, const unsigned int *dst_pitch,
642 const struct iosys_map *src, const struct drm_framebuffer *fb,
643 const struct drm_rect *clip, struct drm_format_conv_state *state)
644{
645 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
646 2,
647 };
648
649 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
650 drm_fb_xrgb8888_to_rgba5551_line);
651}
652EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgba5551);
653
654static void drm_fb_xrgb8888_to_rgb888_line(void *dbuf, const void *sbuf, unsigned int pixels)
655{
656 u8 *dbuf8 = dbuf;
657 const __le32 *sbuf32 = sbuf;
658 unsigned int x;
659 u32 pix;
660
661 for (x = 0; x < pixels; x++) {
662 pix = le32_to_cpu(sbuf32[x]);
663 /* write blue-green-red to output in little endianness */
664 *dbuf8++ = (pix & 0x000000FF) >> 0;
665 *dbuf8++ = (pix & 0x0000FF00) >> 8;
666 *dbuf8++ = (pix & 0x00FF0000) >> 16;
667 }
668}
669
670/**
671 * drm_fb_xrgb8888_to_rgb888 - Convert XRGB8888 to RGB888 clip buffer
672 * @dst: Array of RGB888 destination buffers
673 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
674 * within @dst; can be NULL if scanlines are stored next to each other.
675 * @src: Array of XRGB8888 source buffers
676 * @fb: DRM framebuffer
677 * @clip: Clip rectangle area to copy
678 * @state: Transform and conversion state
679 *
680 * This function copies parts of a framebuffer to display memory and converts the
681 * color format during the process. Destination and framebuffer formats must match. The
682 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
683 * least as many entries as there are planes in @fb's format. Each entry stores the
684 * value for the format's respective color plane at the same index.
685 *
686 * This function does not apply clipping on @dst (i.e. the destination is at the
687 * top-left corner).
688 *
689 * Drivers can use this function for RGB888 devices that don't natively
690 * support XRGB8888.
691 */
692void drm_fb_xrgb8888_to_rgb888(struct iosys_map *dst, const unsigned int *dst_pitch,
693 const struct iosys_map *src, const struct drm_framebuffer *fb,
694 const struct drm_rect *clip, struct drm_format_conv_state *state)
695{
696 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
697 3,
698 };
699
700 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
701 drm_fb_xrgb8888_to_rgb888_line);
702}
703EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb888);
704
705static void drm_fb_xrgb8888_to_argb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
706{
707 __le32 *dbuf32 = dbuf;
708 const __le32 *sbuf32 = sbuf;
709 unsigned int x;
710 u32 pix;
711
712 for (x = 0; x < pixels; x++) {
713 pix = le32_to_cpu(sbuf32[x]);
714 pix |= GENMASK(31, 24); /* fill alpha bits */
715 dbuf32[x] = cpu_to_le32(pix);
716 }
717}
718
719/**
720 * drm_fb_xrgb8888_to_argb8888 - Convert XRGB8888 to ARGB8888 clip buffer
721 * @dst: Array of ARGB8888 destination buffers
722 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
723 * within @dst; can be NULL if scanlines are stored next to each other.
724 * @src: Array of XRGB8888 source buffer
725 * @fb: DRM framebuffer
726 * @clip: Clip rectangle area to copy
727 * @state: Transform and conversion state
728 *
729 * This function copies parts of a framebuffer to display memory and converts the
730 * color format during the process. The parameters @dst, @dst_pitch and @src refer
731 * to arrays. Each array must have at least as many entries as there are planes in
732 * @fb's format. Each entry stores the value for the format's respective color plane
733 * at the same index.
734 *
735 * This function does not apply clipping on @dst (i.e. the destination is at the
736 * top-left corner).
737 *
738 * Drivers can use this function for ARGB8888 devices that don't support XRGB8888
739 * natively. It sets an opaque alpha channel as part of the conversion.
740 */
741void drm_fb_xrgb8888_to_argb8888(struct iosys_map *dst, const unsigned int *dst_pitch,
742 const struct iosys_map *src, const struct drm_framebuffer *fb,
743 const struct drm_rect *clip, struct drm_format_conv_state *state)
744{
745 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
746 4,
747 };
748
749 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
750 drm_fb_xrgb8888_to_argb8888_line);
751}
752EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb8888);
753
754static void drm_fb_xrgb8888_to_abgr8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
755{
756 __le32 *dbuf32 = dbuf;
757 const __le32 *sbuf32 = sbuf;
758 unsigned int x;
759 u32 pix;
760
761 for (x = 0; x < pixels; x++) {
762 pix = le32_to_cpu(sbuf32[x]);
763 pix = ((pix & 0x00ff0000) >> 16) << 0 |
764 ((pix & 0x0000ff00) >> 8) << 8 |
765 ((pix & 0x000000ff) >> 0) << 16 |
766 GENMASK(31, 24); /* fill alpha bits */
767 *dbuf32++ = cpu_to_le32(pix);
768 }
769}
770
771static void drm_fb_xrgb8888_to_abgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,
772 const struct iosys_map *src,
773 const struct drm_framebuffer *fb,
774 const struct drm_rect *clip,
775 struct drm_format_conv_state *state)
776{
777 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
778 4,
779 };
780
781 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
782 drm_fb_xrgb8888_to_abgr8888_line);
783}
784
785static void drm_fb_xrgb8888_to_xbgr8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
786{
787 __le32 *dbuf32 = dbuf;
788 const __le32 *sbuf32 = sbuf;
789 unsigned int x;
790 u32 pix;
791
792 for (x = 0; x < pixels; x++) {
793 pix = le32_to_cpu(sbuf32[x]);
794 pix = ((pix & 0x00ff0000) >> 16) << 0 |
795 ((pix & 0x0000ff00) >> 8) << 8 |
796 ((pix & 0x000000ff) >> 0) << 16 |
797 ((pix & 0xff000000) >> 24) << 24;
798 *dbuf32++ = cpu_to_le32(pix);
799 }
800}
801
802static void drm_fb_xrgb8888_to_xbgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,
803 const struct iosys_map *src,
804 const struct drm_framebuffer *fb,
805 const struct drm_rect *clip,
806 struct drm_format_conv_state *state)
807{
808 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
809 4,
810 };
811
812 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
813 drm_fb_xrgb8888_to_xbgr8888_line);
814}
815
816static void drm_fb_xrgb8888_to_xrgb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
817{
818 __le32 *dbuf32 = dbuf;
819 const __le32 *sbuf32 = sbuf;
820 unsigned int x;
821 u32 val32;
822 u32 pix;
823
824 for (x = 0; x < pixels; x++) {
825 pix = le32_to_cpu(sbuf32[x]);
826 val32 = ((pix & 0x000000FF) << 2) |
827 ((pix & 0x0000FF00) << 4) |
828 ((pix & 0x00FF0000) << 6);
829 pix = val32 | ((val32 >> 8) & 0x00300C03);
830 *dbuf32++ = cpu_to_le32(pix);
831 }
832}
833
834/**
835 * drm_fb_xrgb8888_to_xrgb2101010 - Convert XRGB8888 to XRGB2101010 clip buffer
836 * @dst: Array of XRGB2101010 destination buffers
837 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
838 * within @dst; can be NULL if scanlines are stored next to each other.
839 * @src: Array of XRGB8888 source buffers
840 * @fb: DRM framebuffer
841 * @clip: Clip rectangle area to copy
842 * @state: Transform and conversion state
843 *
844 * This function copies parts of a framebuffer to display memory and converts the
845 * color format during the process. Destination and framebuffer formats must match. The
846 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
847 * least as many entries as there are planes in @fb's format. Each entry stores the
848 * value for the format's respective color plane at the same index.
849 *
850 * This function does not apply clipping on @dst (i.e. the destination is at the
851 * top-left corner).
852 *
853 * Drivers can use this function for XRGB2101010 devices that don't support XRGB8888
854 * natively.
855 */
856void drm_fb_xrgb8888_to_xrgb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,
857 const struct iosys_map *src, const struct drm_framebuffer *fb,
858 const struct drm_rect *clip,
859 struct drm_format_conv_state *state)
860{
861 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
862 4,
863 };
864
865 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
866 drm_fb_xrgb8888_to_xrgb2101010_line);
867}
868EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb2101010);
869
870static void drm_fb_xrgb8888_to_argb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
871{
872 __le32 *dbuf32 = dbuf;
873 const __le32 *sbuf32 = sbuf;
874 unsigned int x;
875 u32 val32;
876 u32 pix;
877
878 for (x = 0; x < pixels; x++) {
879 pix = le32_to_cpu(sbuf32[x]);
880 val32 = ((pix & 0x000000ff) << 2) |
881 ((pix & 0x0000ff00) << 4) |
882 ((pix & 0x00ff0000) << 6);
883 pix = GENMASK(31, 30) | /* set alpha bits */
884 val32 | ((val32 >> 8) & 0x00300c03);
885 *dbuf32++ = cpu_to_le32(pix);
886 }
887}
888
889/**
890 * drm_fb_xrgb8888_to_argb2101010 - Convert XRGB8888 to ARGB2101010 clip buffer
891 * @dst: Array of ARGB2101010 destination buffers
892 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
893 * within @dst; can be NULL if scanlines are stored next to each other.
894 * @src: Array of XRGB8888 source buffers
895 * @fb: DRM framebuffer
896 * @clip: Clip rectangle area to copy
897 * @state: Transform and conversion state
898 *
899 * This function copies parts of a framebuffer to display memory and converts
900 * the color format during the process. The parameters @dst, @dst_pitch and
901 * @src refer to arrays. Each array must have at least as many entries as
902 * there are planes in @fb's format. Each entry stores the value for the
903 * format's respective color plane at the same index.
904 *
905 * This function does not apply clipping on @dst (i.e. the destination is at the
906 * top-left corner).
907 *
908 * Drivers can use this function for ARGB2101010 devices that don't support XRGB8888
909 * natively.
910 */
911void drm_fb_xrgb8888_to_argb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,
912 const struct iosys_map *src, const struct drm_framebuffer *fb,
913 const struct drm_rect *clip,
914 struct drm_format_conv_state *state)
915{
916 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
917 4,
918 };
919
920 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
921 drm_fb_xrgb8888_to_argb2101010_line);
922}
923EXPORT_SYMBOL(drm_fb_xrgb8888_to_argb2101010);
924
925static void drm_fb_xrgb8888_to_gray8_line(void *dbuf, const void *sbuf, unsigned int pixels)
926{
927 u8 *dbuf8 = dbuf;
928 const __le32 *sbuf32 = sbuf;
929 unsigned int x;
930
931 for (x = 0; x < pixels; x++) {
932 u32 pix = le32_to_cpu(sbuf32[x]);
933 u8 r = (pix & 0x00ff0000) >> 16;
934 u8 g = (pix & 0x0000ff00) >> 8;
935 u8 b = pix & 0x000000ff;
936
937 /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
938 *dbuf8++ = (3 * r + 6 * g + b) / 10;
939 }
940}
941
942/**
943 * drm_fb_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
944 * @dst: Array of 8-bit grayscale destination buffers
945 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
946 * within @dst; can be NULL if scanlines are stored next to each other.
947 * @src: Array of XRGB8888 source buffers
948 * @fb: DRM framebuffer
949 * @clip: Clip rectangle area to copy
950 * @state: Transform and conversion state
951 *
952 * This function copies parts of a framebuffer to display memory and converts the
953 * color format during the process. Destination and framebuffer formats must match. The
954 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
955 * least as many entries as there are planes in @fb's format. Each entry stores the
956 * value for the format's respective color plane at the same index.
957 *
958 * This function does not apply clipping on @dst (i.e. the destination is at the
959 * top-left corner).
960 *
961 * DRM doesn't have native monochrome or grayscale support. Drivers can use this
962 * function for grayscale devices that don't support XRGB8888 natively.Such
963 * drivers can announce the commonly supported XR24 format to userspace and use
964 * this function to convert to the native format. Monochrome drivers will use the
965 * most significant bit, where 1 means foreground color and 0 background color.
966 * ITU BT.601 is being used for the RGB -> luma (brightness) conversion.
967 */
968void drm_fb_xrgb8888_to_gray8(struct iosys_map *dst, const unsigned int *dst_pitch,
969 const struct iosys_map *src, const struct drm_framebuffer *fb,
970 const struct drm_rect *clip, struct drm_format_conv_state *state)
971{
972 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
973 1,
974 };
975
976 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,
977 drm_fb_xrgb8888_to_gray8_line);
978}
979EXPORT_SYMBOL(drm_fb_xrgb8888_to_gray8);
980
981/**
982 * drm_fb_blit - Copy parts of a framebuffer to display memory
983 * @dst: Array of display-memory addresses to copy to
984 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
985 * within @dst; can be NULL if scanlines are stored next to each other.
986 * @dst_format: FOURCC code of the display's color format
987 * @src: The framebuffer memory to copy from
988 * @fb: The framebuffer to copy from
989 * @clip: Clip rectangle area to copy
990 * @state: Transform and conversion state
991 *
992 * This function copies parts of a framebuffer to display memory. If the
993 * formats of the display and the framebuffer mismatch, the blit function
994 * will attempt to convert between them during the process. The parameters @dst,
995 * @dst_pitch and @src refer to arrays. Each array must have at least as many
996 * entries as there are planes in @dst_format's format. Each entry stores the
997 * value for the format's respective color plane at the same index.
998 *
999 * This function does not apply clipping on @dst (i.e. the destination is at the
1000 * top-left corner).
1001 *
1002 * Returns:
1003 * 0 on success, or
1004 * -EINVAL if the color-format conversion failed, or
1005 * a negative error code otherwise.
1006 */
1007int drm_fb_blit(struct iosys_map *dst, const unsigned int *dst_pitch, uint32_t dst_format,
1008 const struct iosys_map *src, const struct drm_framebuffer *fb,
1009 const struct drm_rect *clip, struct drm_format_conv_state *state)
1010{
1011 uint32_t fb_format = fb->format->format;
1012
1013 if (fb_format == dst_format) {
1014 drm_fb_memcpy(dst, dst_pitch, src, fb, clip);
1015 return 0;
1016 } else if (fb_format == (dst_format | DRM_FORMAT_BIG_ENDIAN)) {
1017 drm_fb_swab(dst, dst_pitch, src, fb, clip, false, state);
1018 return 0;
1019 } else if (fb_format == (dst_format & ~DRM_FORMAT_BIG_ENDIAN)) {
1020 drm_fb_swab(dst, dst_pitch, src, fb, clip, false, state);
1021 return 0;
1022 } else if (fb_format == DRM_FORMAT_XRGB8888) {
1023 if (dst_format == DRM_FORMAT_RGB565) {
1024 drm_fb_xrgb8888_to_rgb565(dst, dst_pitch, src, fb, clip, state, false);
1025 return 0;
1026 } else if (dst_format == DRM_FORMAT_XRGB1555) {
1027 drm_fb_xrgb8888_to_xrgb1555(dst, dst_pitch, src, fb, clip, state);
1028 return 0;
1029 } else if (dst_format == DRM_FORMAT_ARGB1555) {
1030 drm_fb_xrgb8888_to_argb1555(dst, dst_pitch, src, fb, clip, state);
1031 return 0;
1032 } else if (dst_format == DRM_FORMAT_RGBA5551) {
1033 drm_fb_xrgb8888_to_rgba5551(dst, dst_pitch, src, fb, clip, state);
1034 return 0;
1035 } else if (dst_format == DRM_FORMAT_RGB888) {
1036 drm_fb_xrgb8888_to_rgb888(dst, dst_pitch, src, fb, clip, state);
1037 return 0;
1038 } else if (dst_format == DRM_FORMAT_ARGB8888) {
1039 drm_fb_xrgb8888_to_argb8888(dst, dst_pitch, src, fb, clip, state);
1040 return 0;
1041 } else if (dst_format == DRM_FORMAT_XBGR8888) {
1042 drm_fb_xrgb8888_to_xbgr8888(dst, dst_pitch, src, fb, clip, state);
1043 return 0;
1044 } else if (dst_format == DRM_FORMAT_ABGR8888) {
1045 drm_fb_xrgb8888_to_abgr8888(dst, dst_pitch, src, fb, clip, state);
1046 return 0;
1047 } else if (dst_format == DRM_FORMAT_XRGB2101010) {
1048 drm_fb_xrgb8888_to_xrgb2101010(dst, dst_pitch, src, fb, clip, state);
1049 return 0;
1050 } else if (dst_format == DRM_FORMAT_ARGB2101010) {
1051 drm_fb_xrgb8888_to_argb2101010(dst, dst_pitch, src, fb, clip, state);
1052 return 0;
1053 } else if (dst_format == DRM_FORMAT_BGRX8888) {
1054 drm_fb_swab(dst, dst_pitch, src, fb, clip, false, state);
1055 return 0;
1056 }
1057 }
1058
1059 drm_warn_once(fb->dev, "No conversion helper from %p4cc to %p4cc found.\n",
1060 &fb_format, &dst_format);
1061
1062 return -EINVAL;
1063}
1064EXPORT_SYMBOL(drm_fb_blit);
1065
1066static void drm_fb_gray8_to_mono_line(void *dbuf, const void *sbuf, unsigned int pixels)
1067{
1068 u8 *dbuf8 = dbuf;
1069 const u8 *sbuf8 = sbuf;
1070
1071 while (pixels) {
1072 unsigned int i, bits = min(pixels, 8U);
1073 u8 byte = 0;
1074
1075 for (i = 0; i < bits; i++, pixels--) {
1076 if (*sbuf8++ >= 128)
1077 byte |= BIT(i);
1078 }
1079 *dbuf8++ = byte;
1080 }
1081}
1082
1083/**
1084 * drm_fb_xrgb8888_to_mono - Convert XRGB8888 to monochrome
1085 * @dst: Array of monochrome destination buffers (0=black, 1=white)
1086 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
1087 * within @dst; can be NULL if scanlines are stored next to each other.
1088 * @src: Array of XRGB8888 source buffers
1089 * @fb: DRM framebuffer
1090 * @clip: Clip rectangle area to copy
1091 * @state: Transform and conversion state
1092 *
1093 * This function copies parts of a framebuffer to display memory and converts the
1094 * color format during the process. Destination and framebuffer formats must match. The
1095 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
1096 * least as many entries as there are planes in @fb's format. Each entry stores the
1097 * value for the format's respective color plane at the same index.
1098 *
1099 * This function does not apply clipping on @dst (i.e. the destination is at the
1100 * top-left corner). The first pixel (upper left corner of the clip rectangle) will
1101 * be converted and copied to the first bit (LSB) in the first byte of the monochrome
1102 * destination buffer. If the caller requires that the first pixel in a byte must
1103 * be located at an x-coordinate that is a multiple of 8, then the caller must take
1104 * care itself of supplying a suitable clip rectangle.
1105 *
1106 * DRM doesn't have native monochrome support. Drivers can use this function for
1107 * monochrome devices that don't support XRGB8888 natively. Such drivers can
1108 * announce the commonly supported XR24 format to userspace and use this function
1109 * to convert to the native format.
1110 *
1111 * This function uses drm_fb_xrgb8888_to_gray8() to convert to grayscale and
1112 * then the result is converted from grayscale to monochrome.
1113 */
1114void drm_fb_xrgb8888_to_mono(struct iosys_map *dst, const unsigned int *dst_pitch,
1115 const struct iosys_map *src, const struct drm_framebuffer *fb,
1116 const struct drm_rect *clip, struct drm_format_conv_state *state)
1117{
1118 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
1119 0, 0, 0, 0
1120 };
1121 unsigned int linepixels = drm_rect_width(clip);
1122 unsigned int lines = drm_rect_height(clip);
1123 unsigned int cpp = fb->format->cpp[0];
1124 unsigned int len_src32 = linepixels * cpp;
1125 struct drm_device *dev = fb->dev;
1126 void *vaddr = src[0].vaddr;
1127 unsigned int dst_pitch_0;
1128 unsigned int y;
1129 u8 *mono = dst[0].vaddr, *gray8;
1130 u32 *src32;
1131
1132 if (drm_WARN_ON(dev, fb->format->format != DRM_FORMAT_XRGB8888))
1133 return;
1134
1135 if (!dst_pitch)
1136 dst_pitch = default_dst_pitch;
1137 dst_pitch_0 = dst_pitch[0];
1138
1139 /*
1140 * The mono destination buffer contains 1 bit per pixel
1141 */
1142 if (!dst_pitch_0)
1143 dst_pitch_0 = DIV_ROUND_UP(linepixels, 8);
1144
1145 /*
1146 * The dma memory is write-combined so reads are uncached.
1147 * Speed up by fetching one line at a time.
1148 *
1149 * Also, format conversion from XR24 to monochrome are done
1150 * line-by-line but are converted to 8-bit grayscale as an
1151 * intermediate step.
1152 *
1153 * Allocate a buffer to be used for both copying from the cma
1154 * memory and to store the intermediate grayscale line pixels.
1155 */
1156 src32 = drm_format_conv_state_reserve(state, len_src32 + linepixels, GFP_KERNEL);
1157 if (!src32)
1158 return;
1159
1160 gray8 = (u8 *)src32 + len_src32;
1161
1162 vaddr += clip_offset(clip, fb->pitches[0], cpp);
1163 for (y = 0; y < lines; y++) {
1164 src32 = memcpy(src32, vaddr, len_src32);
1165 drm_fb_xrgb8888_to_gray8_line(gray8, src32, linepixels);
1166 drm_fb_gray8_to_mono_line(mono, gray8, linepixels);
1167 vaddr += fb->pitches[0];
1168 mono += dst_pitch_0;
1169 }
1170}
1171EXPORT_SYMBOL(drm_fb_xrgb8888_to_mono);
1172
1173static uint32_t drm_fb_nonalpha_fourcc(uint32_t fourcc)
1174{
1175 /* only handle formats with depth != 0 and alpha channel */
1176 switch (fourcc) {
1177 case DRM_FORMAT_ARGB1555:
1178 return DRM_FORMAT_XRGB1555;
1179 case DRM_FORMAT_ABGR1555:
1180 return DRM_FORMAT_XBGR1555;
1181 case DRM_FORMAT_RGBA5551:
1182 return DRM_FORMAT_RGBX5551;
1183 case DRM_FORMAT_BGRA5551:
1184 return DRM_FORMAT_BGRX5551;
1185 case DRM_FORMAT_ARGB8888:
1186 return DRM_FORMAT_XRGB8888;
1187 case DRM_FORMAT_ABGR8888:
1188 return DRM_FORMAT_XBGR8888;
1189 case DRM_FORMAT_RGBA8888:
1190 return DRM_FORMAT_RGBX8888;
1191 case DRM_FORMAT_BGRA8888:
1192 return DRM_FORMAT_BGRX8888;
1193 case DRM_FORMAT_ARGB2101010:
1194 return DRM_FORMAT_XRGB2101010;
1195 case DRM_FORMAT_ABGR2101010:
1196 return DRM_FORMAT_XBGR2101010;
1197 case DRM_FORMAT_RGBA1010102:
1198 return DRM_FORMAT_RGBX1010102;
1199 case DRM_FORMAT_BGRA1010102:
1200 return DRM_FORMAT_BGRX1010102;
1201 }
1202
1203 return fourcc;
1204}
1205
1206static bool is_listed_fourcc(const uint32_t *fourccs, size_t nfourccs, uint32_t fourcc)
1207{
1208 const uint32_t *fourccs_end = fourccs + nfourccs;
1209
1210 while (fourccs < fourccs_end) {
1211 if (*fourccs == fourcc)
1212 return true;
1213 ++fourccs;
1214 }
1215 return false;
1216}
1217
1218/**
1219 * drm_fb_build_fourcc_list - Filters a list of supported color formats against
1220 * the device's native formats
1221 * @dev: DRM device
1222 * @native_fourccs: 4CC codes of natively supported color formats
1223 * @native_nfourccs: The number of entries in @native_fourccs
1224 * @fourccs_out: Returns 4CC codes of supported color formats
1225 * @nfourccs_out: The number of available entries in @fourccs_out
1226 *
1227 * This function create a list of supported color format from natively
1228 * supported formats and additional emulated formats.
1229 * At a minimum, most userspace programs expect at least support for
1230 * XRGB8888 on the primary plane. Devices that have to emulate the
1231 * format, and possibly others, can use drm_fb_build_fourcc_list() to
1232 * create a list of supported color formats. The returned list can
1233 * be handed over to drm_universal_plane_init() et al. Native formats
1234 * will go before emulated formats. Native formats with alpha channel
1235 * will be replaced by such without, as primary planes usually don't
1236 * support alpha. Other heuristics might be applied
1237 * to optimize the order. Formats near the beginning of the list are
1238 * usually preferred over formats near the end of the list.
1239 *
1240 * Returns:
1241 * The number of color-formats 4CC codes returned in @fourccs_out.
1242 */
1243size_t drm_fb_build_fourcc_list(struct drm_device *dev,
1244 const u32 *native_fourccs, size_t native_nfourccs,
1245 u32 *fourccs_out, size_t nfourccs_out)
1246{
1247 /*
1248 * XRGB8888 is the default fallback format for most of userspace
1249 * and it's currently the only format that should be emulated for
1250 * the primary plane. Only if there's ever another default fallback,
1251 * it should be added here.
1252 */
1253 static const uint32_t extra_fourccs[] = {
1254 DRM_FORMAT_XRGB8888,
1255 };
1256 static const size_t extra_nfourccs = ARRAY_SIZE(extra_fourccs);
1257
1258 u32 *fourccs = fourccs_out;
1259 const u32 *fourccs_end = fourccs_out + nfourccs_out;
1260 size_t i;
1261
1262 /*
1263 * The device's native formats go first.
1264 */
1265
1266 for (i = 0; i < native_nfourccs; ++i) {
1267 /*
1268 * Several DTs, boot loaders and firmware report native
1269 * alpha formats that are non-alpha formats instead. So
1270 * replace alpha formats by non-alpha formats.
1271 */
1272 u32 fourcc = drm_fb_nonalpha_fourcc(native_fourccs[i]);
1273
1274 if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
1275 continue; /* skip duplicate entries */
1276 } else if (fourccs == fourccs_end) {
1277 drm_warn(dev, "Ignoring native format %p4cc\n", &fourcc);
1278 continue; /* end of available output buffer */
1279 }
1280
1281 drm_dbg_kms(dev, "adding native format %p4cc\n", &fourcc);
1282
1283 *fourccs = fourcc;
1284 ++fourccs;
1285 }
1286
1287 /*
1288 * The extra formats, emulated by the driver, go second.
1289 */
1290
1291 for (i = 0; (i < extra_nfourccs) && (fourccs < fourccs_end); ++i) {
1292 u32 fourcc = extra_fourccs[i];
1293
1294 if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
1295 continue; /* skip duplicate and native entries */
1296 } else if (fourccs == fourccs_end) {
1297 drm_warn(dev, "Ignoring emulated format %p4cc\n", &fourcc);
1298 continue; /* end of available output buffer */
1299 }
1300
1301 drm_dbg_kms(dev, "adding emulated format %p4cc\n", &fourcc);
1302
1303 *fourccs = fourcc;
1304 ++fourccs;
1305 }
1306
1307 return fourccs - fourccs_out;
1308}
1309EXPORT_SYMBOL(drm_fb_build_fourcc_list);
1// SPDX-License-Identifier: GPL-2.0 or MIT
2/*
3 * Copyright (C) 2016 Noralf Trønnes
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 */
10
11#include <linux/io.h>
12#include <linux/iosys-map.h>
13#include <linux/module.h>
14#include <linux/slab.h>
15
16#include <drm/drm_device.h>
17#include <drm/drm_format_helper.h>
18#include <drm/drm_framebuffer.h>
19#include <drm/drm_fourcc.h>
20#include <drm/drm_print.h>
21#include <drm/drm_rect.h>
22
23static unsigned int clip_offset(const struct drm_rect *clip, unsigned int pitch, unsigned int cpp)
24{
25 return clip->y1 * pitch + clip->x1 * cpp;
26}
27
28/**
29 * drm_fb_clip_offset - Returns the clipping rectangles byte-offset in a framebuffer
30 * @pitch: Framebuffer line pitch in byte
31 * @format: Framebuffer format
32 * @clip: Clip rectangle
33 *
34 * Returns:
35 * The byte offset of the clip rectangle's top-left corner within the framebuffer.
36 */
37unsigned int drm_fb_clip_offset(unsigned int pitch, const struct drm_format_info *format,
38 const struct drm_rect *clip)
39{
40 return clip_offset(clip, pitch, format->cpp[0]);
41}
42EXPORT_SYMBOL(drm_fb_clip_offset);
43
44/* TODO: Make this function work with multi-plane formats. */
45static int __drm_fb_xfrm(void *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
46 const void *vaddr, const struct drm_framebuffer *fb,
47 const struct drm_rect *clip, bool vaddr_cached_hint,
48 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
49{
50 unsigned long linepixels = drm_rect_width(clip);
51 unsigned long lines = drm_rect_height(clip);
52 size_t sbuf_len = linepixels * fb->format->cpp[0];
53 void *stmp = NULL;
54 unsigned long i;
55 const void *sbuf;
56
57 /*
58 * Some source buffers, such as DMA memory, use write-combine
59 * caching, so reads are uncached. Speed up access by fetching
60 * one line at a time.
61 */
62 if (!vaddr_cached_hint) {
63 stmp = kmalloc(sbuf_len, GFP_KERNEL);
64 if (!stmp)
65 return -ENOMEM;
66 }
67
68 if (!dst_pitch)
69 dst_pitch = drm_rect_width(clip) * dst_pixsize;
70 vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
71
72 for (i = 0; i < lines; ++i) {
73 if (stmp)
74 sbuf = memcpy(stmp, vaddr, sbuf_len);
75 else
76 sbuf = vaddr;
77 xfrm_line(dst, sbuf, linepixels);
78 vaddr += fb->pitches[0];
79 dst += dst_pitch;
80 }
81
82 kfree(stmp);
83
84 return 0;
85}
86
87/* TODO: Make this function work with multi-plane formats. */
88static int __drm_fb_xfrm_toio(void __iomem *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
89 const void *vaddr, const struct drm_framebuffer *fb,
90 const struct drm_rect *clip, bool vaddr_cached_hint,
91 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
92{
93 unsigned long linepixels = drm_rect_width(clip);
94 unsigned long lines = drm_rect_height(clip);
95 size_t dbuf_len = linepixels * dst_pixsize;
96 size_t stmp_off = round_up(dbuf_len, ARCH_KMALLOC_MINALIGN); /* for sbuf alignment */
97 size_t sbuf_len = linepixels * fb->format->cpp[0];
98 void *stmp = NULL;
99 unsigned long i;
100 const void *sbuf;
101 void *dbuf;
102
103 if (vaddr_cached_hint) {
104 dbuf = kmalloc(dbuf_len, GFP_KERNEL);
105 } else {
106 dbuf = kmalloc(stmp_off + sbuf_len, GFP_KERNEL);
107 stmp = dbuf + stmp_off;
108 }
109 if (!dbuf)
110 return -ENOMEM;
111
112 if (!dst_pitch)
113 dst_pitch = linepixels * dst_pixsize;
114 vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
115
116 for (i = 0; i < lines; ++i) {
117 if (stmp)
118 sbuf = memcpy(stmp, vaddr, sbuf_len);
119 else
120 sbuf = vaddr;
121 xfrm_line(dbuf, sbuf, linepixels);
122 memcpy_toio(dst, dbuf, dbuf_len);
123 vaddr += fb->pitches[0];
124 dst += dst_pitch;
125 }
126
127 kfree(dbuf);
128
129 return 0;
130}
131
132/* TODO: Make this function work with multi-plane formats. */
133static int drm_fb_xfrm(struct iosys_map *dst,
134 const unsigned int *dst_pitch, const u8 *dst_pixsize,
135 const struct iosys_map *src, const struct drm_framebuffer *fb,
136 const struct drm_rect *clip, bool vaddr_cached_hint,
137 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
138{
139 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
140 0, 0, 0, 0
141 };
142
143 if (!dst_pitch)
144 dst_pitch = default_dst_pitch;
145
146 /* TODO: handle src in I/O memory here */
147 if (dst[0].is_iomem)
148 return __drm_fb_xfrm_toio(dst[0].vaddr_iomem, dst_pitch[0], dst_pixsize[0],
149 src[0].vaddr, fb, clip, vaddr_cached_hint, xfrm_line);
150 else
151 return __drm_fb_xfrm(dst[0].vaddr, dst_pitch[0], dst_pixsize[0],
152 src[0].vaddr, fb, clip, vaddr_cached_hint, xfrm_line);
153}
154
155/**
156 * drm_fb_memcpy - Copy clip buffer
157 * @dst: Array of destination buffers
158 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
159 * within @dst; can be NULL if scanlines are stored next to each other.
160 * @src: Array of source buffers
161 * @fb: DRM framebuffer
162 * @clip: Clip rectangle area to copy
163 *
164 * This function copies parts of a framebuffer to display memory. Destination and
165 * framebuffer formats must match. No conversion takes place. The parameters @dst,
166 * @dst_pitch and @src refer to arrays. Each array must have at least as many entries
167 * as there are planes in @fb's format. Each entry stores the value for the format's
168 * respective color plane at the same index.
169 *
170 * This function does not apply clipping on @dst (i.e. the destination is at the
171 * top-left corner).
172 */
173void drm_fb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,
174 const struct iosys_map *src, const struct drm_framebuffer *fb,
175 const struct drm_rect *clip)
176{
177 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
178 0, 0, 0, 0
179 };
180
181 const struct drm_format_info *format = fb->format;
182 unsigned int i, y, lines = drm_rect_height(clip);
183
184 if (!dst_pitch)
185 dst_pitch = default_dst_pitch;
186
187 for (i = 0; i < format->num_planes; ++i) {
188 unsigned int bpp_i = drm_format_info_bpp(format, i);
189 unsigned int cpp_i = DIV_ROUND_UP(bpp_i, 8);
190 size_t len_i = DIV_ROUND_UP(drm_rect_width(clip) * bpp_i, 8);
191 unsigned int dst_pitch_i = dst_pitch[i];
192 struct iosys_map dst_i = dst[i];
193 struct iosys_map src_i = src[i];
194
195 if (!dst_pitch_i)
196 dst_pitch_i = len_i;
197
198 iosys_map_incr(&src_i, clip_offset(clip, fb->pitches[i], cpp_i));
199 for (y = 0; y < lines; y++) {
200 /* TODO: handle src_i in I/O memory here */
201 iosys_map_memcpy_to(&dst_i, 0, src_i.vaddr, len_i);
202 iosys_map_incr(&src_i, fb->pitches[i]);
203 iosys_map_incr(&dst_i, dst_pitch_i);
204 }
205 }
206}
207EXPORT_SYMBOL(drm_fb_memcpy);
208
209static void drm_fb_swab16_line(void *dbuf, const void *sbuf, unsigned int pixels)
210{
211 u16 *dbuf16 = dbuf;
212 const u16 *sbuf16 = sbuf;
213 const u16 *send16 = sbuf16 + pixels;
214
215 while (sbuf16 < send16)
216 *dbuf16++ = swab16(*sbuf16++);
217}
218
219static void drm_fb_swab32_line(void *dbuf, const void *sbuf, unsigned int pixels)
220{
221 u32 *dbuf32 = dbuf;
222 const u32 *sbuf32 = sbuf;
223 const u32 *send32 = sbuf32 + pixels;
224
225 while (sbuf32 < send32)
226 *dbuf32++ = swab32(*sbuf32++);
227}
228
229/**
230 * drm_fb_swab - Swap bytes into clip buffer
231 * @dst: Array of destination buffers
232 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
233 * within @dst; can be NULL if scanlines are stored next to each other.
234 * @src: Array of source buffers
235 * @fb: DRM framebuffer
236 * @clip: Clip rectangle area to copy
237 * @cached: Source buffer is mapped cached (eg. not write-combined)
238 *
239 * This function copies parts of a framebuffer to display memory and swaps per-pixel
240 * bytes during the process. Destination and framebuffer formats must match. The
241 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
242 * least as many entries as there are planes in @fb's format. Each entry stores the
243 * value for the format's respective color plane at the same index. If @cached is
244 * false a temporary buffer is used to cache one pixel line at a time to speed up
245 * slow uncached reads.
246 *
247 * This function does not apply clipping on @dst (i.e. the destination is at the
248 * top-left corner).
249 */
250void drm_fb_swab(struct iosys_map *dst, const unsigned int *dst_pitch,
251 const struct iosys_map *src, const struct drm_framebuffer *fb,
252 const struct drm_rect *clip, bool cached)
253{
254 const struct drm_format_info *format = fb->format;
255 u8 cpp = DIV_ROUND_UP(drm_format_info_bpp(format, 0), 8);
256 void (*swab_line)(void *dbuf, const void *sbuf, unsigned int npixels);
257
258 switch (cpp) {
259 case 4:
260 swab_line = drm_fb_swab32_line;
261 break;
262 case 2:
263 swab_line = drm_fb_swab16_line;
264 break;
265 default:
266 drm_warn_once(fb->dev, "Format %p4cc has unsupported pixel size.\n",
267 &format->format);
268 return;
269 }
270
271 drm_fb_xfrm(dst, dst_pitch, &cpp, src, fb, clip, cached, swab_line);
272}
273EXPORT_SYMBOL(drm_fb_swab);
274
275static void drm_fb_xrgb8888_to_rgb332_line(void *dbuf, const void *sbuf, unsigned int pixels)
276{
277 u8 *dbuf8 = dbuf;
278 const __le32 *sbuf32 = sbuf;
279 unsigned int x;
280 u32 pix;
281
282 for (x = 0; x < pixels; x++) {
283 pix = le32_to_cpu(sbuf32[x]);
284 dbuf8[x] = ((pix & 0x00e00000) >> 16) |
285 ((pix & 0x0000e000) >> 11) |
286 ((pix & 0x000000c0) >> 6);
287 }
288}
289
290/**
291 * drm_fb_xrgb8888_to_rgb332 - Convert XRGB8888 to RGB332 clip buffer
292 * @dst: Array of RGB332 destination buffers
293 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
294 * within @dst; can be NULL if scanlines are stored next to each other.
295 * @src: Array of XRGB8888 source buffers
296 * @fb: DRM framebuffer
297 * @clip: Clip rectangle area to copy
298 *
299 * This function copies parts of a framebuffer to display memory and converts the
300 * color format during the process. Destination and framebuffer formats must match. The
301 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
302 * least as many entries as there are planes in @fb's format. Each entry stores the
303 * value for the format's respective color plane at the same index.
304 *
305 * This function does not apply clipping on @dst (i.e. the destination is at the
306 * top-left corner).
307 *
308 * Drivers can use this function for RGB332 devices that don't support XRGB8888 natively.
309 */
310void drm_fb_xrgb8888_to_rgb332(struct iosys_map *dst, const unsigned int *dst_pitch,
311 const struct iosys_map *src, const struct drm_framebuffer *fb,
312 const struct drm_rect *clip)
313{
314 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
315 1,
316 };
317
318 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
319 drm_fb_xrgb8888_to_rgb332_line);
320}
321EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb332);
322
323static void drm_fb_xrgb8888_to_rgb565_line(void *dbuf, const void *sbuf, unsigned int pixels)
324{
325 u16 *dbuf16 = dbuf;
326 const __le32 *sbuf32 = sbuf;
327 unsigned int x;
328 u16 val16;
329 u32 pix;
330
331 for (x = 0; x < pixels; x++) {
332 pix = le32_to_cpu(sbuf32[x]);
333 val16 = ((pix & 0x00F80000) >> 8) |
334 ((pix & 0x0000FC00) >> 5) |
335 ((pix & 0x000000F8) >> 3);
336 dbuf16[x] = val16;
337 }
338}
339
340static void drm_fb_xrgb8888_to_rgb565_swab_line(void *dbuf, const void *sbuf,
341 unsigned int pixels)
342{
343 u16 *dbuf16 = dbuf;
344 const __le32 *sbuf32 = sbuf;
345 unsigned int x;
346 u16 val16;
347 u32 pix;
348
349 for (x = 0; x < pixels; x++) {
350 pix = le32_to_cpu(sbuf32[x]);
351 val16 = ((pix & 0x00F80000) >> 8) |
352 ((pix & 0x0000FC00) >> 5) |
353 ((pix & 0x000000F8) >> 3);
354 dbuf16[x] = swab16(val16);
355 }
356}
357
358/**
359 * drm_fb_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
360 * @dst: Array of RGB565 destination buffers
361 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
362 * within @dst; can be NULL if scanlines are stored next to each other.
363 * @src: Array of XRGB8888 source buffer
364 * @fb: DRM framebuffer
365 * @clip: Clip rectangle area to copy
366 * @swab: Swap bytes
367 *
368 * This function copies parts of a framebuffer to display memory and converts the
369 * color format during the process. Destination and framebuffer formats must match. The
370 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
371 * least as many entries as there are planes in @fb's format. Each entry stores the
372 * value for the format's respective color plane at the same index.
373 *
374 * This function does not apply clipping on @dst (i.e. the destination is at the
375 * top-left corner).
376 *
377 * Drivers can use this function for RGB565 devices that don't support XRGB8888 natively.
378 */
379void drm_fb_xrgb8888_to_rgb565(struct iosys_map *dst, const unsigned int *dst_pitch,
380 const struct iosys_map *src, const struct drm_framebuffer *fb,
381 const struct drm_rect *clip, bool swab)
382{
383 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
384 2,
385 };
386
387 void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels);
388
389 if (swab)
390 xfrm_line = drm_fb_xrgb8888_to_rgb565_swab_line;
391 else
392 xfrm_line = drm_fb_xrgb8888_to_rgb565_line;
393
394 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, xfrm_line);
395}
396EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb565);
397
398static void drm_fb_xrgb8888_to_rgb888_line(void *dbuf, const void *sbuf, unsigned int pixels)
399{
400 u8 *dbuf8 = dbuf;
401 const __le32 *sbuf32 = sbuf;
402 unsigned int x;
403 u32 pix;
404
405 for (x = 0; x < pixels; x++) {
406 pix = le32_to_cpu(sbuf32[x]);
407 *dbuf8++ = (pix & 0x000000FF) >> 0;
408 *dbuf8++ = (pix & 0x0000FF00) >> 8;
409 *dbuf8++ = (pix & 0x00FF0000) >> 16;
410 }
411}
412
413/**
414 * drm_fb_xrgb8888_to_rgb888 - Convert XRGB8888 to RGB888 clip buffer
415 * @dst: Array of RGB888 destination buffers
416 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
417 * within @dst; can be NULL if scanlines are stored next to each other.
418 * @src: Array of XRGB8888 source buffers
419 * @fb: DRM framebuffer
420 * @clip: Clip rectangle area to copy
421 *
422 * This function copies parts of a framebuffer to display memory and converts the
423 * color format during the process. Destination and framebuffer formats must match. The
424 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
425 * least as many entries as there are planes in @fb's format. Each entry stores the
426 * value for the format's respective color plane at the same index.
427 *
428 * This function does not apply clipping on @dst (i.e. the destination is at the
429 * top-left corner).
430 *
431 * Drivers can use this function for RGB888 devices that don't natively
432 * support XRGB8888.
433 */
434void drm_fb_xrgb8888_to_rgb888(struct iosys_map *dst, const unsigned int *dst_pitch,
435 const struct iosys_map *src, const struct drm_framebuffer *fb,
436 const struct drm_rect *clip)
437{
438 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
439 3,
440 };
441
442 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
443 drm_fb_xrgb8888_to_rgb888_line);
444}
445EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb888);
446
447static void drm_fb_rgb565_to_xrgb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
448{
449 __le32 *dbuf32 = dbuf;
450 const __le16 *sbuf16 = sbuf;
451 unsigned int x;
452
453 for (x = 0; x < pixels; x++) {
454 u16 val16 = le16_to_cpu(sbuf16[x]);
455 u32 val32 = ((val16 & 0xf800) << 8) |
456 ((val16 & 0x07e0) << 5) |
457 ((val16 & 0x001f) << 3);
458 val32 = 0xff000000 | val32 |
459 ((val32 >> 3) & 0x00070007) |
460 ((val32 >> 2) & 0x00000300);
461 dbuf32[x] = cpu_to_le32(val32);
462 }
463}
464
465static void drm_fb_rgb565_to_xrgb8888(struct iosys_map *dst, const unsigned int *dst_pitch,
466 const struct iosys_map *src,
467 const struct drm_framebuffer *fb,
468 const struct drm_rect *clip)
469{
470 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
471 4,
472 };
473
474 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
475 drm_fb_rgb565_to_xrgb8888_line);
476}
477
478static void drm_fb_rgb888_to_xrgb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
479{
480 __le32 *dbuf32 = dbuf;
481 const u8 *sbuf8 = sbuf;
482 unsigned int x;
483
484 for (x = 0; x < pixels; x++) {
485 u8 r = *sbuf8++;
486 u8 g = *sbuf8++;
487 u8 b = *sbuf8++;
488 u32 pix = 0xff000000 | (r << 16) | (g << 8) | b;
489 dbuf32[x] = cpu_to_le32(pix);
490 }
491}
492
493static void drm_fb_rgb888_to_xrgb8888(struct iosys_map *dst, const unsigned int *dst_pitch,
494 const struct iosys_map *src,
495 const struct drm_framebuffer *fb,
496 const struct drm_rect *clip)
497{
498 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
499 4,
500 };
501
502 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
503 drm_fb_rgb888_to_xrgb8888_line);
504}
505
506static void drm_fb_xrgb8888_to_xrgb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
507{
508 __le32 *dbuf32 = dbuf;
509 const __le32 *sbuf32 = sbuf;
510 unsigned int x;
511 u32 val32;
512 u32 pix;
513
514 for (x = 0; x < pixels; x++) {
515 pix = le32_to_cpu(sbuf32[x]);
516 val32 = ((pix & 0x000000FF) << 2) |
517 ((pix & 0x0000FF00) << 4) |
518 ((pix & 0x00FF0000) << 6);
519 pix = val32 | ((val32 >> 8) & 0x00300C03);
520 *dbuf32++ = cpu_to_le32(pix);
521 }
522}
523
524/**
525 * drm_fb_xrgb8888_to_xrgb2101010 - Convert XRGB8888 to XRGB2101010 clip buffer
526 * @dst: Array of XRGB2101010 destination buffers
527 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
528 * within @dst; can be NULL if scanlines are stored next to each other.
529 * @src: Array of XRGB8888 source buffers
530 * @fb: DRM framebuffer
531 * @clip: Clip rectangle area to copy
532 *
533 * This function copies parts of a framebuffer to display memory and converts the
534 * color format during the process. Destination and framebuffer formats must match. The
535 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
536 * least as many entries as there are planes in @fb's format. Each entry stores the
537 * value for the format's respective color plane at the same index.
538 *
539 * This function does not apply clipping on @dst (i.e. the destination is at the
540 * top-left corner).
541 *
542 * Drivers can use this function for XRGB2101010 devices that don't support XRGB8888
543 * natively.
544 */
545void drm_fb_xrgb8888_to_xrgb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,
546 const struct iosys_map *src, const struct drm_framebuffer *fb,
547 const struct drm_rect *clip)
548{
549 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
550 4,
551 };
552
553 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
554 drm_fb_xrgb8888_to_xrgb2101010_line);
555}
556EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb2101010);
557
558static void drm_fb_xrgb8888_to_gray8_line(void *dbuf, const void *sbuf, unsigned int pixels)
559{
560 u8 *dbuf8 = dbuf;
561 const __le32 *sbuf32 = sbuf;
562 unsigned int x;
563
564 for (x = 0; x < pixels; x++) {
565 u32 pix = le32_to_cpu(sbuf32[x]);
566 u8 r = (pix & 0x00ff0000) >> 16;
567 u8 g = (pix & 0x0000ff00) >> 8;
568 u8 b = pix & 0x000000ff;
569
570 /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
571 *dbuf8++ = (3 * r + 6 * g + b) / 10;
572 }
573}
574
575/**
576 * drm_fb_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
577 * @dst: Array of 8-bit grayscale destination buffers
578 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
579 * within @dst; can be NULL if scanlines are stored next to each other.
580 * @src: Array of XRGB8888 source buffers
581 * @fb: DRM framebuffer
582 * @clip: Clip rectangle area to copy
583 *
584 * This function copies parts of a framebuffer to display memory and converts the
585 * color format during the process. Destination and framebuffer formats must match. The
586 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
587 * least as many entries as there are planes in @fb's format. Each entry stores the
588 * value for the format's respective color plane at the same index.
589 *
590 * This function does not apply clipping on @dst (i.e. the destination is at the
591 * top-left corner).
592 *
593 * DRM doesn't have native monochrome or grayscale support. Drivers can use this
594 * function for grayscale devices that don't support XRGB8888 natively.Such
595 * drivers can announce the commonly supported XR24 format to userspace and use
596 * this function to convert to the native format. Monochrome drivers will use the
597 * most significant bit, where 1 means foreground color and 0 background color.
598 * ITU BT.601 is being used for the RGB -> luma (brightness) conversion.
599 */
600void drm_fb_xrgb8888_to_gray8(struct iosys_map *dst, const unsigned int *dst_pitch,
601 const struct iosys_map *src, const struct drm_framebuffer *fb,
602 const struct drm_rect *clip)
603{
604 static const u8 dst_pixsize[DRM_FORMAT_MAX_PLANES] = {
605 1,
606 };
607
608 drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false,
609 drm_fb_xrgb8888_to_gray8_line);
610}
611EXPORT_SYMBOL(drm_fb_xrgb8888_to_gray8);
612
613/**
614 * drm_fb_blit - Copy parts of a framebuffer to display memory
615 * @dst: Array of display-memory addresses to copy to
616 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
617 * within @dst; can be NULL if scanlines are stored next to each other.
618 * @dst_format: FOURCC code of the display's color format
619 * @src: The framebuffer memory to copy from
620 * @fb: The framebuffer to copy from
621 * @clip: Clip rectangle area to copy
622 *
623 * This function copies parts of a framebuffer to display memory. If the
624 * formats of the display and the framebuffer mismatch, the blit function
625 * will attempt to convert between them during the process. The parameters @dst,
626 * @dst_pitch and @src refer to arrays. Each array must have at least as many
627 * entries as there are planes in @dst_format's format. Each entry stores the
628 * value for the format's respective color plane at the same index.
629 *
630 * This function does not apply clipping on @dst (i.e. the destination is at the
631 * top-left corner).
632 *
633 * Returns:
634 * 0 on success, or
635 * -EINVAL if the color-format conversion failed, or
636 * a negative error code otherwise.
637 */
638int drm_fb_blit(struct iosys_map *dst, const unsigned int *dst_pitch, uint32_t dst_format,
639 const struct iosys_map *src, const struct drm_framebuffer *fb,
640 const struct drm_rect *clip)
641{
642 uint32_t fb_format = fb->format->format;
643
644 /* treat alpha channel like filler bits */
645 if (fb_format == DRM_FORMAT_ARGB8888)
646 fb_format = DRM_FORMAT_XRGB8888;
647 if (dst_format == DRM_FORMAT_ARGB8888)
648 dst_format = DRM_FORMAT_XRGB8888;
649 if (fb_format == DRM_FORMAT_ARGB2101010)
650 fb_format = DRM_FORMAT_XRGB2101010;
651 if (dst_format == DRM_FORMAT_ARGB2101010)
652 dst_format = DRM_FORMAT_XRGB2101010;
653
654 if (dst_format == fb_format) {
655 drm_fb_memcpy(dst, dst_pitch, src, fb, clip);
656 return 0;
657
658 } else if (dst_format == DRM_FORMAT_RGB565) {
659 if (fb_format == DRM_FORMAT_XRGB8888) {
660 drm_fb_xrgb8888_to_rgb565(dst, dst_pitch, src, fb, clip, false);
661 return 0;
662 }
663 } else if (dst_format == (DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN)) {
664 if (fb_format == DRM_FORMAT_RGB565) {
665 drm_fb_swab(dst, dst_pitch, src, fb, clip, false);
666 return 0;
667 }
668 } else if (dst_format == DRM_FORMAT_RGB888) {
669 if (fb_format == DRM_FORMAT_XRGB8888) {
670 drm_fb_xrgb8888_to_rgb888(dst, dst_pitch, src, fb, clip);
671 return 0;
672 }
673 } else if (dst_format == DRM_FORMAT_XRGB8888) {
674 if (fb_format == DRM_FORMAT_RGB888) {
675 drm_fb_rgb888_to_xrgb8888(dst, dst_pitch, src, fb, clip);
676 return 0;
677 } else if (fb_format == DRM_FORMAT_RGB565) {
678 drm_fb_rgb565_to_xrgb8888(dst, dst_pitch, src, fb, clip);
679 return 0;
680 }
681 } else if (dst_format == DRM_FORMAT_XRGB2101010) {
682 if (fb_format == DRM_FORMAT_XRGB8888) {
683 drm_fb_xrgb8888_to_xrgb2101010(dst, dst_pitch, src, fb, clip);
684 return 0;
685 }
686 } else if (dst_format == DRM_FORMAT_BGRX8888) {
687 if (fb_format == DRM_FORMAT_XRGB8888) {
688 drm_fb_swab(dst, dst_pitch, src, fb, clip, false);
689 return 0;
690 }
691 }
692
693 drm_warn_once(fb->dev, "No conversion helper from %p4cc to %p4cc found.\n",
694 &fb_format, &dst_format);
695
696 return -EINVAL;
697}
698EXPORT_SYMBOL(drm_fb_blit);
699
700static void drm_fb_gray8_to_mono_line(void *dbuf, const void *sbuf, unsigned int pixels)
701{
702 u8 *dbuf8 = dbuf;
703 const u8 *sbuf8 = sbuf;
704
705 while (pixels) {
706 unsigned int i, bits = min(pixels, 8U);
707 u8 byte = 0;
708
709 for (i = 0; i < bits; i++, pixels--) {
710 if (*sbuf8++ >= 128)
711 byte |= BIT(i);
712 }
713 *dbuf8++ = byte;
714 }
715}
716
717/**
718 * drm_fb_xrgb8888_to_mono - Convert XRGB8888 to monochrome
719 * @dst: Array of monochrome destination buffers (0=black, 1=white)
720 * @dst_pitch: Array of numbers of bytes between the start of two consecutive scanlines
721 * within @dst; can be NULL if scanlines are stored next to each other.
722 * @src: Array of XRGB8888 source buffers
723 * @fb: DRM framebuffer
724 * @clip: Clip rectangle area to copy
725 *
726 * This function copies parts of a framebuffer to display memory and converts the
727 * color format during the process. Destination and framebuffer formats must match. The
728 * parameters @dst, @dst_pitch and @src refer to arrays. Each array must have at
729 * least as many entries as there are planes in @fb's format. Each entry stores the
730 * value for the format's respective color plane at the same index.
731 *
732 * This function does not apply clipping on @dst (i.e. the destination is at the
733 * top-left corner). The first pixel (upper left corner of the clip rectangle) will
734 * be converted and copied to the first bit (LSB) in the first byte of the monochrome
735 * destination buffer. If the caller requires that the first pixel in a byte must
736 * be located at an x-coordinate that is a multiple of 8, then the caller must take
737 * care itself of supplying a suitable clip rectangle.
738 *
739 * DRM doesn't have native monochrome support. Drivers can use this function for
740 * monochrome devices that don't support XRGB8888 natively. Such drivers can
741 * announce the commonly supported XR24 format to userspace and use this function
742 * to convert to the native format.
743 *
744 * This function uses drm_fb_xrgb8888_to_gray8() to convert to grayscale and
745 * then the result is converted from grayscale to monochrome.
746 */
747void drm_fb_xrgb8888_to_mono(struct iosys_map *dst, const unsigned int *dst_pitch,
748 const struct iosys_map *src, const struct drm_framebuffer *fb,
749 const struct drm_rect *clip)
750{
751 static const unsigned int default_dst_pitch[DRM_FORMAT_MAX_PLANES] = {
752 0, 0, 0, 0
753 };
754 unsigned int linepixels = drm_rect_width(clip);
755 unsigned int lines = drm_rect_height(clip);
756 unsigned int cpp = fb->format->cpp[0];
757 unsigned int len_src32 = linepixels * cpp;
758 struct drm_device *dev = fb->dev;
759 void *vaddr = src[0].vaddr;
760 unsigned int dst_pitch_0;
761 unsigned int y;
762 u8 *mono = dst[0].vaddr, *gray8;
763 u32 *src32;
764
765 if (drm_WARN_ON(dev, fb->format->format != DRM_FORMAT_XRGB8888))
766 return;
767
768 if (!dst_pitch)
769 dst_pitch = default_dst_pitch;
770 dst_pitch_0 = dst_pitch[0];
771
772 /*
773 * The mono destination buffer contains 1 bit per pixel
774 */
775 if (!dst_pitch_0)
776 dst_pitch_0 = DIV_ROUND_UP(linepixels, 8);
777
778 /*
779 * The dma memory is write-combined so reads are uncached.
780 * Speed up by fetching one line at a time.
781 *
782 * Also, format conversion from XR24 to monochrome are done
783 * line-by-line but are converted to 8-bit grayscale as an
784 * intermediate step.
785 *
786 * Allocate a buffer to be used for both copying from the cma
787 * memory and to store the intermediate grayscale line pixels.
788 */
789 src32 = kmalloc(len_src32 + linepixels, GFP_KERNEL);
790 if (!src32)
791 return;
792
793 gray8 = (u8 *)src32 + len_src32;
794
795 vaddr += clip_offset(clip, fb->pitches[0], cpp);
796 for (y = 0; y < lines; y++) {
797 src32 = memcpy(src32, vaddr, len_src32);
798 drm_fb_xrgb8888_to_gray8_line(gray8, src32, linepixels);
799 drm_fb_gray8_to_mono_line(mono, gray8, linepixels);
800 vaddr += fb->pitches[0];
801 mono += dst_pitch_0;
802 }
803
804 kfree(src32);
805}
806EXPORT_SYMBOL(drm_fb_xrgb8888_to_mono);
807
808static bool is_listed_fourcc(const uint32_t *fourccs, size_t nfourccs, uint32_t fourcc)
809{
810 const uint32_t *fourccs_end = fourccs + nfourccs;
811
812 while (fourccs < fourccs_end) {
813 if (*fourccs == fourcc)
814 return true;
815 ++fourccs;
816 }
817 return false;
818}
819
820static const uint32_t conv_from_xrgb8888[] = {
821 DRM_FORMAT_XRGB8888,
822 DRM_FORMAT_ARGB8888,
823 DRM_FORMAT_XRGB2101010,
824 DRM_FORMAT_ARGB2101010,
825 DRM_FORMAT_RGB565,
826 DRM_FORMAT_RGB888,
827};
828
829static const uint32_t conv_from_rgb565_888[] = {
830 DRM_FORMAT_XRGB8888,
831 DRM_FORMAT_ARGB8888,
832};
833
834static bool is_conversion_supported(uint32_t from, uint32_t to)
835{
836 switch (from) {
837 case DRM_FORMAT_XRGB8888:
838 case DRM_FORMAT_ARGB8888:
839 return is_listed_fourcc(conv_from_xrgb8888, ARRAY_SIZE(conv_from_xrgb8888), to);
840 case DRM_FORMAT_RGB565:
841 case DRM_FORMAT_RGB888:
842 return is_listed_fourcc(conv_from_rgb565_888, ARRAY_SIZE(conv_from_rgb565_888), to);
843 case DRM_FORMAT_XRGB2101010:
844 return to == DRM_FORMAT_ARGB2101010;
845 case DRM_FORMAT_ARGB2101010:
846 return to == DRM_FORMAT_XRGB2101010;
847 default:
848 return false;
849 }
850}
851
852/**
853 * drm_fb_build_fourcc_list - Filters a list of supported color formats against
854 * the device's native formats
855 * @dev: DRM device
856 * @native_fourccs: 4CC codes of natively supported color formats
857 * @native_nfourccs: The number of entries in @native_fourccs
858 * @driver_fourccs: 4CC codes of all driver-supported color formats
859 * @driver_nfourccs: The number of entries in @driver_fourccs
860 * @fourccs_out: Returns 4CC codes of supported color formats
861 * @nfourccs_out: The number of available entries in @fourccs_out
862 *
863 * This function create a list of supported color format from natively
864 * supported formats and the emulated formats.
865 * At a minimum, most userspace programs expect at least support for
866 * XRGB8888 on the primary plane. Devices that have to emulate the
867 * format, and possibly others, can use drm_fb_build_fourcc_list() to
868 * create a list of supported color formats. The returned list can
869 * be handed over to drm_universal_plane_init() et al. Native formats
870 * will go before emulated formats. Other heuristics might be applied
871 * to optimize the order. Formats near the beginning of the list are
872 * usually preferred over formats near the end of the list. Formats
873 * without conversion helpers will be skipped. New drivers should only
874 * pass in XRGB8888 and avoid exposing additional emulated formats.
875 *
876 * Returns:
877 * The number of color-formats 4CC codes returned in @fourccs_out.
878 */
879size_t drm_fb_build_fourcc_list(struct drm_device *dev,
880 const u32 *native_fourccs, size_t native_nfourccs,
881 const u32 *driver_fourccs, size_t driver_nfourccs,
882 u32 *fourccs_out, size_t nfourccs_out)
883{
884 u32 *fourccs = fourccs_out;
885 const u32 *fourccs_end = fourccs_out + nfourccs_out;
886 uint32_t native_format = 0;
887 size_t i;
888
889 /*
890 * The device's native formats go first.
891 */
892
893 for (i = 0; i < native_nfourccs; ++i) {
894 u32 fourcc = native_fourccs[i];
895
896 if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
897 continue; /* skip duplicate entries */
898 } else if (fourccs == fourccs_end) {
899 drm_warn(dev, "Ignoring native format %p4cc\n", &fourcc);
900 continue; /* end of available output buffer */
901 }
902
903 drm_dbg_kms(dev, "adding native format %p4cc\n", &fourcc);
904
905 /*
906 * There should only be one native format with the current API.
907 * This API needs to be refactored to correctly support arbitrary
908 * sets of native formats, since it needs to report which native
909 * format to use for each emulated format.
910 */
911 if (!native_format)
912 native_format = fourcc;
913 *fourccs = fourcc;
914 ++fourccs;
915 }
916
917 /*
918 * The extra formats, emulated by the driver, go second.
919 */
920
921 for (i = 0; (i < driver_nfourccs) && (fourccs < fourccs_end); ++i) {
922 u32 fourcc = driver_fourccs[i];
923
924 if (is_listed_fourcc(fourccs_out, fourccs - fourccs_out, fourcc)) {
925 continue; /* skip duplicate and native entries */
926 } else if (fourccs == fourccs_end) {
927 drm_warn(dev, "Ignoring emulated format %p4cc\n", &fourcc);
928 continue; /* end of available output buffer */
929 } else if (!is_conversion_supported(fourcc, native_format)) {
930 drm_dbg_kms(dev, "Unsupported emulated format %p4cc\n", &fourcc);
931 continue; /* format is not supported for conversion */
932 }
933
934 drm_dbg_kms(dev, "adding emulated format %p4cc\n", &fourcc);
935
936 *fourccs = fourcc;
937 ++fourccs;
938 }
939
940 return fourccs - fourccs_out;
941}
942EXPORT_SYMBOL(drm_fb_build_fourcc_list);