drivers/staging/fbtft/fbtft-bus.c

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