lib/Kconfig: make PRIME_NUMBERS not user selectable.
[sfrench/cifs-2.6.git] / drivers / gpu / drm / tinydrm / mipi-dbi.c
1 /*
2  * MIPI Display Bus Interface (DBI) LCD controller support
3  *
4  * Copyright 2016 Noralf Trønnes
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  */
11
12 #include <drm/tinydrm/mipi-dbi.h>
13 #include <drm/tinydrm/tinydrm-helpers.h>
14 #include <linux/debugfs.h>
15 #include <linux/dma-buf.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/module.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/spi/spi.h>
20 #include <video/mipi_display.h>
21
22 #define MIPI_DBI_MAX_SPI_READ_SPEED 2000000 /* 2MHz */
23
24 #define DCS_POWER_MODE_DISPLAY                  BIT(2)
25 #define DCS_POWER_MODE_DISPLAY_NORMAL_MODE      BIT(3)
26 #define DCS_POWER_MODE_SLEEP_MODE               BIT(4)
27 #define DCS_POWER_MODE_PARTIAL_MODE             BIT(5)
28 #define DCS_POWER_MODE_IDLE_MODE                BIT(6)
29 #define DCS_POWER_MODE_RESERVED_MASK            (BIT(0) | BIT(1) | BIT(7))
30
31 /**
32  * DOC: overview
33  *
34  * This library provides helpers for MIPI Display Bus Interface (DBI)
35  * compatible display controllers.
36  *
37  * Many controllers for tiny lcd displays are MIPI compliant and can use this
38  * library. If a controller uses registers 0x2A and 0x2B to set the area to
39  * update and uses register 0x2C to write to frame memory, it is most likely
40  * MIPI compliant.
41  *
42  * Only MIPI Type 1 displays are supported since a full frame memory is needed.
43  *
44  * There are 3 MIPI DBI implementation types:
45  *
46  * A. Motorola 6800 type parallel bus
47  *
48  * B. Intel 8080 type parallel bus
49  *
50  * C. SPI type with 3 options:
51  *
52  *    1. 9-bit with the Data/Command signal as the ninth bit
53  *    2. Same as above except it's sent as 16 bits
54  *    3. 8-bit with the Data/Command signal as a separate D/CX pin
55  *
56  * Currently mipi_dbi only supports Type C options 1 and 3 with
57  * mipi_dbi_spi_init().
58  */
59
60 #define MIPI_DBI_DEBUG_COMMAND(cmd, data, len) \
61 ({ \
62         if (!len) \
63                 DRM_DEBUG_DRIVER("cmd=%02x\n", cmd); \
64         else if (len <= 32) \
65                 DRM_DEBUG_DRIVER("cmd=%02x, par=%*ph\n", cmd, (int)len, data);\
66         else \
67                 DRM_DEBUG_DRIVER("cmd=%02x, len=%zu\n", cmd, (int)len); \
68 })
69
70 static const u8 mipi_dbi_dcs_read_commands[] = {
71         MIPI_DCS_GET_DISPLAY_ID,
72         MIPI_DCS_GET_RED_CHANNEL,
73         MIPI_DCS_GET_GREEN_CHANNEL,
74         MIPI_DCS_GET_BLUE_CHANNEL,
75         MIPI_DCS_GET_DISPLAY_STATUS,
76         MIPI_DCS_GET_POWER_MODE,
77         MIPI_DCS_GET_ADDRESS_MODE,
78         MIPI_DCS_GET_PIXEL_FORMAT,
79         MIPI_DCS_GET_DISPLAY_MODE,
80         MIPI_DCS_GET_SIGNAL_MODE,
81         MIPI_DCS_GET_DIAGNOSTIC_RESULT,
82         MIPI_DCS_READ_MEMORY_START,
83         MIPI_DCS_READ_MEMORY_CONTINUE,
84         MIPI_DCS_GET_SCANLINE,
85         MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
86         MIPI_DCS_GET_CONTROL_DISPLAY,
87         MIPI_DCS_GET_POWER_SAVE,
88         MIPI_DCS_GET_CABC_MIN_BRIGHTNESS,
89         MIPI_DCS_READ_DDB_START,
90         MIPI_DCS_READ_DDB_CONTINUE,
91         0, /* sentinel */
92 };
93
94 static bool mipi_dbi_command_is_read(struct mipi_dbi *mipi, u8 cmd)
95 {
96         unsigned int i;
97
98         if (!mipi->read_commands)
99                 return false;
100
101         for (i = 0; i < 0xff; i++) {
102                 if (!mipi->read_commands[i])
103                         return false;
104                 if (cmd == mipi->read_commands[i])
105                         return true;
106         }
107
108         return false;
109 }
110
111 /**
112  * mipi_dbi_command_read - MIPI DCS read command
113  * @mipi: MIPI structure
114  * @cmd: Command
115  * @val: Value read
116  *
117  * Send MIPI DCS read command to the controller.
118  *
119  * Returns:
120  * Zero on success, negative error code on failure.
121  */
122 int mipi_dbi_command_read(struct mipi_dbi *mipi, u8 cmd, u8 *val)
123 {
124         if (!mipi->read_commands)
125                 return -EACCES;
126
127         if (!mipi_dbi_command_is_read(mipi, cmd))
128                 return -EINVAL;
129
130         return mipi_dbi_command_buf(mipi, cmd, val, 1);
131 }
132 EXPORT_SYMBOL(mipi_dbi_command_read);
133
134 /**
135  * mipi_dbi_command_buf - MIPI DCS command with parameter(s) in an array
136  * @mipi: MIPI structure
137  * @cmd: Command
138  * @data: Parameter buffer
139  * @len: Buffer length
140  *
141  * Returns:
142  * Zero on success, negative error code on failure.
143  */
144 int mipi_dbi_command_buf(struct mipi_dbi *mipi, u8 cmd, u8 *data, size_t len)
145 {
146         int ret;
147
148         mutex_lock(&mipi->cmdlock);
149         ret = mipi->command(mipi, cmd, data, len);
150         mutex_unlock(&mipi->cmdlock);
151
152         return ret;
153 }
154 EXPORT_SYMBOL(mipi_dbi_command_buf);
155
156 static int mipi_dbi_buf_copy(void *dst, struct drm_framebuffer *fb,
157                                 struct drm_clip_rect *clip, bool swap)
158 {
159         struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
160         struct dma_buf_attachment *import_attach = cma_obj->base.import_attach;
161         struct drm_format_name_buf format_name;
162         void *src = cma_obj->vaddr;
163         int ret = 0;
164
165         if (import_attach) {
166                 ret = dma_buf_begin_cpu_access(import_attach->dmabuf,
167                                                DMA_FROM_DEVICE);
168                 if (ret)
169                         return ret;
170         }
171
172         switch (fb->format->format) {
173         case DRM_FORMAT_RGB565:
174                 if (swap)
175                         tinydrm_swab16(dst, src, fb, clip);
176                 else
177                         tinydrm_memcpy(dst, src, fb, clip);
178                 break;
179         case DRM_FORMAT_XRGB8888:
180                 tinydrm_xrgb8888_to_rgb565(dst, src, fb, clip, swap);
181                 break;
182         default:
183                 dev_err_once(fb->dev->dev, "Format is not supported: %s\n",
184                              drm_get_format_name(fb->format->format,
185                                                  &format_name));
186                 return -EINVAL;
187         }
188
189         if (import_attach)
190                 ret = dma_buf_end_cpu_access(import_attach->dmabuf,
191                                              DMA_FROM_DEVICE);
192         return ret;
193 }
194
195 static int mipi_dbi_fb_dirty(struct drm_framebuffer *fb,
196                              struct drm_file *file_priv,
197                              unsigned int flags, unsigned int color,
198                              struct drm_clip_rect *clips,
199                              unsigned int num_clips)
200 {
201         struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
202         struct tinydrm_device *tdev = fb->dev->dev_private;
203         struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
204         bool swap = mipi->swap_bytes;
205         struct drm_clip_rect clip;
206         int ret = 0;
207         bool full;
208         void *tr;
209
210         mutex_lock(&tdev->dirty_lock);
211
212         if (!mipi->enabled)
213                 goto out_unlock;
214
215         /* fbdev can flush even when we're not interested */
216         if (tdev->pipe.plane.fb != fb)
217                 goto out_unlock;
218
219         full = tinydrm_merge_clips(&clip, clips, num_clips, flags,
220                                    fb->width, fb->height);
221
222         DRM_DEBUG("Flushing [FB:%d] x1=%u, x2=%u, y1=%u, y2=%u\n", fb->base.id,
223                   clip.x1, clip.x2, clip.y1, clip.y2);
224
225         if (!mipi->dc || !full || swap ||
226             fb->format->format == DRM_FORMAT_XRGB8888) {
227                 tr = mipi->tx_buf;
228                 ret = mipi_dbi_buf_copy(mipi->tx_buf, fb, &clip, swap);
229                 if (ret)
230                         goto out_unlock;
231         } else {
232                 tr = cma_obj->vaddr;
233         }
234
235         mipi_dbi_command(mipi, MIPI_DCS_SET_COLUMN_ADDRESS,
236                          (clip.x1 >> 8) & 0xFF, clip.x1 & 0xFF,
237                          (clip.x2 >> 8) & 0xFF, (clip.x2 - 1) & 0xFF);
238         mipi_dbi_command(mipi, MIPI_DCS_SET_PAGE_ADDRESS,
239                          (clip.y1 >> 8) & 0xFF, clip.y1 & 0xFF,
240                          (clip.y2 >> 8) & 0xFF, (clip.y2 - 1) & 0xFF);
241
242         ret = mipi_dbi_command_buf(mipi, MIPI_DCS_WRITE_MEMORY_START, tr,
243                                 (clip.x2 - clip.x1) * (clip.y2 - clip.y1) * 2);
244
245 out_unlock:
246         mutex_unlock(&tdev->dirty_lock);
247
248         if (ret)
249                 dev_err_once(fb->dev->dev, "Failed to update display %d\n",
250                              ret);
251
252         return ret;
253 }
254
255 static const struct drm_framebuffer_funcs mipi_dbi_fb_funcs = {
256         .destroy        = drm_fb_cma_destroy,
257         .create_handle  = drm_fb_cma_create_handle,
258         .dirty          = mipi_dbi_fb_dirty,
259 };
260
261 /**
262  * mipi_dbi_pipe_enable - MIPI DBI pipe enable helper
263  * @pipe: Display pipe
264  * @crtc_state: CRTC state
265  *
266  * This function enables backlight. Drivers can use this as their
267  * &drm_simple_display_pipe_funcs->enable callback.
268  */
269 void mipi_dbi_pipe_enable(struct drm_simple_display_pipe *pipe,
270                           struct drm_crtc_state *crtc_state)
271 {
272         struct tinydrm_device *tdev = pipe_to_tinydrm(pipe);
273         struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
274         struct drm_framebuffer *fb = pipe->plane.fb;
275
276         DRM_DEBUG_KMS("\n");
277
278         mipi->enabled = true;
279         if (fb)
280                 fb->funcs->dirty(fb, NULL, 0, 0, NULL, 0);
281
282         tinydrm_enable_backlight(mipi->backlight);
283 }
284 EXPORT_SYMBOL(mipi_dbi_pipe_enable);
285
286 static void mipi_dbi_blank(struct mipi_dbi *mipi)
287 {
288         struct drm_device *drm = mipi->tinydrm.drm;
289         u16 height = drm->mode_config.min_height;
290         u16 width = drm->mode_config.min_width;
291         size_t len = width * height * 2;
292
293         memset(mipi->tx_buf, 0, len);
294
295         mipi_dbi_command(mipi, MIPI_DCS_SET_COLUMN_ADDRESS, 0, 0,
296                          (width >> 8) & 0xFF, (width - 1) & 0xFF);
297         mipi_dbi_command(mipi, MIPI_DCS_SET_PAGE_ADDRESS, 0, 0,
298                          (height >> 8) & 0xFF, (height - 1) & 0xFF);
299         mipi_dbi_command_buf(mipi, MIPI_DCS_WRITE_MEMORY_START,
300                              (u8 *)mipi->tx_buf, len);
301 }
302
303 /**
304  * mipi_dbi_pipe_disable - MIPI DBI pipe disable helper
305  * @pipe: Display pipe
306  *
307  * This function disables backlight if present or if not the
308  * display memory is blanked. Drivers can use this as their
309  * &drm_simple_display_pipe_funcs->disable callback.
310  */
311 void mipi_dbi_pipe_disable(struct drm_simple_display_pipe *pipe)
312 {
313         struct tinydrm_device *tdev = pipe_to_tinydrm(pipe);
314         struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
315
316         DRM_DEBUG_KMS("\n");
317
318         mipi->enabled = false;
319
320         if (mipi->backlight)
321                 tinydrm_disable_backlight(mipi->backlight);
322         else
323                 mipi_dbi_blank(mipi);
324 }
325 EXPORT_SYMBOL(mipi_dbi_pipe_disable);
326
327 static const uint32_t mipi_dbi_formats[] = {
328         DRM_FORMAT_RGB565,
329         DRM_FORMAT_XRGB8888,
330 };
331
332 /**
333  * mipi_dbi_init - MIPI DBI initialization
334  * @dev: Parent device
335  * @mipi: &mipi_dbi structure to initialize
336  * @pipe_funcs: Display pipe functions
337  * @driver: DRM driver
338  * @mode: Display mode
339  * @rotation: Initial rotation in degrees Counter Clock Wise
340  *
341  * This function initializes a &mipi_dbi structure and it's underlying
342  * @tinydrm_device. It also sets up the display pipeline.
343  *
344  * Supported formats: Native RGB565 and emulated XRGB8888.
345  *
346  * Objects created by this function will be automatically freed on driver
347  * detach (devres).
348  *
349  * Returns:
350  * Zero on success, negative error code on failure.
351  */
352 int mipi_dbi_init(struct device *dev, struct mipi_dbi *mipi,
353                   const struct drm_simple_display_pipe_funcs *pipe_funcs,
354                   struct drm_driver *driver,
355                   const struct drm_display_mode *mode, unsigned int rotation)
356 {
357         size_t bufsize = mode->vdisplay * mode->hdisplay * sizeof(u16);
358         struct tinydrm_device *tdev = &mipi->tinydrm;
359         int ret;
360
361         if (!mipi->command)
362                 return -EINVAL;
363
364         mutex_init(&mipi->cmdlock);
365
366         mipi->tx_buf = devm_kmalloc(dev, bufsize, GFP_KERNEL);
367         if (!mipi->tx_buf)
368                 return -ENOMEM;
369
370         ret = devm_tinydrm_init(dev, tdev, &mipi_dbi_fb_funcs, driver);
371         if (ret)
372                 return ret;
373
374         /* TODO: Maybe add DRM_MODE_CONNECTOR_SPI */
375         ret = tinydrm_display_pipe_init(tdev, pipe_funcs,
376                                         DRM_MODE_CONNECTOR_VIRTUAL,
377                                         mipi_dbi_formats,
378                                         ARRAY_SIZE(mipi_dbi_formats), mode,
379                                         rotation);
380         if (ret)
381                 return ret;
382
383         tdev->drm->mode_config.preferred_depth = 16;
384         mipi->rotation = rotation;
385
386         drm_mode_config_reset(tdev->drm);
387
388         DRM_DEBUG_KMS("preferred_depth=%u, rotation = %u\n",
389                       tdev->drm->mode_config.preferred_depth, rotation);
390
391         return 0;
392 }
393 EXPORT_SYMBOL(mipi_dbi_init);
394
395 /**
396  * mipi_dbi_hw_reset - Hardware reset of controller
397  * @mipi: MIPI DBI structure
398  *
399  * Reset controller if the &mipi_dbi->reset gpio is set.
400  */
401 void mipi_dbi_hw_reset(struct mipi_dbi *mipi)
402 {
403         if (!mipi->reset)
404                 return;
405
406         gpiod_set_value_cansleep(mipi->reset, 0);
407         msleep(20);
408         gpiod_set_value_cansleep(mipi->reset, 1);
409         msleep(120);
410 }
411 EXPORT_SYMBOL(mipi_dbi_hw_reset);
412
413 /**
414  * mipi_dbi_display_is_on - Check if display is on
415  * @mipi: MIPI DBI structure
416  *
417  * This function checks the Power Mode register (if readable) to see if
418  * display output is turned on. This can be used to see if the bootloader
419  * has already turned on the display avoiding flicker when the pipeline is
420  * enabled.
421  *
422  * Returns:
423  * true if the display can be verified to be on, false otherwise.
424  */
425 bool mipi_dbi_display_is_on(struct mipi_dbi *mipi)
426 {
427         u8 val;
428
429         if (mipi_dbi_command_read(mipi, MIPI_DCS_GET_POWER_MODE, &val))
430                 return false;
431
432         val &= ~DCS_POWER_MODE_RESERVED_MASK;
433
434         if (val != (DCS_POWER_MODE_DISPLAY |
435             DCS_POWER_MODE_DISPLAY_NORMAL_MODE | DCS_POWER_MODE_SLEEP_MODE))
436                 return false;
437
438         DRM_DEBUG_DRIVER("Display is ON\n");
439
440         return true;
441 }
442 EXPORT_SYMBOL(mipi_dbi_display_is_on);
443
444 #if IS_ENABLED(CONFIG_SPI)
445
446 /*
447  * Many controllers have a max speed of 10MHz, but can be pushed way beyond
448  * that. Increase reliability by running pixel data at max speed and the rest
449  * at 10MHz, preventing transfer glitches from messing up the init settings.
450  */
451 static u32 mipi_dbi_spi_cmd_max_speed(struct spi_device *spi, size_t len)
452 {
453         if (len > 64)
454                 return 0; /* use default */
455
456         return min_t(u32, 10000000, spi->max_speed_hz);
457 }
458
459 /*
460  * MIPI DBI Type C Option 1
461  *
462  * If the SPI controller doesn't have 9 bits per word support,
463  * use blocks of 9 bytes to send 8x 9-bit words using a 8-bit SPI transfer.
464  * Pad partial blocks with MIPI_DCS_NOP (zero).
465  * This is how the D/C bit (x) is added:
466  *     x7654321
467  *     0x765432
468  *     10x76543
469  *     210x7654
470  *     3210x765
471  *     43210x76
472  *     543210x7
473  *     6543210x
474  *     76543210
475  */
476
477 static int mipi_dbi_spi1e_transfer(struct mipi_dbi *mipi, int dc,
478                                    const void *buf, size_t len,
479                                    unsigned int bpw)
480 {
481         bool swap_bytes = (bpw == 16 && tinydrm_machine_little_endian());
482         size_t chunk, max_chunk = mipi->tx_buf9_len;
483         struct spi_device *spi = mipi->spi;
484         struct spi_transfer tr = {
485                 .tx_buf = mipi->tx_buf9,
486                 .bits_per_word = 8,
487         };
488         struct spi_message m;
489         const u8 *src = buf;
490         int i, ret;
491         u8 *dst;
492
493         if (drm_debug & DRM_UT_DRIVER)
494                 pr_debug("[drm:%s] dc=%d, max_chunk=%zu, transfers:\n",
495                          __func__, dc, max_chunk);
496
497         tr.speed_hz = mipi_dbi_spi_cmd_max_speed(spi, len);
498         spi_message_init_with_transfers(&m, &tr, 1);
499
500         if (!dc) {
501                 if (WARN_ON_ONCE(len != 1))
502                         return -EINVAL;
503
504                 /* Command: pad no-op's (zeroes) at beginning of block */
505                 dst = mipi->tx_buf9;
506                 memset(dst, 0, 9);
507                 dst[8] = *src;
508                 tr.len = 9;
509
510                 tinydrm_dbg_spi_message(spi, &m);
511
512                 return spi_sync(spi, &m);
513         }
514
515         /* max with room for adding one bit per byte */
516         max_chunk = max_chunk / 9 * 8;
517         /* but no bigger than len */
518         max_chunk = min(max_chunk, len);
519         /* 8 byte blocks */
520         max_chunk = max_t(size_t, 8, max_chunk & ~0x7);
521
522         while (len) {
523                 size_t added = 0;
524
525                 chunk = min(len, max_chunk);
526                 len -= chunk;
527                 dst = mipi->tx_buf9;
528
529                 if (chunk < 8) {
530                         u8 val, carry = 0;
531
532                         /* Data: pad no-op's (zeroes) at end of block */
533                         memset(dst, 0, 9);
534
535                         if (swap_bytes) {
536                                 for (i = 1; i < (chunk + 1); i++) {
537                                         val = src[1];
538                                         *dst++ = carry | BIT(8 - i) | (val >> i);
539                                         carry = val << (8 - i);
540                                         i++;
541                                         val = src[0];
542                                         *dst++ = carry | BIT(8 - i) | (val >> i);
543                                         carry = val << (8 - i);
544                                         src += 2;
545                                 }
546                                 *dst++ = carry;
547                         } else {
548                                 for (i = 1; i < (chunk + 1); i++) {
549                                         val = *src++;
550                                         *dst++ = carry | BIT(8 - i) | (val >> i);
551                                         carry = val << (8 - i);
552                                 }
553                                 *dst++ = carry;
554                         }
555
556                         chunk = 8;
557                         added = 1;
558                 } else {
559                         for (i = 0; i < chunk; i += 8) {
560                                 if (swap_bytes) {
561                                         *dst++ =                 BIT(7) | (src[1] >> 1);
562                                         *dst++ = (src[1] << 7) | BIT(6) | (src[0] >> 2);
563                                         *dst++ = (src[0] << 6) | BIT(5) | (src[3] >> 3);
564                                         *dst++ = (src[3] << 5) | BIT(4) | (src[2] >> 4);
565                                         *dst++ = (src[2] << 4) | BIT(3) | (src[5] >> 5);
566                                         *dst++ = (src[5] << 3) | BIT(2) | (src[4] >> 6);
567                                         *dst++ = (src[4] << 2) | BIT(1) | (src[7] >> 7);
568                                         *dst++ = (src[7] << 1) | BIT(0);
569                                         *dst++ = src[6];
570                                 } else {
571                                         *dst++ =                 BIT(7) | (src[0] >> 1);
572                                         *dst++ = (src[0] << 7) | BIT(6) | (src[1] >> 2);
573                                         *dst++ = (src[1] << 6) | BIT(5) | (src[2] >> 3);
574                                         *dst++ = (src[2] << 5) | BIT(4) | (src[3] >> 4);
575                                         *dst++ = (src[3] << 4) | BIT(3) | (src[4] >> 5);
576                                         *dst++ = (src[4] << 3) | BIT(2) | (src[5] >> 6);
577                                         *dst++ = (src[5] << 2) | BIT(1) | (src[6] >> 7);
578                                         *dst++ = (src[6] << 1) | BIT(0);
579                                         *dst++ = src[7];
580                                 }
581
582                                 src += 8;
583                                 added++;
584                         }
585                 }
586
587                 tr.len = chunk + added;
588
589                 tinydrm_dbg_spi_message(spi, &m);
590                 ret = spi_sync(spi, &m);
591                 if (ret)
592                         return ret;
593         };
594
595         return 0;
596 }
597
598 static int mipi_dbi_spi1_transfer(struct mipi_dbi *mipi, int dc,
599                                   const void *buf, size_t len,
600                                   unsigned int bpw)
601 {
602         struct spi_device *spi = mipi->spi;
603         struct spi_transfer tr = {
604                 .bits_per_word = 9,
605         };
606         const u16 *src16 = buf;
607         const u8 *src8 = buf;
608         struct spi_message m;
609         size_t max_chunk;
610         u16 *dst16;
611         int ret;
612
613         if (!tinydrm_spi_bpw_supported(spi, 9))
614                 return mipi_dbi_spi1e_transfer(mipi, dc, buf, len, bpw);
615
616         tr.speed_hz = mipi_dbi_spi_cmd_max_speed(spi, len);
617         max_chunk = mipi->tx_buf9_len;
618         dst16 = mipi->tx_buf9;
619
620         if (drm_debug & DRM_UT_DRIVER)
621                 pr_debug("[drm:%s] dc=%d, max_chunk=%zu, transfers:\n",
622                          __func__, dc, max_chunk);
623
624         max_chunk = min(max_chunk / 2, len);
625
626         spi_message_init_with_transfers(&m, &tr, 1);
627         tr.tx_buf = dst16;
628
629         while (len) {
630                 size_t chunk = min(len, max_chunk);
631                 unsigned int i;
632
633                 if (bpw == 16 && tinydrm_machine_little_endian()) {
634                         for (i = 0; i < (chunk * 2); i += 2) {
635                                 dst16[i]     = *src16 >> 8;
636                                 dst16[i + 1] = *src16++ & 0xFF;
637                                 if (dc) {
638                                         dst16[i]     |= 0x0100;
639                                         dst16[i + 1] |= 0x0100;
640                                 }
641                         }
642                 } else {
643                         for (i = 0; i < chunk; i++) {
644                                 dst16[i] = *src8++;
645                                 if (dc)
646                                         dst16[i] |= 0x0100;
647                         }
648                 }
649
650                 tr.len = chunk;
651                 len -= chunk;
652
653                 tinydrm_dbg_spi_message(spi, &m);
654                 ret = spi_sync(spi, &m);
655                 if (ret)
656                         return ret;
657         };
658
659         return 0;
660 }
661
662 static int mipi_dbi_typec1_command(struct mipi_dbi *mipi, u8 cmd,
663                                    u8 *parameters, size_t num)
664 {
665         unsigned int bpw = (cmd == MIPI_DCS_WRITE_MEMORY_START) ? 16 : 8;
666         int ret;
667
668         if (mipi_dbi_command_is_read(mipi, cmd))
669                 return -ENOTSUPP;
670
671         MIPI_DBI_DEBUG_COMMAND(cmd, parameters, num);
672
673         ret = mipi_dbi_spi1_transfer(mipi, 0, &cmd, 1, 8);
674         if (ret || !num)
675                 return ret;
676
677         return mipi_dbi_spi1_transfer(mipi, 1, parameters, num, bpw);
678 }
679
680 /* MIPI DBI Type C Option 3 */
681
682 static int mipi_dbi_typec3_command_read(struct mipi_dbi *mipi, u8 cmd,
683                                         u8 *data, size_t len)
684 {
685         struct spi_device *spi = mipi->spi;
686         u32 speed_hz = min_t(u32, MIPI_DBI_MAX_SPI_READ_SPEED,
687                              spi->max_speed_hz / 2);
688         struct spi_transfer tr[2] = {
689                 {
690                         .speed_hz = speed_hz,
691                         .tx_buf = &cmd,
692                         .len = 1,
693                 }, {
694                         .speed_hz = speed_hz,
695                         .len = len,
696                 },
697         };
698         struct spi_message m;
699         u8 *buf;
700         int ret;
701
702         if (!len)
703                 return -EINVAL;
704
705         /*
706          * Support non-standard 24-bit and 32-bit Nokia read commands which
707          * start with a dummy clock, so we need to read an extra byte.
708          */
709         if (cmd == MIPI_DCS_GET_DISPLAY_ID ||
710             cmd == MIPI_DCS_GET_DISPLAY_STATUS) {
711                 if (!(len == 3 || len == 4))
712                         return -EINVAL;
713
714                 tr[1].len = len + 1;
715         }
716
717         buf = kmalloc(tr[1].len, GFP_KERNEL);
718         if (!buf)
719                 return -ENOMEM;
720
721         tr[1].rx_buf = buf;
722         gpiod_set_value_cansleep(mipi->dc, 0);
723
724         spi_message_init_with_transfers(&m, tr, ARRAY_SIZE(tr));
725         ret = spi_sync(spi, &m);
726         if (ret)
727                 goto err_free;
728
729         tinydrm_dbg_spi_message(spi, &m);
730
731         if (tr[1].len == len) {
732                 memcpy(data, buf, len);
733         } else {
734                 unsigned int i;
735
736                 for (i = 0; i < len; i++)
737                         data[i] = (buf[i] << 1) | !!(buf[i + 1] & BIT(7));
738         }
739
740         MIPI_DBI_DEBUG_COMMAND(cmd, data, len);
741
742 err_free:
743         kfree(buf);
744
745         return ret;
746 }
747
748 static int mipi_dbi_typec3_command(struct mipi_dbi *mipi, u8 cmd,
749                                    u8 *par, size_t num)
750 {
751         struct spi_device *spi = mipi->spi;
752         unsigned int bpw = 8;
753         u32 speed_hz;
754         int ret;
755
756         if (mipi_dbi_command_is_read(mipi, cmd))
757                 return mipi_dbi_typec3_command_read(mipi, cmd, par, num);
758
759         MIPI_DBI_DEBUG_COMMAND(cmd, par, num);
760
761         gpiod_set_value_cansleep(mipi->dc, 0);
762         speed_hz = mipi_dbi_spi_cmd_max_speed(spi, 1);
763         ret = tinydrm_spi_transfer(spi, speed_hz, NULL, 8, &cmd, 1);
764         if (ret || !num)
765                 return ret;
766
767         if (cmd == MIPI_DCS_WRITE_MEMORY_START && !mipi->swap_bytes)
768                 bpw = 16;
769
770         gpiod_set_value_cansleep(mipi->dc, 1);
771         speed_hz = mipi_dbi_spi_cmd_max_speed(spi, num);
772
773         return tinydrm_spi_transfer(spi, speed_hz, NULL, bpw, par, num);
774 }
775
776 /**
777  * mipi_dbi_spi_init - Initialize MIPI DBI SPI interfaced controller
778  * @spi: SPI device
779  * @dc: D/C gpio (optional)
780  * @mipi: &mipi_dbi structure to initialize
781  * @pipe_funcs: Display pipe functions
782  * @driver: DRM driver
783  * @mode: Display mode
784  * @rotation: Initial rotation in degrees Counter Clock Wise
785  *
786  * This function sets &mipi_dbi->command, enables &mipi->read_commands for the
787  * usual read commands and initializes @mipi using mipi_dbi_init().
788  *
789  * If @dc is set, a Type C Option 3 interface is assumed, if not
790  * Type C Option 1.
791  *
792  * If the SPI master driver doesn't support the necessary bits per word,
793  * the following transformation is used:
794  *
795  * - 9-bit: reorder buffer as 9x 8-bit words, padded with no-op command.
796  * - 16-bit: if big endian send as 8-bit, if little endian swap bytes
797  *
798  * Returns:
799  * Zero on success, negative error code on failure.
800  */
801 int mipi_dbi_spi_init(struct spi_device *spi, struct mipi_dbi *mipi,
802                       struct gpio_desc *dc,
803                       const struct drm_simple_display_pipe_funcs *pipe_funcs,
804                       struct drm_driver *driver,
805                       const struct drm_display_mode *mode,
806                       unsigned int rotation)
807 {
808         size_t tx_size = tinydrm_spi_max_transfer_size(spi, 0);
809         struct device *dev = &spi->dev;
810         int ret;
811
812         if (tx_size < 16) {
813                 DRM_ERROR("SPI transmit buffer too small: %zu\n", tx_size);
814                 return -EINVAL;
815         }
816
817         /*
818          * Even though it's not the SPI device that does DMA (the master does),
819          * the dma mask is necessary for the dma_alloc_wc() in
820          * drm_gem_cma_create(). The dma_addr returned will be a physical
821          * adddress which might be different from the bus address, but this is
822          * not a problem since the address will not be used.
823          * The virtual address is used in the transfer and the SPI core
824          * re-maps it on the SPI master device using the DMA streaming API
825          * (spi_map_buf()).
826          */
827         if (!dev->coherent_dma_mask) {
828                 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
829                 if (ret) {
830                         dev_warn(dev, "Failed to set dma mask %d\n", ret);
831                         return ret;
832                 }
833         }
834
835         mipi->spi = spi;
836         mipi->read_commands = mipi_dbi_dcs_read_commands;
837
838         if (dc) {
839                 mipi->command = mipi_dbi_typec3_command;
840                 mipi->dc = dc;
841                 if (tinydrm_machine_little_endian() &&
842                     !tinydrm_spi_bpw_supported(spi, 16))
843                         mipi->swap_bytes = true;
844         } else {
845                 mipi->command = mipi_dbi_typec1_command;
846                 mipi->tx_buf9_len = tx_size;
847                 mipi->tx_buf9 = devm_kmalloc(dev, tx_size, GFP_KERNEL);
848                 if (!mipi->tx_buf9)
849                         return -ENOMEM;
850         }
851
852         return mipi_dbi_init(dev, mipi, pipe_funcs, driver, mode, rotation);
853 }
854 EXPORT_SYMBOL(mipi_dbi_spi_init);
855
856 #endif /* CONFIG_SPI */
857
858 #ifdef CONFIG_DEBUG_FS
859
860 static ssize_t mipi_dbi_debugfs_command_write(struct file *file,
861                                               const char __user *ubuf,
862                                               size_t count, loff_t *ppos)
863 {
864         struct seq_file *m = file->private_data;
865         struct mipi_dbi *mipi = m->private;
866         u8 val, cmd = 0, parameters[64];
867         char *buf, *pos, *token;
868         unsigned int i;
869         int ret;
870
871         buf = memdup_user_nul(ubuf, count);
872         if (IS_ERR(buf))
873                 return PTR_ERR(buf);
874
875         /* strip trailing whitespace */
876         for (i = count - 1; i > 0; i--)
877                 if (isspace(buf[i]))
878                         buf[i] = '\0';
879                 else
880                         break;
881         i = 0;
882         pos = buf;
883         while (pos) {
884                 token = strsep(&pos, " ");
885                 if (!token) {
886                         ret = -EINVAL;
887                         goto err_free;
888                 }
889
890                 ret = kstrtou8(token, 16, &val);
891                 if (ret < 0)
892                         goto err_free;
893
894                 if (token == buf)
895                         cmd = val;
896                 else
897                         parameters[i++] = val;
898
899                 if (i == 64) {
900                         ret = -E2BIG;
901                         goto err_free;
902                 }
903         }
904
905         ret = mipi_dbi_command_buf(mipi, cmd, parameters, i);
906
907 err_free:
908         kfree(buf);
909
910         return ret < 0 ? ret : count;
911 }
912
913 static int mipi_dbi_debugfs_command_show(struct seq_file *m, void *unused)
914 {
915         struct mipi_dbi *mipi = m->private;
916         u8 cmd, val[4];
917         size_t len, i;
918         int ret;
919
920         for (cmd = 0; cmd < 255; cmd++) {
921                 if (!mipi_dbi_command_is_read(mipi, cmd))
922                         continue;
923
924                 switch (cmd) {
925                 case MIPI_DCS_READ_MEMORY_START:
926                 case MIPI_DCS_READ_MEMORY_CONTINUE:
927                         len = 2;
928                         break;
929                 case MIPI_DCS_GET_DISPLAY_ID:
930                         len = 3;
931                         break;
932                 case MIPI_DCS_GET_DISPLAY_STATUS:
933                         len = 4;
934                         break;
935                 default:
936                         len = 1;
937                         break;
938                 }
939
940                 seq_printf(m, "%02x: ", cmd);
941                 ret = mipi_dbi_command_buf(mipi, cmd, val, len);
942                 if (ret) {
943                         seq_puts(m, "XX\n");
944                         continue;
945                 }
946
947                 for (i = 0; i < len; i++)
948                         seq_printf(m, "%02x", val[i]);
949                 seq_puts(m, "\n");
950         }
951
952         return 0;
953 }
954
955 static int mipi_dbi_debugfs_command_open(struct inode *inode,
956                                          struct file *file)
957 {
958         return single_open(file, mipi_dbi_debugfs_command_show,
959                            inode->i_private);
960 }
961
962 static const struct file_operations mipi_dbi_debugfs_command_fops = {
963         .owner = THIS_MODULE,
964         .open = mipi_dbi_debugfs_command_open,
965         .read = seq_read,
966         .llseek = seq_lseek,
967         .release = single_release,
968         .write = mipi_dbi_debugfs_command_write,
969 };
970
971 static const struct drm_info_list mipi_dbi_debugfs_list[] = {
972         { "fb",   drm_fb_cma_debugfs_show, 0 },
973 };
974
975 /**
976  * mipi_dbi_debugfs_init - Create debugfs entries
977  * @minor: DRM minor
978  *
979  * This function creates a 'command' debugfs file for sending commands to the
980  * controller or getting the read command values.
981  * Drivers can use this as their &drm_driver->debugfs_init callback.
982  *
983  * Returns:
984  * Zero on success, negative error code on failure.
985  */
986 int mipi_dbi_debugfs_init(struct drm_minor *minor)
987 {
988         struct tinydrm_device *tdev = minor->dev->dev_private;
989         struct mipi_dbi *mipi = mipi_dbi_from_tinydrm(tdev);
990         umode_t mode = S_IFREG | S_IWUSR;
991
992         if (mipi->read_commands)
993                 mode |= S_IRUGO;
994         debugfs_create_file("command", mode, minor->debugfs_root, mipi,
995                             &mipi_dbi_debugfs_command_fops);
996
997         return drm_debugfs_create_files(mipi_dbi_debugfs_list,
998                                         ARRAY_SIZE(mipi_dbi_debugfs_list),
999                                         minor->debugfs_root, minor);
1000 }
1001 EXPORT_SYMBOL(mipi_dbi_debugfs_init);
1002
1003 #endif
1004
1005 MODULE_LICENSE("GPL");