drivers/gpu/drm/drm_format_helper.c

   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/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/io.h>
  14
  15 #include <drm/drm_device.h>
  16 #include <drm/drm_format_helper.h>
  17 #include <drm/drm_framebuffer.h>
  18 #include <drm/drm_fourcc.h>
  19 #include <drm/drm_print.h>
  20 #include <drm/drm_rect.h>
  21
  22 static unsigned int clip_offset(const struct drm_rect *clip, unsigned int pitch, unsigned int cpp)
  23 {
  24         return clip->y1 * pitch + clip->x1 * cpp;
  25 }
  26
  27 /**
  28  * drm_fb_clip_offset - Returns the clipping rectangles byte-offset in a framebuffer
  29  * @pitch: Framebuffer line pitch in byte
  30  * @format: Framebuffer format
  31  * @clip: Clip rectangle
  32  *
  33  * Returns:
  34  * The byte offset of the clip rectangle's top-left corner within the framebuffer.
  35  */
  36 unsigned int drm_fb_clip_offset(unsigned int pitch, const struct drm_format_info *format,
  37                                 const struct drm_rect *clip)
  38 {
  39         return clip_offset(clip, pitch, format->cpp[0]);
  40 }
  41 EXPORT_SYMBOL(drm_fb_clip_offset);
  42
  43 /* TODO: Make this functon work with multi-plane formats. */
  44 static int drm_fb_xfrm(void *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
  45                        const void *vaddr, const struct drm_framebuffer *fb,
  46                        const struct drm_rect *clip, bool vaddr_cached_hint,
  47                        void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
  48 {
  49         unsigned long linepixels = drm_rect_width(clip);
  50         unsigned long lines = drm_rect_height(clip);
  51         size_t sbuf_len = linepixels * fb->format->cpp[0];
  52         void *stmp = NULL;
  53         unsigned long i;
  54         const void *sbuf;
  55
  56         /*
  57          * Some source buffers, such as CMA memory, use write-combine
  58          * caching, so reads are uncached. Speed up access by fetching
  59          * one line at a time.
  60          */
  61         if (!vaddr_cached_hint) {
  62                 stmp = kmalloc(sbuf_len, GFP_KERNEL);
  63                 if (!stmp)
  64                         return -ENOMEM;
  65         }
  66
  67         if (!dst_pitch)
  68                 dst_pitch = drm_rect_width(clip) * dst_pixsize;
  69         vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
  70
  71         for (i = 0; i < lines; ++i) {
  72                 if (stmp)
  73                         sbuf = memcpy(stmp, vaddr, sbuf_len);
  74                 else
  75                         sbuf = vaddr;
  76                 xfrm_line(dst, sbuf, linepixels);
  77                 vaddr += fb->pitches[0];
  78                 dst += dst_pitch;
  79         }
  80
  81         kfree(stmp);
  82
  83         return 0;
  84 }
  85
  86 /* TODO: Make this functon work with multi-plane formats. */
  87 static int drm_fb_xfrm_toio(void __iomem *dst, unsigned long dst_pitch, unsigned long dst_pixsize,
  88                             const void *vaddr, const struct drm_framebuffer *fb,
  89                             const struct drm_rect *clip, bool vaddr_cached_hint,
  90                             void (*xfrm_line)(void *dbuf, const void *sbuf, unsigned int npixels))
  91 {
  92         unsigned long linepixels = drm_rect_width(clip);
  93         unsigned long lines = drm_rect_height(clip);
  94         size_t dbuf_len = linepixels * dst_pixsize;
  95         size_t stmp_off = round_up(dbuf_len, ARCH_KMALLOC_MINALIGN); /* for sbuf alignment */
  96         size_t sbuf_len = linepixels * fb->format->cpp[0];
  97         void *stmp = NULL;
  98         unsigned long i;
  99         const void *sbuf;
 100         void *dbuf;
 101
 102         if (vaddr_cached_hint) {
 103                 dbuf = kmalloc(dbuf_len, GFP_KERNEL);
 104         } else {
 105                 dbuf = kmalloc(stmp_off + sbuf_len, GFP_KERNEL);
 106                 stmp = dbuf + stmp_off;
 107         }
 108         if (!dbuf)
 109                 return -ENOMEM;
 110
 111         if (!dst_pitch)
 112                 dst_pitch = linepixels * dst_pixsize;
 113         vaddr += clip_offset(clip, fb->pitches[0], fb->format->cpp[0]);
 114
 115         for (i = 0; i < lines; ++i) {
 116                 if (stmp)
 117                         sbuf = memcpy(stmp, vaddr, sbuf_len);
 118                 else
 119                         sbuf = vaddr;
 120                 xfrm_line(dbuf, sbuf, linepixels);
 121                 memcpy_toio(dst, dbuf, dbuf_len);
 122                 vaddr += fb->pitches[0];
 123                 dst += dst_pitch;
 124         }
 125
 126         kfree(dbuf);
 127
 128         return 0;
 129 }
 130
 131 /**
 132  * drm_fb_memcpy - Copy clip buffer
 133  * @dst: Destination buffer
 134  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 135  * @vaddr: Source buffer
 136  * @fb: DRM framebuffer
 137  * @clip: Clip rectangle area to copy
 138  *
 139  * This function does not apply clipping on dst, i.e. the destination
 140  * is at the top-left corner.
 141  */
 142 void drm_fb_memcpy(void *dst, unsigned int dst_pitch, const void *vaddr,
 143                    const struct drm_framebuffer *fb, const struct drm_rect *clip)
 144 {
 145         unsigned int cpp = fb->format->cpp[0];
 146         size_t len = (clip->x2 - clip->x1) * cpp;
 147         unsigned int y, lines = clip->y2 - clip->y1;
 148
 149         if (!dst_pitch)
 150                 dst_pitch = len;
 151
 152         vaddr += clip_offset(clip, fb->pitches[0], cpp);
 153         for (y = 0; y < lines; y++) {
 154                 memcpy(dst, vaddr, len);
 155                 vaddr += fb->pitches[0];
 156                 dst += dst_pitch;
 157         }
 158 }
 159 EXPORT_SYMBOL(drm_fb_memcpy);
 160
 161 /**
 162  * drm_fb_memcpy_toio - Copy clip buffer
 163  * @dst: Destination buffer (iomem)
 164  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 165  * @vaddr: Source buffer
 166  * @fb: DRM framebuffer
 167  * @clip: Clip rectangle area to copy
 168  *
 169  * This function does not apply clipping on dst, i.e. the destination
 170  * is at the top-left corner.
 171  */
 172 void drm_fb_memcpy_toio(void __iomem *dst, unsigned int dst_pitch, const void *vaddr,
 173                         const struct drm_framebuffer *fb, const struct drm_rect *clip)
 174 {
 175         unsigned int cpp = fb->format->cpp[0];
 176         size_t len = (clip->x2 - clip->x1) * cpp;
 177         unsigned int y, lines = clip->y2 - clip->y1;
 178
 179         if (!dst_pitch)
 180                 dst_pitch = len;
 181
 182         vaddr += clip_offset(clip, fb->pitches[0], cpp);
 183         for (y = 0; y < lines; y++) {
 184                 memcpy_toio(dst, vaddr, len);
 185                 vaddr += fb->pitches[0];
 186                 dst += dst_pitch;
 187         }
 188 }
 189 EXPORT_SYMBOL(drm_fb_memcpy_toio);
 190
 191 static void drm_fb_swab16_line(void *dbuf, const void *sbuf, unsigned int pixels)
 192 {
 193         u16 *dbuf16 = dbuf;
 194         const u16 *sbuf16 = sbuf;
 195         const u16 *send16 = sbuf16 + pixels;
 196
 197         while (sbuf16 < send16)
 198                 *dbuf16++ = swab16(*sbuf16++);
 199 }
 200
 201 static void drm_fb_swab32_line(void *dbuf, const void *sbuf, unsigned int pixels)
 202 {
 203         u32 *dbuf32 = dbuf;
 204         const u32 *sbuf32 = sbuf;
 205         const u32 *send32 = sbuf32 + pixels;
 206
 207         while (sbuf32 < send32)
 208                 *dbuf32++ = swab32(*sbuf32++);
 209 }
 210
 211 /**
 212  * drm_fb_swab - Swap bytes into clip buffer
 213  * @dst: Destination buffer
 214  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 215  * @src: Source buffer
 216  * @fb: DRM framebuffer
 217  * @clip: Clip rectangle area to copy
 218  * @cached: Source buffer is mapped cached (eg. not write-combined)
 219  *
 220  * If @cached is false a temporary buffer is used to cache one pixel line at a
 221  * time to speed up slow uncached reads.
 222  *
 223  * This function does not apply clipping on dst, i.e. the destination
 224  * is at the top-left corner.
 225  */
 226 void drm_fb_swab(void *dst, unsigned int dst_pitch, const void *src,
 227                  const struct drm_framebuffer *fb, const struct drm_rect *clip,
 228                  bool cached)
 229 {
 230         u8 cpp = fb->format->cpp[0];
 231
 232         switch (cpp) {
 233         case 4:
 234                 drm_fb_xfrm(dst, dst_pitch, cpp, src, fb, clip, cached, drm_fb_swab32_line);
 235                 break;
 236         case 2:
 237                 drm_fb_xfrm(dst, dst_pitch, cpp, src, fb, clip, cached, drm_fb_swab16_line);
 238                 break;
 239         default:
 240                 drm_warn_once(fb->dev, "Format %p4cc has unsupported pixel size.\n",
 241                               &fb->format->format);
 242                 break;
 243         }
 244 }
 245 EXPORT_SYMBOL(drm_fb_swab);
 246
 247 static void drm_fb_xrgb8888_to_rgb332_line(void *dbuf, const void *sbuf, unsigned int pixels)
 248 {
 249         u8 *dbuf8 = dbuf;
 250         const __le32 *sbuf32 = sbuf;
 251         unsigned int x;
 252         u32 pix;
 253
 254         for (x = 0; x < pixels; x++) {
 255                 pix = le32_to_cpu(sbuf32[x]);
 256                 dbuf8[x] = ((pix & 0x00e00000) >> 16) |
 257                            ((pix & 0x0000e000) >> 11) |
 258                            ((pix & 0x000000c0) >> 6);
 259         }
 260 }
 261
 262 /**
 263  * drm_fb_xrgb8888_to_rgb332 - Convert XRGB8888 to RGB332 clip buffer
 264  * @dst: RGB332 destination buffer
 265  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 266  * @src: XRGB8888 source buffer
 267  * @fb: DRM framebuffer
 268  * @clip: Clip rectangle area to copy
 269  *
 270  * Drivers can use this function for RGB332 devices that don't natively support XRGB8888.
 271  */
 272 void drm_fb_xrgb8888_to_rgb332(void *dst, unsigned int dst_pitch, const void *src,
 273                                const struct drm_framebuffer *fb, const struct drm_rect *clip)
 274 {
 275         drm_fb_xfrm(dst, dst_pitch, 1, src, fb, clip, false, drm_fb_xrgb8888_to_rgb332_line);
 276 }
 277 EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb332);
 278
 279 static void drm_fb_xrgb8888_to_rgb565_line(void *dbuf, const void *sbuf, unsigned int pixels)
 280 {
 281         u16 *dbuf16 = dbuf;
 282         const u32 *sbuf32 = sbuf;
 283         unsigned int x;
 284         u16 val16;
 285
 286         for (x = 0; x < pixels; x++) {
 287                 val16 = ((sbuf32[x] & 0x00F80000) >> 8) |
 288                         ((sbuf32[x] & 0x0000FC00) >> 5) |
 289                         ((sbuf32[x] & 0x000000F8) >> 3);
 290                 dbuf16[x] = val16;
 291         }
 292 }
 293
 294 static void drm_fb_xrgb8888_to_rgb565_swab_line(void *dbuf, const void *sbuf,
 295                                                 unsigned int pixels)
 296 {
 297         u16 *dbuf16 = dbuf;
 298         const u32 *sbuf32 = sbuf;
 299         unsigned int x;
 300         u16 val16;
 301
 302         for (x = 0; x < pixels; x++) {
 303                 val16 = ((sbuf32[x] & 0x00F80000) >> 8) |
 304                         ((sbuf32[x] & 0x0000FC00) >> 5) |
 305                         ((sbuf32[x] & 0x000000F8) >> 3);
 306                 dbuf16[x] = swab16(val16);
 307         }
 308 }
 309
 310 /**
 311  * drm_fb_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
 312  * @dst: RGB565 destination buffer
 313  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 314  * @vaddr: XRGB8888 source buffer
 315  * @fb: DRM framebuffer
 316  * @clip: Clip rectangle area to copy
 317  * @swab: Swap bytes
 318  *
 319  * Drivers can use this function for RGB565 devices that don't natively
 320  * support XRGB8888.
 321  */
 322 void drm_fb_xrgb8888_to_rgb565(void *dst, unsigned int dst_pitch, const void *vaddr,
 323                                const struct drm_framebuffer *fb, const struct drm_rect *clip,
 324                                bool swab)
 325 {
 326         if (swab)
 327                 drm_fb_xfrm(dst, dst_pitch, 2, vaddr, fb, clip, false,
 328                             drm_fb_xrgb8888_to_rgb565_swab_line);
 329         else
 330                 drm_fb_xfrm(dst, dst_pitch, 2, vaddr, fb, clip, false,
 331                             drm_fb_xrgb8888_to_rgb565_line);
 332 }
 333 EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb565);
 334
 335 /**
 336  * drm_fb_xrgb8888_to_rgb565_toio - Convert XRGB8888 to RGB565 clip buffer
 337  * @dst: RGB565 destination buffer (iomem)
 338  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 339  * @vaddr: XRGB8888 source buffer
 340  * @fb: DRM framebuffer
 341  * @clip: Clip rectangle area to copy
 342  * @swab: Swap bytes
 343  *
 344  * Drivers can use this function for RGB565 devices that don't natively
 345  * support XRGB8888.
 346  */
 347 void drm_fb_xrgb8888_to_rgb565_toio(void __iomem *dst, unsigned int dst_pitch,
 348                                     const void *vaddr, const struct drm_framebuffer *fb,
 349                                     const struct drm_rect *clip, bool swab)
 350 {
 351         if (swab)
 352                 drm_fb_xfrm_toio(dst, dst_pitch, 2, vaddr, fb, clip, false,
 353                                  drm_fb_xrgb8888_to_rgb565_swab_line);
 354         else
 355                 drm_fb_xfrm_toio(dst, dst_pitch, 2, vaddr, fb, clip, false,
 356                                  drm_fb_xrgb8888_to_rgb565_line);
 357 }
 358 EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb565_toio);
 359
 360 static void drm_fb_xrgb8888_to_rgb888_line(void *dbuf, const void *sbuf, unsigned int pixels)
 361 {
 362         u8 *dbuf8 = dbuf;
 363         const u32 *sbuf32 = sbuf;
 364         unsigned int x;
 365
 366         for (x = 0; x < pixels; x++) {
 367                 *dbuf8++ = (sbuf32[x] & 0x000000FF) >>  0;
 368                 *dbuf8++ = (sbuf32[x] & 0x0000FF00) >>  8;
 369                 *dbuf8++ = (sbuf32[x] & 0x00FF0000) >> 16;
 370         }
 371 }
 372
 373 /**
 374  * drm_fb_xrgb8888_to_rgb888 - Convert XRGB8888 to RGB888 clip buffer
 375  * @dst: RGB888 destination buffer
 376  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 377  * @src: XRGB8888 source buffer
 378  * @fb: DRM framebuffer
 379  * @clip: Clip rectangle area to copy
 380  *
 381  * Drivers can use this function for RGB888 devices that don't natively
 382  * support XRGB8888.
 383  */
 384 void drm_fb_xrgb8888_to_rgb888(void *dst, unsigned int dst_pitch, const void *src,
 385                                const struct drm_framebuffer *fb, const struct drm_rect *clip)
 386 {
 387         drm_fb_xfrm(dst, dst_pitch, 3, src, fb, clip, false, drm_fb_xrgb8888_to_rgb888_line);
 388 }
 389 EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb888);
 390
 391 /**
 392  * drm_fb_xrgb8888_to_rgb888_toio - Convert XRGB8888 to RGB888 clip buffer
 393  * @dst: RGB565 destination buffer (iomem)
 394  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 395  * @vaddr: XRGB8888 source buffer
 396  * @fb: DRM framebuffer
 397  * @clip: Clip rectangle area to copy
 398  *
 399  * Drivers can use this function for RGB888 devices that don't natively
 400  * support XRGB8888.
 401  */
 402 void drm_fb_xrgb8888_to_rgb888_toio(void __iomem *dst, unsigned int dst_pitch,
 403                                     const void *vaddr, const struct drm_framebuffer *fb,
 404                                     const struct drm_rect *clip)
 405 {
 406         drm_fb_xfrm_toio(dst, dst_pitch, 3, vaddr, fb, clip, false,
 407                          drm_fb_xrgb8888_to_rgb888_line);
 408 }
 409 EXPORT_SYMBOL(drm_fb_xrgb8888_to_rgb888_toio);
 410
 411 static void drm_fb_rgb565_to_xrgb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
 412 {
 413         u32 *dbuf32 = dbuf;
 414         const u16 *sbuf16 = sbuf;
 415         unsigned int x;
 416
 417         for (x = 0; x < pixels; x++, ++sbuf16, ++dbuf32) {
 418                 u32 val32 = ((*sbuf16 & 0xf800) << 8) |
 419                             ((*sbuf16 & 0x07e0) << 5) |
 420                             ((*sbuf16 & 0x001f) << 3);
 421                 *dbuf32 = 0xff000000 | val32 |
 422                           ((val32 >> 3) & 0x00070007) |
 423                           ((val32 >> 2) & 0x00000300);
 424         }
 425 }
 426
 427 static void drm_fb_rgb565_to_xrgb8888_toio(void __iomem *dst, unsigned int dst_pitch,
 428                                            const void *vaddr, const struct drm_framebuffer *fb,
 429                                            const struct drm_rect *clip)
 430 {
 431         drm_fb_xfrm_toio(dst, dst_pitch, 4, vaddr, fb, clip, false,
 432                          drm_fb_rgb565_to_xrgb8888_line);
 433 }
 434
 435 static void drm_fb_rgb888_to_xrgb8888_line(void *dbuf, const void *sbuf, unsigned int pixels)
 436 {
 437         u32 *dbuf32 = dbuf;
 438         const u8 *sbuf8 = sbuf;
 439         unsigned int x;
 440
 441         for (x = 0; x < pixels; x++) {
 442                 u8 r = *sbuf8++;
 443                 u8 g = *sbuf8++;
 444                 u8 b = *sbuf8++;
 445                 *dbuf32++ = 0xff000000 | (r << 16) | (g << 8) | b;
 446         }
 447 }
 448
 449 static void drm_fb_rgb888_to_xrgb8888_toio(void __iomem *dst, unsigned int dst_pitch,
 450                                            const void *vaddr, const struct drm_framebuffer *fb,
 451                                            const struct drm_rect *clip)
 452 {
 453         drm_fb_xfrm_toio(dst, dst_pitch, 4, vaddr, fb, clip, false,
 454                          drm_fb_rgb888_to_xrgb8888_line);
 455 }
 456
 457 static void drm_fb_xrgb8888_to_xrgb2101010_line(void *dbuf, const void *sbuf, unsigned int pixels)
 458 {
 459         u32 *dbuf32 = dbuf;
 460         const u32 *sbuf32 = sbuf;
 461         unsigned int x;
 462         u32 val32;
 463
 464         for (x = 0; x < pixels; x++) {
 465                 val32 = ((sbuf32[x] & 0x000000FF) << 2) |
 466                         ((sbuf32[x] & 0x0000FF00) << 4) |
 467                         ((sbuf32[x] & 0x00FF0000) << 6);
 468                 *dbuf32++ = val32 | ((val32 >> 8) & 0x00300C03);
 469         }
 470 }
 471
 472 /**
 473  * drm_fb_xrgb8888_to_xrgb2101010_toio - Convert XRGB8888 to XRGB2101010 clip
 474  * buffer
 475  * @dst: XRGB2101010 destination buffer (iomem)
 476  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 477  * @vaddr: XRGB8888 source buffer
 478  * @fb: DRM framebuffer
 479  * @clip: Clip rectangle area to copy
 480  *
 481  * Drivers can use this function for XRGB2101010 devices that don't natively
 482  * support XRGB8888.
 483  */
 484 void drm_fb_xrgb8888_to_xrgb2101010_toio(void __iomem *dst,
 485                                          unsigned int dst_pitch, const void *vaddr,
 486                                          const struct drm_framebuffer *fb,
 487                                          const struct drm_rect *clip)
 488 {
 489         drm_fb_xfrm_toio(dst, dst_pitch, 4, vaddr, fb, clip, false,
 490                          drm_fb_xrgb8888_to_xrgb2101010_line);
 491 }
 492 EXPORT_SYMBOL(drm_fb_xrgb8888_to_xrgb2101010_toio);
 493
 494 static void drm_fb_xrgb8888_to_gray8_line(void *dbuf, const void *sbuf, unsigned int pixels)
 495 {
 496         u8 *dbuf8 = dbuf;
 497         const u32 *sbuf32 = sbuf;
 498         unsigned int x;
 499
 500         for (x = 0; x < pixels; x++) {
 501                 u8 r = (*sbuf32 & 0x00ff0000) >> 16;
 502                 u8 g = (*sbuf32 & 0x0000ff00) >> 8;
 503                 u8 b =  *sbuf32 & 0x000000ff;
 504
 505                 /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
 506                 *dbuf8++ = (3 * r + 6 * g + b) / 10;
 507                 sbuf32++;
 508         }
 509 }
 510
 511 /**
 512  * drm_fb_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
 513  * @dst: 8-bit grayscale destination buffer
 514  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 515  * @vaddr: XRGB8888 source buffer
 516  * @fb: DRM framebuffer
 517  * @clip: Clip rectangle area to copy
 518  *
 519  * Drm doesn't have native monochrome or grayscale support.
 520  * Such drivers can announce the commonly supported XR24 format to userspace
 521  * and use this function to convert to the native format.
 522  *
 523  * Monochrome drivers will use the most significant bit,
 524  * where 1 means foreground color and 0 background color.
 525  *
 526  * ITU BT.601 is used for the RGB -> luma (brightness) conversion.
 527  */
 528 void drm_fb_xrgb8888_to_gray8(void *dst, unsigned int dst_pitch, const void *vaddr,
 529                               const struct drm_framebuffer *fb, const struct drm_rect *clip)
 530 {
 531         drm_fb_xfrm(dst, dst_pitch, 1, vaddr, fb, clip, false, drm_fb_xrgb8888_to_gray8_line);
 532 }
 533 EXPORT_SYMBOL(drm_fb_xrgb8888_to_gray8);
 534
 535 /**
 536  * drm_fb_blit_toio - Copy parts of a framebuffer to display memory
 537  * @dst:        The display memory to copy to
 538  * @dst_pitch:  Number of bytes between two consecutive scanlines within dst
 539  * @dst_format: FOURCC code of the display's color format
 540  * @vmap:       The framebuffer memory to copy from
 541  * @fb:         The framebuffer to copy from
 542  * @clip:       Clip rectangle area to copy
 543  *
 544  * This function copies parts of a framebuffer to display memory. If the
 545  * formats of the display and the framebuffer mismatch, the blit function
 546  * will attempt to convert between them.
 547  *
 548  * Returns:
 549  * 0 on success, or
 550  * -EINVAL if the color-format conversion failed, or
 551  * a negative error code otherwise.
 552  */
 553 int drm_fb_blit_toio(void __iomem *dst, unsigned int dst_pitch, uint32_t dst_format,
 554                      const void *vmap, const struct drm_framebuffer *fb,
 555                      const struct drm_rect *clip)
 556 {
 557         uint32_t fb_format = fb->format->format;
 558
 559         /* treat alpha channel like filler bits */
 560         if (fb_format == DRM_FORMAT_ARGB8888)
 561                 fb_format = DRM_FORMAT_XRGB8888;
 562         if (dst_format == DRM_FORMAT_ARGB8888)
 563                 dst_format = DRM_FORMAT_XRGB8888;
 564         if (fb_format == DRM_FORMAT_ARGB2101010)
 565                 fb_format = DRM_FORMAT_XRGB2101010;
 566         if (dst_format == DRM_FORMAT_ARGB2101010)
 567                 dst_format = DRM_FORMAT_XRGB2101010;
 568
 569         if (dst_format == fb_format) {
 570                 drm_fb_memcpy_toio(dst, dst_pitch, vmap, fb, clip);
 571                 return 0;
 572
 573         } else if (dst_format == DRM_FORMAT_RGB565) {
 574                 if (fb_format == DRM_FORMAT_XRGB8888) {
 575                         drm_fb_xrgb8888_to_rgb565_toio(dst, dst_pitch, vmap, fb, clip, false);
 576                         return 0;
 577                 }
 578         } else if (dst_format == DRM_FORMAT_RGB888) {
 579                 if (fb_format == DRM_FORMAT_XRGB8888) {
 580                         drm_fb_xrgb8888_to_rgb888_toio(dst, dst_pitch, vmap, fb, clip);
 581                         return 0;
 582                 }
 583         } else if (dst_format == DRM_FORMAT_XRGB8888) {
 584                 if (fb_format == DRM_FORMAT_RGB888) {
 585                         drm_fb_rgb888_to_xrgb8888_toio(dst, dst_pitch, vmap, fb, clip);
 586                         return 0;
 587                 } else if (fb_format == DRM_FORMAT_RGB565) {
 588                         drm_fb_rgb565_to_xrgb8888_toio(dst, dst_pitch, vmap, fb, clip);
 589                         return 0;
 590                 }
 591         } else if (dst_format == DRM_FORMAT_XRGB2101010) {
 592                 if (fb_format == DRM_FORMAT_XRGB8888) {
 593                         drm_fb_xrgb8888_to_xrgb2101010_toio(dst, dst_pitch, vmap, fb, clip);
 594                         return 0;
 595                 }
 596         }
 597
 598         drm_warn_once(fb->dev, "No conversion helper from %p4cc to %p4cc found.\n",
 599                       &fb_format, &dst_format);
 600
 601         return -EINVAL;
 602 }
 603 EXPORT_SYMBOL(drm_fb_blit_toio);
 604
 605
 606 static void drm_fb_gray8_to_mono_line(void *dbuf, const void *sbuf, unsigned int pixels)
 607 {
 608         u8 *dbuf8 = dbuf;
 609         const u8 *sbuf8 = sbuf;
 610
 611         while (pixels) {
 612                 unsigned int i, bits = min(pixels, 8U);
 613                 u8 byte = 0;
 614
 615                 for (i = 0; i < bits; i++, pixels--) {
 616                         if (*sbuf8++ >= 128)
 617                                 byte |= BIT(i);
 618                 }
 619                 *dbuf8++ = byte;
 620         }
 621 }
 622
 623 /**
 624  * drm_fb_xrgb8888_to_mono - Convert XRGB8888 to monochrome
 625  * @dst: monochrome destination buffer (0=black, 1=white)
 626  * @dst_pitch: Number of bytes between two consecutive scanlines within dst
 627  * @vaddr: XRGB8888 source buffer
 628  * @fb: DRM framebuffer
 629  * @clip: Clip rectangle area to copy
 630  *
 631  * DRM doesn't have native monochrome support.
 632  * Such drivers can announce the commonly supported XR24 format to userspace
 633  * and use this function to convert to the native format.
 634  *
 635  * This function uses drm_fb_xrgb8888_to_gray8() to convert to grayscale and
 636  * then the result is converted from grayscale to monochrome.
 637  *
 638  * The first pixel (upper left corner of the clip rectangle) will be converted
 639  * and copied to the first bit (LSB) in the first byte of the monochrome
 640  * destination buffer.
 641  * If the caller requires that the first pixel in a byte must be located at an
 642  * x-coordinate that is a multiple of 8, then the caller must take care itself
 643  * of supplying a suitable clip rectangle.
 644  */
 645 void drm_fb_xrgb8888_to_mono(void *dst, unsigned int dst_pitch, const void *vaddr,
 646                              const struct drm_framebuffer *fb, const struct drm_rect *clip)
 647 {
 648         unsigned int linepixels = drm_rect_width(clip);
 649         unsigned int lines = drm_rect_height(clip);
 650         unsigned int cpp = fb->format->cpp[0];
 651         unsigned int len_src32 = linepixels * cpp;
 652         struct drm_device *dev = fb->dev;
 653         unsigned int y;
 654         u8 *mono = dst, *gray8;
 655         u32 *src32;
 656
 657         if (drm_WARN_ON(dev, fb->format->format != DRM_FORMAT_XRGB8888))
 658                 return;
 659
 660         /*
 661          * The mono destination buffer contains 1 bit per pixel
 662          */
 663         if (!dst_pitch)
 664                 dst_pitch = DIV_ROUND_UP(linepixels, 8);
 665
 666         /*
 667          * The cma memory is write-combined so reads are uncached.
 668          * Speed up by fetching one line at a time.
 669          *
 670          * Also, format conversion from XR24 to monochrome are done
 671          * line-by-line but are converted to 8-bit grayscale as an
 672          * intermediate step.
 673          *
 674          * Allocate a buffer to be used for both copying from the cma
 675          * memory and to store the intermediate grayscale line pixels.
 676          */
 677         src32 = kmalloc(len_src32 + linepixels, GFP_KERNEL);
 678         if (!src32)
 679                 return;
 680
 681         gray8 = (u8 *)src32 + len_src32;
 682
 683         vaddr += clip_offset(clip, fb->pitches[0], cpp);
 684         for (y = 0; y < lines; y++) {
 685                 src32 = memcpy(src32, vaddr, len_src32);
 686                 drm_fb_xrgb8888_to_gray8_line(gray8, src32, linepixels);
 687                 drm_fb_gray8_to_mono_line(mono, gray8, linepixels);
 688                 vaddr += fb->pitches[0];
 689                 mono += dst_pitch;
 690         }
 691
 692         kfree(src32);
 693 }
 694 EXPORT_SYMBOL(drm_fb_xrgb8888_to_mono);