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 /**
  82  * tinydrm_memcpy - Copy clip buffer
  83  * @dst: Destination buffer
  84  * @vaddr: Source buffer
  85  * @fb: DRM framebuffer
  86  * @clip: Clip rectangle area to copy
  87  */
  88 void tinydrm_memcpy(void *dst, void *vaddr, struct drm_framebuffer *fb,
  89                     struct drm_clip_rect *clip)
  90 {
  91         unsigned int cpp = drm_format_plane_cpp(fb->format->format, 0);
  92         unsigned int pitch = fb->pitches[0];
  93         void *src = vaddr + (clip->y1 * pitch) + (clip->x1 * cpp);
  94         size_t len = (clip->x2 - clip->x1) * cpp;
  95         unsigned int y;
  96
  97         for (y = clip->y1; y < clip->y2; y++) {
  98                 memcpy(dst, src, len);
  99                 src += pitch;
 100                 dst += len;
 101         }
 102 }
 103 EXPORT_SYMBOL(tinydrm_memcpy);
 104
 105 /**
 106  * tinydrm_swab16 - Swap bytes into clip buffer
 107  * @dst: RGB565 destination buffer
 108  * @vaddr: RGB565 source buffer
 109  * @fb: DRM framebuffer
 110  * @clip: Clip rectangle area to copy
 111  */
 112 void tinydrm_swab16(u16 *dst, void *vaddr, struct drm_framebuffer *fb,
 113                     struct drm_clip_rect *clip)
 114 {
 115         size_t len = (clip->x2 - clip->x1) * sizeof(u16);
 116         unsigned int x, y;
 117         u16 *src, *buf;
 118
 119         /*
 120          * The cma memory is write-combined so reads are uncached.
 121          * Speed up by fetching one line at a time.
 122          */
 123         buf = kmalloc(len, GFP_KERNEL);
 124         if (!buf)
 125                 return;
 126
 127         for (y = clip->y1; y < clip->y2; y++) {
 128                 src = vaddr + (y * fb->pitches[0]);
 129                 src += clip->x1;
 130                 memcpy(buf, src, len);
 131                 src = buf;
 132                 for (x = clip->x1; x < clip->x2; x++)
 133                         *dst++ = swab16(*src++);
 134         }
 135
 136         kfree(buf);
 137 }
 138 EXPORT_SYMBOL(tinydrm_swab16);
 139
 140 /**
 141  * tinydrm_xrgb8888_to_rgb565 - Convert XRGB8888 to RGB565 clip buffer
 142  * @dst: RGB565 destination buffer
 143  * @vaddr: XRGB8888 source buffer
 144  * @fb: DRM framebuffer
 145  * @clip: Clip rectangle area to copy
 146  * @swap: Swap bytes
 147  *
 148  * Drivers can use this function for RGB565 devices that don't natively
 149  * support XRGB8888.
 150  */
 151 void tinydrm_xrgb8888_to_rgb565(u16 *dst, void *vaddr,
 152                                 struct drm_framebuffer *fb,
 153                                 struct drm_clip_rect *clip, bool swap)
 154 {
 155         size_t len = (clip->x2 - clip->x1) * sizeof(u32);
 156         unsigned int x, y;
 157         u32 *src, *buf;
 158         u16 val16;
 159
 160         buf = kmalloc(len, GFP_KERNEL);
 161         if (!buf)
 162                 return;
 163
 164         for (y = clip->y1; y < clip->y2; y++) {
 165                 src = vaddr + (y * fb->pitches[0]);
 166                 src += clip->x1;
 167                 memcpy(buf, src, len);
 168                 src = buf;
 169                 for (x = clip->x1; x < clip->x2; x++) {
 170                         val16 = ((*src & 0x00F80000) >> 8) |
 171                                 ((*src & 0x0000FC00) >> 5) |
 172                                 ((*src & 0x000000F8) >> 3);
 173                         src++;
 174                         if (swap)
 175                                 *dst++ = swab16(val16);
 176                         else
 177                                 *dst++ = val16;
 178                 }
 179         }
 180
 181         kfree(buf);
 182 }
 183 EXPORT_SYMBOL(tinydrm_xrgb8888_to_rgb565);
 184
 185 /**
 186  * tinydrm_xrgb8888_to_gray8 - Convert XRGB8888 to grayscale
 187  * @dst: 8-bit grayscale destination buffer
 188  * @vaddr: XRGB8888 source buffer
 189  * @fb: DRM framebuffer
 190  * @clip: Clip rectangle area to copy
 191  *
 192  * Drm doesn't have native monochrome or grayscale support.
 193  * Such drivers can announce the commonly supported XR24 format to userspace
 194  * and use this function to convert to the native format.
 195  *
 196  * Monochrome drivers will use the most significant bit,
 197  * where 1 means foreground color and 0 background color.
 198  *
 199  * ITU BT.601 is used for the RGB -> luma (brightness) conversion.
 200  */
 201 void tinydrm_xrgb8888_to_gray8(u8 *dst, void *vaddr, struct drm_framebuffer *fb,
 202                                struct drm_clip_rect *clip)
 203 {
 204         unsigned int len = (clip->x2 - clip->x1) * sizeof(u32);
 205         unsigned int x, y;
 206         void *buf;
 207         u32 *src;
 208
 209         if (WARN_ON(fb->format->format != DRM_FORMAT_XRGB8888))
 210                 return;
 211         /*
 212          * The cma memory is write-combined so reads are uncached.
 213          * Speed up by fetching one line at a time.
 214          */
 215         buf = kmalloc(len, GFP_KERNEL);
 216         if (!buf)
 217                 return;
 218
 219         for (y = clip->y1; y < clip->y2; y++) {
 220                 src = vaddr + (y * fb->pitches[0]);
 221                 src += clip->x1;
 222                 memcpy(buf, src, len);
 223                 src = buf;
 224                 for (x = clip->x1; x < clip->x2; x++) {
 225                         u8 r = (*src & 0x00ff0000) >> 16;
 226                         u8 g = (*src & 0x0000ff00) >> 8;
 227                         u8 b =  *src & 0x000000ff;
 228
 229                         /* ITU BT.601: Y = 0.299 R + 0.587 G + 0.114 B */
 230                         *dst++ = (3 * r + 6 * g + b) / 10;
 231                         src++;
 232                 }
 233         }
 234
 235         kfree(buf);
 236 }
 237 EXPORT_SYMBOL(tinydrm_xrgb8888_to_gray8);
 238
 239 /**
 240  * tinydrm_of_find_backlight - Find backlight device in device-tree
 241  * @dev: Device
 242  *
 243  * This function looks for a DT node pointed to by a property named 'backlight'
 244  * and uses of_find_backlight_by_node() to get the backlight device.
 245  * Additionally if the brightness property is zero, it is set to
 246  * max_brightness.
 247  *
 248  * Returns:
 249  * NULL if there's no backlight property.
 250  * Error pointer -EPROBE_DEFER if the DT node is found, but no backlight device
 251  * is found.
 252  * If the backlight device is found, a pointer to the structure is returned.
 253  */
 254 struct backlight_device *tinydrm_of_find_backlight(struct device *dev)
 255 {
 256         struct backlight_device *backlight;
 257         struct device_node *np;
 258
 259         np = of_parse_phandle(dev->of_node, "backlight", 0);
 260         if (!np)
 261                 return NULL;
 262
 263         backlight = of_find_backlight_by_node(np);
 264         of_node_put(np);
 265
 266         if (!backlight)
 267                 return ERR_PTR(-EPROBE_DEFER);
 268
 269         if (!backlight->props.brightness) {
 270                 backlight->props.brightness = backlight->props.max_brightness;
 271                 DRM_DEBUG_KMS("Backlight brightness set to %d\n",
 272                               backlight->props.brightness);
 273         }
 274
 275         return backlight;
 276 }
 277 EXPORT_SYMBOL(tinydrm_of_find_backlight);
 278
 279 /**
 280  * tinydrm_enable_backlight - Enable backlight helper
 281  * @backlight: Backlight device
 282  *
 283  * Returns:
 284  * Zero on success, negative error code on failure.
 285  */
 286 int tinydrm_enable_backlight(struct backlight_device *backlight)
 287 {
 288         unsigned int old_state;
 289         int ret;
 290
 291         if (!backlight)
 292                 return 0;
 293
 294         old_state = backlight->props.state;
 295         backlight->props.state &= ~BL_CORE_FBBLANK;
 296         DRM_DEBUG_KMS("Backlight state: 0x%x -> 0x%x\n", old_state,
 297                       backlight->props.state);
 298
 299         ret = backlight_update_status(backlight);
 300         if (ret)
 301                 DRM_ERROR("Failed to enable backlight %d\n", ret);
 302
 303         return ret;
 304 }
 305 EXPORT_SYMBOL(tinydrm_enable_backlight);
 306
 307 /**
 308  * tinydrm_disable_backlight - Disable backlight helper
 309  * @backlight: Backlight device
 310  *
 311  * Returns:
 312  * Zero on success, negative error code on failure.
 313  */
 314 int tinydrm_disable_backlight(struct backlight_device *backlight)
 315 {
 316         unsigned int old_state;
 317         int ret;
 318
 319         if (!backlight)
 320                 return 0;
 321
 322         old_state = backlight->props.state;
 323         backlight->props.state |= BL_CORE_FBBLANK;
 324         DRM_DEBUG_KMS("Backlight state: 0x%x -> 0x%x\n", old_state,
 325                       backlight->props.state);
 326         ret = backlight_update_status(backlight);
 327         if (ret)
 328                 DRM_ERROR("Failed to disable backlight %d\n", ret);
 329
 330         return ret;
 331 }
 332 EXPORT_SYMBOL(tinydrm_disable_backlight);
 333
 334 #if IS_ENABLED(CONFIG_SPI)
 335
 336 /**
 337  * tinydrm_spi_max_transfer_size - Determine max SPI transfer size
 338  * @spi: SPI device
 339  * @max_len: Maximum buffer size needed (optional)
 340  *
 341  * This function returns the maximum size to use for SPI transfers. It checks
 342  * the SPI master, the optional @max_len and the module parameter spi_max and
 343  * returns the smallest.
 344  *
 345  * Returns:
 346  * Maximum size for SPI transfers
 347  */
 348 size_t tinydrm_spi_max_transfer_size(struct spi_device *spi, size_t max_len)
 349 {
 350         size_t ret;
 351
 352         ret = min(spi_max_transfer_size(spi), spi->master->max_dma_len);
 353         if (max_len)
 354                 ret = min(ret, max_len);
 355         if (spi_max)
 356                 ret = min_t(size_t, ret, spi_max);
 357         ret &= ~0x3;
 358         if (ret < 4)
 359                 ret = 4;
 360
 361         return ret;
 362 }
 363 EXPORT_SYMBOL(tinydrm_spi_max_transfer_size);
 364
 365 /**
 366  * tinydrm_spi_bpw_supported - Check if bits per word is supported
 367  * @spi: SPI device
 368  * @bpw: Bits per word
 369  *
 370  * This function checks to see if the SPI master driver supports @bpw.
 371  *
 372  * Returns:
 373  * True if @bpw is supported, false otherwise.
 374  */
 375 bool tinydrm_spi_bpw_supported(struct spi_device *spi, u8 bpw)
 376 {
 377         u32 bpw_mask = spi->master->bits_per_word_mask;
 378
 379         if (bpw == 8)
 380                 return true;
 381
 382         if (!bpw_mask) {
 383                 dev_warn_once(&spi->dev,
 384                               "bits_per_word_mask not set, assume 8-bit only\n");
 385                 return false;
 386         }
 387
 388         if (bpw_mask & SPI_BPW_MASK(bpw))
 389                 return true;
 390
 391         return false;
 392 }
 393 EXPORT_SYMBOL(tinydrm_spi_bpw_supported);
 394
 395 static void
 396 tinydrm_dbg_spi_print(struct spi_device *spi, struct spi_transfer *tr,
 397                       const void *buf, int idx, bool tx)
 398 {
 399         u32 speed_hz = tr->speed_hz ? tr->speed_hz : spi->max_speed_hz;
 400         char linebuf[3 * 32];
 401
 402         hex_dump_to_buffer(buf, tr->len, 16,
 403                            DIV_ROUND_UP(tr->bits_per_word, 8),
 404                            linebuf, sizeof(linebuf), false);
 405
 406         printk(KERN_DEBUG
 407                "    tr(%i): speed=%u%s, bpw=%i, len=%u, %s_buf=[%s%s]\n", idx,
 408                speed_hz > 1000000 ? speed_hz / 1000000 : speed_hz / 1000,
 409                speed_hz > 1000000 ? "MHz" : "kHz", tr->bits_per_word, tr->len,
 410                tx ? "tx" : "rx", linebuf, tr->len > 16 ? " ..." : "");
 411 }
 412
 413 /* called through tinydrm_dbg_spi_message() */
 414 void _tinydrm_dbg_spi_message(struct spi_device *spi, struct spi_message *m)
 415 {
 416         struct spi_transfer *tmp;
 417         struct list_head *pos;
 418         int i = 0;
 419
 420         list_for_each(pos, &m->transfers) {
 421                 tmp = list_entry(pos, struct spi_transfer, transfer_list);
 422
 423                 if (tmp->tx_buf)
 424                         tinydrm_dbg_spi_print(spi, tmp, tmp->tx_buf, i, true);
 425                 if (tmp->rx_buf)
 426                         tinydrm_dbg_spi_print(spi, tmp, tmp->rx_buf, i, false);
 427                 i++;
 428         }
 429 }
 430 EXPORT_SYMBOL(_tinydrm_dbg_spi_message);
 431
 432 /**
 433  * tinydrm_spi_transfer - SPI transfer helper
 434  * @spi: SPI device
 435  * @speed_hz: Override speed (optional)
 436  * @header: Optional header transfer
 437  * @bpw: Bits per word
 438  * @buf: Buffer to transfer
 439  * @len: Buffer length
 440  *
 441  * This SPI transfer helper breaks up the transfer of @buf into chunks which
 442  * the SPI master driver can handle. If the machine is Little Endian and the
 443  * SPI master driver doesn't support 16 bits per word, it swaps the bytes and
 444  * does a 8-bit transfer.
 445  * If @header is set, it is prepended to each SPI message.
 446  *
 447  * Returns:
 448  * Zero on success, negative error code on failure.
 449  */
 450 int tinydrm_spi_transfer(struct spi_device *spi, u32 speed_hz,
 451                          struct spi_transfer *header, u8 bpw, const void *buf,
 452                          size_t len)
 453 {
 454         struct spi_transfer tr = {
 455                 .bits_per_word = bpw,
 456                 .speed_hz = speed_hz,
 457         };
 458         struct spi_message m;
 459         u16 *swap_buf = NULL;
 460         size_t max_chunk;
 461         size_t chunk;
 462         int ret = 0;
 463
 464         if (WARN_ON_ONCE(bpw != 8 && bpw != 16))
 465                 return -EINVAL;
 466
 467         max_chunk = tinydrm_spi_max_transfer_size(spi, 0);
 468
 469         if (drm_debug & DRM_UT_DRIVER)
 470                 pr_debug("[drm:%s] bpw=%u, max_chunk=%zu, transfers:\n",
 471                          __func__, bpw, max_chunk);
 472
 473         if (bpw == 16 && !tinydrm_spi_bpw_supported(spi, 16)) {
 474                 tr.bits_per_word = 8;
 475                 if (tinydrm_machine_little_endian()) {
 476                         swap_buf = kmalloc(min(len, max_chunk), GFP_KERNEL);
 477                         if (!swap_buf)
 478                                 return -ENOMEM;
 479                 }
 480         }
 481
 482         spi_message_init(&m);
 483         if (header)
 484                 spi_message_add_tail(header, &m);
 485         spi_message_add_tail(&tr, &m);
 486
 487         while (len) {
 488                 chunk = min(len, max_chunk);
 489
 490                 tr.tx_buf = buf;
 491                 tr.len = chunk;
 492
 493                 if (swap_buf) {
 494                         const u16 *buf16 = buf;
 495                         unsigned int i;
 496
 497                         for (i = 0; i < chunk / 2; i++)
 498                                 swap_buf[i] = swab16(buf16[i]);
 499
 500                         tr.tx_buf = swap_buf;
 501                 }
 502
 503                 buf += chunk;
 504                 len -= chunk;
 505
 506                 tinydrm_dbg_spi_message(spi, &m);
 507                 ret = spi_sync(spi, &m);
 508                 if (ret)
 509                         return ret;
 510         }
 511
 512         return 0;
 513 }
 514 EXPORT_SYMBOL(tinydrm_spi_transfer);
 515
 516 #endif /* CONFIG_SPI */