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 
fbtft_write_spi(struct fbtft_par * par,void * buf,size_t len)8 int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len)
9 {
10 	struct spi_transfer t = {
11 		.tx_buf = buf,
12 		.len = len,
13 	};
14 	struct spi_message m;
15 
16 	fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
17 			  "%s(len=%zu): ", __func__, len);
18 
19 	if (!par->spi) {
20 		dev_err(par->info->device,
21 			"%s: par->spi is unexpectedly NULL\n", __func__);
22 		return -1;
23 	}
24 
25 	spi_message_init(&m);
26 	spi_message_add_tail(&t, &m);
27 	return spi_sync(par->spi, &m);
28 }
29 EXPORT_SYMBOL(fbtft_write_spi);
30 
31 /**
32  * fbtft_write_spi_emulate_9() - write SPI emulating 9-bit
33  * @par: Driver data
34  * @buf: Buffer to write
35  * @len: Length of buffer (must be divisible by 8)
36  *
37  * When 9-bit SPI is not available, this function can be used to emulate that.
38  * par->extra must hold a transformation buffer used for transfer.
39  */
fbtft_write_spi_emulate_9(struct fbtft_par * par,void * buf,size_t len)40 int fbtft_write_spi_emulate_9(struct fbtft_par *par, void *buf, size_t len)
41 {
42 	u16 *src = buf;
43 	u8 *dst = par->extra;
44 	size_t size = len / 2;
45 	size_t added = 0;
46 	int bits, i, j;
47 	u64 val, dc, tmp;
48 
49 	fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
50 			  "%s(len=%zu): ", __func__, len);
51 
52 	if (!par->extra) {
53 		dev_err(par->info->device, "%s: error: par->extra is NULL\n",
54 			__func__);
55 		return -EINVAL;
56 	}
57 	if ((len % 8) != 0) {
58 		dev_err(par->info->device,
59 			"error: len=%zu must be divisible by 8\n", len);
60 		return -EINVAL;
61 	}
62 
63 	for (i = 0; i < size; i += 8) {
64 		tmp = 0;
65 		bits = 63;
66 		for (j = 0; j < 7; j++) {
67 			dc = (*src & 0x0100) ? 1 : 0;
68 			val = *src & 0x00FF;
69 			tmp |= dc << bits;
70 			bits -= 8;
71 			tmp |= val << bits--;
72 			src++;
73 		}
74 		tmp |= ((*src & 0x0100) ? 1 : 0);
75 		*(__be64 *)dst = cpu_to_be64(tmp);
76 		dst += 8;
77 		*dst++ = (u8)(*src++ & 0x00FF);
78 		added++;
79 	}
80 
81 	return spi_write(par->spi, par->extra, size + added);
82 }
83 EXPORT_SYMBOL(fbtft_write_spi_emulate_9);
84 
fbtft_read_spi(struct fbtft_par * par,void * buf,size_t len)85 int fbtft_read_spi(struct fbtft_par *par, void *buf, size_t len)
86 {
87 	int ret;
88 	u8 txbuf[32] = { 0, };
89 	struct spi_transfer	t = {
90 			.speed_hz = 2000000,
91 			.rx_buf		= buf,
92 			.len		= len,
93 		};
94 	struct spi_message	m;
95 
96 	if (!par->spi) {
97 		dev_err(par->info->device,
98 			"%s: par->spi is unexpectedly NULL\n", __func__);
99 		return -ENODEV;
100 	}
101 
102 	if (par->startbyte) {
103 		if (len > 32) {
104 			dev_err(par->info->device,
105 				"len=%zu can't be larger than 32 when using 'startbyte'\n",
106 				len);
107 			return -EINVAL;
108 		}
109 		txbuf[0] = par->startbyte | 0x3;
110 		t.tx_buf = txbuf;
111 		fbtft_par_dbg_hex(DEBUG_READ, par, par->info->device, u8,
112 				  txbuf, len, "%s(len=%zu) txbuf => ",
113 				  __func__, len);
114 	}
115 
116 	spi_message_init(&m);
117 	spi_message_add_tail(&t, &m);
118 	ret = spi_sync(par->spi, &m);
119 	fbtft_par_dbg_hex(DEBUG_READ, par, par->info->device, u8, buf, len,
120 			  "%s(len=%zu) buf <= ", __func__, len);
121 
122 	return ret;
123 }
124 EXPORT_SYMBOL(fbtft_read_spi);
125 
126 /*
127  * Optimized use of gpiolib is twice as fast as no optimization
128  * only one driver can use the optimized version at a time
129  */
fbtft_write_gpio8_wr(struct fbtft_par * par,void * buf,size_t len)130 int fbtft_write_gpio8_wr(struct fbtft_par *par, void *buf, size_t len)
131 {
132 	u8 data;
133 	int i;
134 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
135 	static u8 prev_data;
136 #endif
137 
138 	fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
139 			  "%s(len=%zu): ", __func__, len);
140 
141 	while (len--) {
142 		data = *(u8 *)buf;
143 
144 		/* Start writing by pulling down /WR */
145 		gpiod_set_value(par->gpio.wr, 1);
146 
147 		/* Set data */
148 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
149 		if (data == prev_data) {
150 			gpiod_set_value(par->gpio.wr, 1); /* used as delay */
151 		} else {
152 			for (i = 0; i < 8; i++) {
153 				if ((data & 1) != (prev_data & 1))
154 					gpiod_set_value(par->gpio.db[i],
155 							data & 1);
156 				data >>= 1;
157 				prev_data >>= 1;
158 			}
159 		}
160 #else
161 		for (i = 0; i < 8; i++) {
162 			gpiod_set_value(par->gpio.db[i], data & 1);
163 			data >>= 1;
164 		}
165 #endif
166 
167 		/* Pullup /WR */
168 		gpiod_set_value(par->gpio.wr, 0);
169 
170 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
171 		prev_data = *(u8 *)buf;
172 #endif
173 		buf++;
174 	}
175 
176 	return 0;
177 }
178 EXPORT_SYMBOL(fbtft_write_gpio8_wr);
179 
fbtft_write_gpio16_wr(struct fbtft_par * par,void * buf,size_t len)180 int fbtft_write_gpio16_wr(struct fbtft_par *par, void *buf, size_t len)
181 {
182 	u16 data;
183 	int i;
184 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
185 	static u16 prev_data;
186 #endif
187 
188 	fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
189 			  "%s(len=%zu): ", __func__, len);
190 
191 	while (len) {
192 		data = *(u16 *)buf;
193 
194 		/* Start writing by pulling down /WR */
195 		gpiod_set_value(par->gpio.wr, 1);
196 
197 		/* Set data */
198 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
199 		if (data == prev_data) {
200 			gpiod_set_value(par->gpio.wr, 1); /* used as delay */
201 		} else {
202 			for (i = 0; i < 16; i++) {
203 				if ((data & 1) != (prev_data & 1))
204 					gpiod_set_value(par->gpio.db[i],
205 							data & 1);
206 				data >>= 1;
207 				prev_data >>= 1;
208 			}
209 		}
210 #else
211 		for (i = 0; i < 16; i++) {
212 			gpiod_set_value(par->gpio.db[i], data & 1);
213 			data >>= 1;
214 		}
215 #endif
216 
217 		/* Pullup /WR */
218 		gpiod_set_value(par->gpio.wr, 0);
219 
220 #ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
221 		prev_data = *(u16 *)buf;
222 #endif
223 		buf += 2;
224 		len -= 2;
225 	}
226 
227 	return 0;
228 }
229 EXPORT_SYMBOL(fbtft_write_gpio16_wr);
230 
fbtft_write_gpio16_wr_latched(struct fbtft_par * par,void * buf,size_t len)231 int fbtft_write_gpio16_wr_latched(struct fbtft_par *par, void *buf, size_t len)
232 {
233 	dev_err(par->info->device, "%s: function not implemented\n", __func__);
234 	return -1;
235 }
236 EXPORT_SYMBOL(fbtft_write_gpio16_wr_latched);
237