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