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(desc: par->gpio.dc, value: 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, buf: vmem16, len, dc: 1); |
242 | } |
243 | EXPORT_SYMBOL(fbtft_write_vmem16_bus16); |
244 | |