drivers/staging/fbtft/fbtft-bus.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/export.h>
   3 #include <linux/errno.h>
   4 #include <linux/gpio/consumer.h>
   5 #include <linux/spi/spi.h>
   6 #include "fbtft.h"
   7
   8 /*****************************************************************************
   9  *
  10  *   void (*write_reg)(struct fbtft_par *par, int len, ...);
  11  *
  12  *****************************************************************************/
  13
  14 #define define_fbtft_write_reg(func, buffer_type, data_type, modifier)        \
  15 void func(struct fbtft_par *par, int len, ...)                                \
  16 {                                                                             \
  17         va_list args;                                                         \
  18         int i, ret;                                                           \
  19         int offset = 0;                                                       \
  20         buffer_type *buf = (buffer_type *)par->buf;                           \
  21                                                                               \
  22         if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) {                    \
  23                 va_start(args, len);                                          \
  24                 for (i = 0; i < len; i++) {                                   \
  25                         buf[i] = modifier((data_type)va_arg(args,             \
  26                                                             unsigned int));   \
  27                 }                                                             \
  28                 va_end(args);                                                 \
  29                 fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par,                  \
  30                                   par->info->device, buffer_type, buf, len,   \
  31                                   "%s: ", __func__);                          \
  32         }                                                                     \
  33                                                                               \
  34         va_start(args, len);                                                  \
  35                                                                               \
  36         if (par->startbyte) {                                                 \
  37                 *(u8 *)par->buf = par->startbyte;                             \
  38                 buf = (buffer_type *)(par->buf + 1);                          \
  39                 offset = 1;                                                   \
  40         }                                                                     \
  41                                                                               \
  42         *buf = modifier((data_type)va_arg(args, unsigned int));               \
  43         ret = fbtft_write_buf_dc(par, par->buf, sizeof(data_type) + offset,   \
  44                                  0);                                          \
  45         if (ret < 0)                                                          \
  46                 goto out;                                                     \
  47         len--;                                                                \
  48                                                                               \
  49         if (par->startbyte)                                                   \
  50                 *(u8 *)par->buf = par->startbyte | 0x2;                       \
  51                                                                               \
  52         if (len) {                                                            \
  53                 i = len;                                                      \
  54                 while (i--)                                                   \
  55                         *buf++ = modifier((data_type)va_arg(args,             \
  56                                                             unsigned int));   \
  57                 fbtft_write_buf_dc(par, par->buf,                             \
  58                                    len * (sizeof(data_type) + offset), 1);    \
  59         }                                                                     \
  60 out:                                                                          \
  61         va_end(args);                                                         \
  62 }                                                                             \
  63 EXPORT_SYMBOL(func);
  64
  65 define_fbtft_write_reg(fbtft_write_reg8_bus8, u8, u8, )
  66 define_fbtft_write_reg(fbtft_write_reg16_bus8, __be16, u16, cpu_to_be16)
  67 define_fbtft_write_reg(fbtft_write_reg16_bus16, u16, u16, )
  68
  69 void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...)
  70 {
  71         va_list args;
  72         int i, ret;
  73         int pad = 0;
  74         u16 *buf = (u16 *)par->buf;
  75
  76         if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) {
  77                 va_start(args, len);
  78                 for (i = 0; i < len; i++)
  79                         *(((u8 *)buf) + i) = (u8)va_arg(args, unsigned int);
  80                 va_end(args);
  81                 fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par,
  82                                   par->info->device, u8, buf, len, "%s: ",
  83                                   __func__);
  84         }
  85         if (len <= 0)
  86                 return;
  87
  88         if (par->spi && (par->spi->bits_per_word == 8)) {
  89                 /* we're emulating 9-bit, pad start of buffer with no-ops
  90                  * (assuming here that zero is a no-op)
  91                  */
  92                 pad = (len % 4) ? 4 - (len % 4) : 0;
  93                 for (i = 0; i < pad; i++)
  94                         *buf++ = 0x000;
  95         }
  96
  97         va_start(args, len);
  98         *buf++ = (u8)va_arg(args, unsigned int);
  99         i = len - 1;
 100         while (i--) {
 101                 *buf = (u8)va_arg(args, unsigned int);
 102                 *buf++ |= 0x100; /* dc=1 */
 103         }
 104         va_end(args);
 105         ret = par->fbtftops.write(par, par->buf, (len + pad) * sizeof(u16));
 106         if (ret < 0) {
 107                 dev_err(par->info->device,
 108                         "write() failed and returned %d\n", ret);
 109                 return;
 110         }
 111 }
 112 EXPORT_SYMBOL(fbtft_write_reg8_bus9);
 113
 114 /*****************************************************************************
 115  *
 116  *   int (*write_vmem)(struct fbtft_par *par);
 117  *
 118  *****************************************************************************/
 119
 120 /* 16 bit pixel over 8-bit databus */
 121 int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len)
 122 {
 123         u16 *vmem16;
 124         __be16 *txbuf16 = par->txbuf.buf;
 125         size_t remain;
 126         size_t to_copy;
 127         size_t tx_array_size;
 128         int i;
 129         int ret = 0;
 130         size_t startbyte_size = 0;
 131
 132         fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
 133                       __func__, offset, len);
 134
 135         remain = len / 2;
 136         vmem16 = (u16 *)(par->info->screen_buffer + offset);
 137
 138         gpiod_set_value(par->gpio.dc, 1);
 139
 140         /* non buffered write */
 141         if (!par->txbuf.buf)
 142                 return par->fbtftops.write(par, vmem16, len);
 143
 144         /* buffered write */
 145         tx_array_size = par->txbuf.len / 2;
 146
 147         if (par->startbyte) {
 148                 txbuf16 = par->txbuf.buf + 1;
 149                 tx_array_size -= 2;
 150                 *(u8 *)(par->txbuf.buf) = par->startbyte | 0x2;
 151                 startbyte_size = 1;
 152         }
 153
 154         while (remain) {
 155                 to_copy = min(tx_array_size, remain);
 156                 dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
 157                         to_copy, remain - to_copy);
 158
 159                 for (i = 0; i < to_copy; i++)
 160                         txbuf16[i] = cpu_to_be16(vmem16[i]);
 161
 162                 vmem16 = vmem16 + to_copy;
 163                 ret = par->fbtftops.write(par, par->txbuf.buf,
 164                                                 startbyte_size + to_copy * 2);
 165                 if (ret < 0)
 166                         return ret;
 167                 remain -= to_copy;
 168         }
 169
 170         return ret;
 171 }
 172 EXPORT_SYMBOL(fbtft_write_vmem16_bus8);
 173
 174 /* 16 bit pixel over 9-bit SPI bus: dc + high byte, dc + low byte */
 175 int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len)
 176 {
 177         u8 *vmem8;
 178         u16 *txbuf16 = par->txbuf.buf;
 179         size_t remain;
 180         size_t to_copy;
 181         size_t tx_array_size;
 182         int i;
 183         int ret = 0;
 184
 185         fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
 186                       __func__, offset, len);
 187
 188         if (!par->txbuf.buf) {
 189                 dev_err(par->info->device, "%s: txbuf.buf is NULL\n", __func__);
 190                 return -1;
 191         }
 192
 193         remain = len;
 194         vmem8 = par->info->screen_buffer + offset;
 195
 196         tx_array_size = par->txbuf.len / 2;
 197
 198         while (remain) {
 199                 to_copy = min(tx_array_size, remain);
 200                 dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
 201                         to_copy, remain - to_copy);
 202
 203 #ifdef __LITTLE_ENDIAN
 204                 for (i = 0; i < to_copy; i += 2) {
 205                         txbuf16[i]     = 0x0100 | vmem8[i + 1];
 206                         txbuf16[i + 1] = 0x0100 | vmem8[i];
 207                 }
 208 #else
 209                 for (i = 0; i < to_copy; i++)
 210                         txbuf16[i]   = 0x0100 | vmem8[i];
 211 #endif
 212                 vmem8 = vmem8 + to_copy;
 213                 ret = par->fbtftops.write(par, par->txbuf.buf, to_copy * 2);
 214                 if (ret < 0)
 215                         return ret;
 216                 remain -= to_copy;
 217         }
 218
 219         return ret;
 220 }
 221 EXPORT_SYMBOL(fbtft_write_vmem16_bus9);
 222
 223 int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len)
 224 {
 225         dev_err(par->info->device, "%s: function not implemented\n", __func__);
 226         return -1;
 227 }
 228 EXPORT_SYMBOL(fbtft_write_vmem8_bus8);
 229
 230 /* 16 bit pixel over 16-bit databus */
 231 int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len)
 232 {
 233         u16 *vmem16;
 234
 235         fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
 236                       __func__, offset, len);
 237
 238         vmem16 = (u16 *)(par->info->screen_buffer + offset);
 239
 240         /* no need for buffered write with 16-bit bus */
 241         return fbtft_write_buf_dc(par, vmem16, len, 1);
 242 }
 243 EXPORT_SYMBOL(fbtft_write_vmem16_bus16);