drivers/gpu/drm/tinydrm/core/tinydrm-helpers.c

   1 /*
   2  * Copyright (C) 2016 Noralf Trønnes
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  */
   9
  10 #include <linux/backlight.h>
  11 #include <linux/dma-buf.h>
  12 #include <linux/pm.h>
  13 #include <linux/spi/spi.h>
  14 #include <linux/swab.h>
  15
  16 #include <drm/tinydrm/tinydrm.h>
  17 #include <drm/tinydrm/tinydrm-helpers.h>
  18
  19 static unsigned int spi_max;
  20 module_param(spi_max, uint, 0400);
  21 MODULE_PARM_DESC(spi_max, "Set a lower SPI max transfer size");
  22
  23 /**
  24  * tinydrm_merge_clips - Merge clip rectangles
  25  * @dst: Destination clip rectangle
  26  * @src: Source clip rectangle(s)
  27  * @num_clips: Number of @src clip rectangles
  28  * @flags: Dirty fb ioctl flags
  29  * @max_width: Maximum width of @dst
  30  * @max_height: Maximum height of @dst
  31  *
  32  * This function merges @src clip rectangle(s) into @dst. If @src is NULL,
  33  * @max_width and @min_width is used to set a full @dst clip rectangle.
  34  *
  35  * Returns:
  36  * true if it's a full clip, false otherwise
  37  */
  38 bool tinydrm_merge_clips(struct drm_clip_rect *dst,
  39                          struct drm_clip_rect *src, unsigned int num_clips,
  40                          unsigned int flags, u32 max_width, u32 max_height)
  41 {
  42         unsigned int i;
  43
  44         if (!src || !num_clips) {
  45                 dst->x1 = 0;
  46                 dst->x2 = max_width;
  47                 dst->y1 = 0;
  48                 dst->y2 = max_height;
  49                 return true;
  50         }
  51
  52         dst->x1 = ~0;
  53         dst->y1 = ~0;
  54         dst->x2 = 0;
  55         dst->y2 = 0;
  56
  57         for (i = 0; i < num_clips; i++) {
  58                 if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY)
  59                         i++;
  60                 dst->x1 = min(dst->x1, src[i].x1);
  61                 dst->x2 = max(dst->x2, src[i].x2);
  62                 dst->y1 = min(dst->y1, src[i].y1);
  63                 dst->y2 = max(dst->y2, src[i].y2);
  64         }
  65
  66         if (dst->x2 > max_width || dst->y2 > max_height ||
  67             dst->x1 >= dst->x2 || dst->y1 >= dst->y2) {
  68                 DRM_DEBUG_KMS("Illegal clip: x1=%u, x2=%u, y1=%u, y2=%u\n",
  69                               dst->x1, dst->x2, dst->y1, dst->y2);
  70                 dst->x1 = 0;
  71                 dst->y1 = 0;
  72                 dst->x2 = max_width;
  73                 dst->y2 = max_height;
  74         }
  75
  76         return (dst->x2 - dst->x1) == max_width &&
  77                (dst->y2 - dst->y1) == max_height;
  78 }
  79 EXPORT_SYMBOL(tinydrm_merge_clips);
  80
  81 int tinydrm_fb_dirty(struct drm_framebuffer *fb,
  82                      struct drm_file *file_priv,
  83                      unsigned int flags, unsigned int color,
  84                      struct drm_clip_rect *clips,
  85                      unsigned int num_clips)
  86 {
  87         struct tinydrm_device *tdev = fb->dev->dev_private;
  88         struct drm_plane *plane = &tdev->pipe.plane;
  89         int ret = 0;
  90
  91         drm_modeset_lock(&plane->mutex, NULL);
  92
  93         /* fbdev can flush even when we're not interested */
  94         if (plane->state->fb == fb) {
  95                 mutex_lock(&tdev->dirty_lock);
  96                 ret = tdev->fb_dirty(fb, file_priv, flags,
  97                                      color, clips, num_clips);
  98                 mutex_unlock(&tdev->dirty_lock);
  99         }
 100
 101         drm_modeset_unlock(&plane->mutex);
 102
 103         if (ret)
 104                 dev_err_once(fb->dev->dev,
 105                              "Failed to update display %d\n", ret);
 106
 107         return ret;
 108 }
 109 EXPORT_SYMBOL(tinydrm_fb_dirty);
 110
 111 /**
 112  * tinydrm_memcpy - Copy clip buffer
 113  * @dst: Destination buffer
 114  * @vaddr: Source buffer
 115  * @fb: DRM framebuffer
 116  * @clip: Clip rectangle area to copy
 117  */
 118 void tinydrm_memcpy(void *dst, void *vaddr, struct drm_framebuffer *fb,
 119                     struct drm_clip_rect *clip)
 120 {
 121         unsigned int cpp = drm_format_plane_cpp(fb->format->format, 0);
 122         unsigned int pitch = fb->pitches[0];
 123         void *src = vaddr + (clip->y1 * pitch) + (clip->x1 * cpp);
 124         size_t len = (clip->x2 - clip->x1) * cpp;
 125         unsigned int y;
 126
 127         for (y = clip->y1; y < clip->y2; y++) {
 128                 memcpy(dst, src, len);
 129                 src += pitch;
 130                 dst += len;
 131         }
 132 }
 133 EXPORT_SYMBOL(tinydrm_memcpy);
 134
 135 /**
 136  * tinydrm_swab16 - Swap bytes into clip buffer
 137  * @dst: RGB565 destination buffer
 138  * @vaddr: RGB565 source buffer
 139  * @fb: DRM framebuffer
 140  * @clip: Clip rectangle area to copy
 141  */
 142 void tinydrm_swab16(u16 *dst, void *vaddr, struct drm_framebuffer *fb,
 143                     struct drm_clip_rect *clip)
 144 {
 145         size_t len = (clip->x2 - clip->x1) * sizeof(u16);
 146         unsigned int x, y;
 147         u16 *src, *buf;
 148
 149         /*
 150          * The cma memory is write-combined so reads are uncached.
 151          * Speed up by fetching one line at a time.
 152          */
 153         buf = kmalloc(len, GFP_KERNEL);
 154         if (!buf)
 155                 return;
 156
 157         for (y = clip->y1; y < clip->y2; y++) {
 158                 src = vaddr + (y * fb->pitches[0]);
 159                 src += clip->x1;
 160                 memcpy(buf, src, len);
 161                 src = buf;
 162                 for (x = clip->x1; x < clip->x2; x++)
 163                         *dst++ = swab16(*src++);
 164         }
 165
 166         kfree(buf);
 167 }
 168 EXPORT_SYMBOL(tinydrm_swab16);
 169
 170 /**
 171  * tinydrm_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
 172  * @dst: RGB565 destination buffer
 173  * @vaddr: XRGB8888 source buffer
 174  * @fb: DRM framebuffer
 175  * @clip: Clip rectangle area to copy
 176  * @swap: Swap bytes
 177  *
 178  * Drivers can use this function for RGB565 devices that don't natively
 179  * support XRGB8888.
 180  */
 181 void tinydrm_xrgb8888_to_rgb565(u16 *dst, void *vaddr,
 182                                 struct drm_framebuffer *fb,
 183                                 struct drm_clip_rect *clip, bool swap)
 184 {
 185         size_t len = (clip->x2 - clip->x1) * sizeof(u32);
 186         unsigned int x, y;
 187         u32 *src, *buf;
 188         u16 val16;
 189
 190         buf = kmalloc(len, GFP_KERNEL);
 191         if (!buf)
 192                 return;
 193
 194         for (y = clip->y1; y < clip->y2; y++) {
 195                 src = vaddr + (y * fb->pitches[0]);
 196                 src += clip->x1;
 197                 memcpy(buf, src, len);
 198                 src = buf;
 199                 for (x = clip->x1; x < clip->x2; x++) {
 200                         val16 = ((*src & 0x00F80000) >> 8) |
 201                                 ((*src & 0x0000FC00) >> 5) |
 202                                 ((*src & 0x000000F8) >> 3);
 203                         src++;
 204                         if (swap)
 205                                 *dst++ = swab16(val16);
 206                         else
 207                                 *dst++ = val16;
 208                 }
 209         }
 210
 211         kfree(buf);
 212 }
 213 EXPORT_SYMBOL(tinydrm_xrgb8888_to_rgb565);
 214
 215 /**
 216  * tinydrm_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
 217  * @dst: 8-bit grayscale destination buffer
 218  * @vaddr: XRGB8888 source buffer
 219  * @fb: DRM framebuffer
 220  * @clip: Clip rectangle area to copy
 221  *
 222  * Drm doesn't have native monochrome or grayscale support.
 223  * Such drivers can announce the commonly supported XR24 format to userspace
 224  * and use this function to convert to the native format.
 225  *
 226  * Monochrome drivers will use the most significant bit,
 227  * where 1 means foreground color and 0 background color.
 228  *
 229  * ITU BT.601 is used for the RGB -> luma (brightness) conversion.
 230  */
 231 void tinydrm_xrgb8888_to_gray8(u8 *dst, void *vaddr, struct drm_framebuffer *fb,
 232                                struct drm_clip_rect *clip)
 233 {
 234         unsigned int len = (clip->x2 - clip->x1) * sizeof(u32);
 235         unsigned int x, y;
 236         void *buf;
 237         u32 *src;
 238
 239         if (WARN_ON(fb->format->format != DRM_FORMAT_XRGB8888))
 240                 return;
 241         /*
 242          * The cma memory is write-combined so reads are uncached.
 243          * Speed up by fetching one line at a time.
 244          */
 245         buf = kmalloc(len, GFP_KERNEL);
 246         if (!buf)
 247                 return;
 248
 249         for (y = clip->y1; y < clip->y2; y++) {
 250                 src = vaddr + (y * fb->pitches[0]);
 251                 src += clip->x1;
 252                 memcpy(buf, src, len);
 253                 src = buf;
 254                 for (x = clip->x1; x < clip->x2; x++) {
 255                         u8 r = (*src & 0x00ff0000) >> 16;
 256                         u8 g = (*src & 0x0000ff00) >> 8;
 257                         u8 b =  *src & 0x000000ff;
 258
 259                         /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
 260                         *dst++ = (3 * r + 6 * g + b) / 10;
 261                         src++;
 262                 }
 263         }
 264
 265         kfree(buf);
 266 }
 267 EXPORT_SYMBOL(tinydrm_xrgb8888_to_gray8);
 268
 269 #if IS_ENABLED(CONFIG_SPI)
 270
 271 /**
 272  * tinydrm_spi_max_transfer_size - Determine max SPI transfer size
 273  * @spi: SPI device
 274  * @max_len: Maximum buffer size needed (optional)
 275  *
 276  * This function returns the maximum size to use for SPI transfers. It checks
 277  * the SPI master, the optional @max_len and the module parameter spi_max and
 278  * returns the smallest.
 279  *
 280  * Returns:
 281  * Maximum size for SPI transfers
 282  */
 283 size_t tinydrm_spi_max_transfer_size(struct spi_device *spi, size_t max_len)
 284 {
 285         size_t ret;
 286
 287         ret = min(spi_max_transfer_size(spi), spi->master->max_dma_len);
 288         if (max_len)
 289                 ret = min(ret, max_len);
 290         if (spi_max)
 291                 ret = min_t(size_t, ret, spi_max);
 292         ret &= ~0x3;
 293         if (ret < 4)
 294                 ret = 4;
 295
 296         return ret;
 297 }
 298 EXPORT_SYMBOL(tinydrm_spi_max_transfer_size);
 299
 300 /**
 301  * tinydrm_spi_bpw_supported - Check if bits per word is supported
 302  * @spi: SPI device
 303  * @bpw: Bits per word
 304  *
 305  * This function checks to see if the SPI master driver supports @bpw.
 306  *
 307  * Returns:
 308  * True if @bpw is supported, false otherwise.
 309  */
 310 bool tinydrm_spi_bpw_supported(struct spi_device *spi, u8 bpw)
 311 {
 312         u32 bpw_mask = spi->master->bits_per_word_mask;
 313
 314         if (bpw == 8)
 315                 return true;
 316
 317         if (!bpw_mask) {
 318                 dev_warn_once(&spi->dev,
 319                               "bits_per_word_mask not set, assume 8-bit only\n");
 320                 return false;
 321         }
 322
 323         if (bpw_mask & SPI_BPW_MASK(bpw))
 324                 return true;
 325
 326         return false;
 327 }
 328 EXPORT_SYMBOL(tinydrm_spi_bpw_supported);
 329
 330 static void
 331 tinydrm_dbg_spi_print(struct spi_device *spi, struct spi_transfer *tr,
 332                       const void *buf, int idx, bool tx)
 333 {
 334         u32 speed_hz = tr->speed_hz ? tr->speed_hz : spi->max_speed_hz;
 335         char linebuf[3 * 32];
 336
 337         hex_dump_to_buffer(buf, tr->len, 16,
 338                            DIV_ROUND_UP(tr->bits_per_word, 8),
 339                            linebuf, sizeof(linebuf), false);
 340
 341         printk(KERN_DEBUG
 342                "    tr(%i): speed=%u%s, bpw=%i, len=%u, %s_buf=[%s%s]\n", idx,
 343                speed_hz > 1000000 ? speed_hz / 1000000 : speed_hz / 1000,
 344                speed_hz > 1000000 ? "MHz" : "kHz", tr->bits_per_word, tr->len,
 345                tx ? "tx" : "rx", linebuf, tr->len > 16 ? " ..." : "");
 346 }
 347
 348 /* called through tinydrm_dbg_spi_message() */
 349 void _tinydrm_dbg_spi_message(struct spi_device *spi, struct spi_message *m)
 350 {
 351         struct spi_transfer *tmp;
 352         int i = 0;
 353
 354         list_for_each_entry(tmp, &m->transfers, transfer_list) {
 355
 356                 if (tmp->tx_buf)
 357                         tinydrm_dbg_spi_print(spi, tmp, tmp->tx_buf, i, true);
 358                 if (tmp->rx_buf)
 359                         tinydrm_dbg_spi_print(spi, tmp, tmp->rx_buf, i, false);
 360                 i++;
 361         }
 362 }
 363 EXPORT_SYMBOL(_tinydrm_dbg_spi_message);
 364
 365 /**
 366  * tinydrm_spi_transfer - SPI transfer helper
 367  * @spi: SPI device
 368  * @speed_hz: Override speed (optional)
 369  * @header: Optional header transfer
 370  * @bpw: Bits per word
 371  * @buf: Buffer to transfer
 372  * @len: Buffer length
 373  *
 374  * This SPI transfer helper breaks up the transfer of @buf into chunks which
 375  * the SPI master driver can handle. If the machine is Little Endian and the
 376  * SPI master driver doesn't support 16 bits per word, it swaps the bytes and
 377  * does a 8-bit transfer.
 378  * If @header is set, it is prepended to each SPI message.
 379  *
 380  * Returns:
 381  * Zero on success, negative error code on failure.
 382  */
 383 int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz,
 384                          struct spi_transfer *header, u8 bpw, const void *buf,
 385                          size_t len)
 386 {
 387         struct spi_transfer tr = {
 388                 .bits_per_word = bpw,
 389                 .speed_hz = speed_hz,
 390         };
 391         struct spi_message m;
 392         u16 *swap_buf = NULL;
 393         size_t max_chunk;
 394         size_t chunk;
 395         int ret = 0;
 396
 397         if (WARN_ON_ONCE(bpw != 8 && bpw != 16))
 398                 return -EINVAL;
 399
 400         max_chunk = tinydrm_spi_max_transfer_size(spi, 0);
 401
 402         if (drm_debug & DRM_UT_DRIVER)
 403                 pr_debug("[drm:%s] bpw=%u, max_chunk=%zu, transfers:\n",
 404                          __func__, bpw, max_chunk);
 405
 406         if (bpw == 16 && !tinydrm_spi_bpw_supported(spi, 16)) {
 407                 tr.bits_per_word = 8;
 408                 if (tinydrm_machine_little_endian()) {
 409                         swap_buf = kmalloc(min(len, max_chunk), GFP_KERNEL);
 410                         if (!swap_buf)
 411                                 return -ENOMEM;
 412                 }
 413         }
 414
 415         spi_message_init(&m);
 416         if (header)
 417                 spi_message_add_tail(header, &m);
 418         spi_message_add_tail(&tr, &m);
 419
 420         while (len) {
 421                 chunk = min(len, max_chunk);
 422
 423                 tr.tx_buf = buf;
 424                 tr.len = chunk;
 425
 426                 if (swap_buf) {
 427                         const u16 *buf16 = buf;
 428                         unsigned int i;
 429
 430                         for (i = 0; i < chunk / 2; i++)
 431                                 swap_buf[i] = swab16(buf16[i]);
 432
 433                         tr.tx_buf = swap_buf;
 434                 }
 435
 436                 buf += chunk;
 437                 len -= chunk;
 438
 439                 tinydrm_dbg_spi_message(spi, &m);
 440                 ret = spi_sync(spi, &m);
 441                 if (ret)
 442                         return ret;
 443         }
 444
 445         return 0;
 446 }
 447 EXPORT_SYMBOL(tinydrm_spi_transfer);
 448
 449 #endif /* CONFIG_SPI */