[deliverable/linux.git] / drivers / staging / fbtft / fbtft-bus.c

#include <linux/export.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/spi/spi.h>
#include "fbtft.h"

/*****************************************************************************
 *
 *   void (*write_reg)(struct fbtft_par *par, int len, ...);
 *
 *****************************************************************************/

#define define_fbtft_write_reg(func, type, modifier)                          \
void func(struct fbtft_par *par, int len, ...)                                \
{                                                                             \
	va_list args;                                                         \
	int i, ret;                                                           \
	int offset = 0;                                                       \
	type *buf = (type *)par->buf;                                         \
									      \
	if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) {                    \
		va_start(args, len);                                          \
		for (i = 0; i < len; i++) {                                   \
			buf[i] = (type)va_arg(args, unsigned int);            \
		}                                                             \
		va_end(args);                                                 \
		fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par, par->info->device, type, buf, len, "%s: ", __func__);   \
	}                                                                     \
									      \
	va_start(args, len);                                                  \
									      \
	if (par->startbyte) {                                                 \
		*(u8 *)par->buf = par->startbyte;                             \
		buf = (type *)(par->buf + 1);                                 \
		offset = 1;                                                   \
	}                                                                     \
									      \
	*buf = modifier((type)va_arg(args, unsigned int));                    \
	if (par->gpio.dc != -1)                                               \
		gpio_set_value(par->gpio.dc, 0);                              \
	ret = par->fbtftops.write(par, par->buf, sizeof(type) + offset);      \
	if (ret < 0) {                                                        \
		va_end(args);                                                 \
		dev_err(par->info->device, "%s: write() failed and returned %d\n", __func__, ret); \
		return;                                                       \
	}                                                                     \
	len--;                                                                \
									      \
	if (par->startbyte)                                                   \
		*(u8 *)par->buf = par->startbyte | 0x2;                       \
									      \
	if (len) {                                                            \
		i = len;                                                      \
		while (i--) {                                                 \
			*buf++ = modifier((type)va_arg(args, unsigned int));  \
		}                                                             \
		if (par->gpio.dc != -1)                                       \
			gpio_set_value(par->gpio.dc, 1);                      \
		ret = par->fbtftops.write(par, par->buf,		      \
					  len * (sizeof(type) + offset));     \
		if (ret < 0) {                                                \
			va_end(args);                                         \
			dev_err(par->info->device, "%s: write() failed and returned %d\n", __func__, ret); \
			return;                                               \
		}                                                             \
	}                                                                     \
	va_end(args);                                                         \
}                                                                             \
EXPORT_SYMBOL(func);

define_fbtft_write_reg(fbtft_write_reg8_bus8, u8, )
define_fbtft_write_reg(fbtft_write_reg16_bus8, u16, cpu_to_be16)
define_fbtft_write_reg(fbtft_write_reg16_bus16, u16, )

void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...)
{
	va_list args;
	int i, ret;
	int pad = 0;
	u16 *buf = (u16 *)par->buf;

	if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) {
		va_start(args, len);
		for (i = 0; i < len; i++)
			*(((u8 *)buf) + i) = (u8)va_arg(args, unsigned int);
		va_end(args);
		fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par,
			par->info->device, u8, buf, len, "%s: ", __func__);
	}
	if (len <= 0)
		return;

	if (par->spi && (par->spi->bits_per_word == 8)) {
		/* we're emulating 9-bit, pad start of buffer with no-ops
		 * (assuming here that zero is a no-op)
		 */
		pad = (len % 4) ? 4 - (len % 4) : 0;
		for (i = 0; i < pad; i++)
			*buf++ = 0x000;
	}

	va_start(args, len);
	*buf++ = (u8)va_arg(args, unsigned int);
	i = len - 1;
	while (i--) {
		*buf = (u8)va_arg(args, unsigned int);
		*buf++ |= 0x100; /* dc=1 */
	}
	va_end(args);
	ret = par->fbtftops.write(par, par->buf, (len + pad) * sizeof(u16));
	if (ret < 0) {
		dev_err(par->info->device,
			"write() failed and returned %d\n", ret);
		return;
	}
}
EXPORT_SYMBOL(fbtft_write_reg8_bus9);

/*****************************************************************************
 *
 *   int (*write_vmem)(struct fbtft_par *par);
 *
 *****************************************************************************/

/* 16 bit pixel over 8-bit databus */
int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len)
{
	u16 *vmem16;
	u16 *txbuf16 = par->txbuf.buf;
	size_t remain;
	size_t to_copy;
	size_t tx_array_size;
	int i;
	int ret = 0;
	size_t startbyte_size = 0;

	fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
		__func__, offset, len);

	remain = len / 2;
	vmem16 = (u16 *)(par->info->screen_buffer + offset);

	if (par->gpio.dc != -1)
		gpio_set_value(par->gpio.dc, 1);

	/* non buffered write */
	if (!par->txbuf.buf)
		return par->fbtftops.write(par, vmem16, len);

	/* buffered write */
	tx_array_size = par->txbuf.len / 2;

	if (par->startbyte) {
		txbuf16 = par->txbuf.buf + 1;
		tx_array_size -= 2;
		*(u8 *)(par->txbuf.buf) = par->startbyte | 0x2;
		startbyte_size = 1;
	}

	while (remain) {
		to_copy = min(tx_array_size, remain);
		dev_dbg(par->info->device, "    to_copy=%zu, remain=%zu\n",
						to_copy, remain - to_copy);

		for (i = 0; i < to_copy; i++)
			txbuf16[i] = cpu_to_be16(vmem16[i]);

		vmem16 = vmem16 + to_copy;
		ret = par->fbtftops.write(par, par->txbuf.buf,
						startbyte_size + to_copy * 2);
		if (ret < 0)
			return ret;
		remain -= to_copy;
	}

	return ret;
}
EXPORT_SYMBOL(fbtft_write_vmem16_bus8);

/* 16 bit pixel over 9-bit SPI bus: dc + high byte, dc + low byte */
int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len)
{
	u8 *vmem8;
	u16 *txbuf16 = par->txbuf.buf;
	size_t remain;
	size_t to_copy;
	size_t tx_array_size;
	int i;
	int ret = 0;

	fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
		__func__, offset, len);

	if (!par->txbuf.buf) {
		dev_err(par->info->device, "%s: txbuf.buf is NULL\n", __func__);
		return -1;
	}

	remain = len;
	vmem8 = par->info->screen_buffer + offset;

	tx_array_size = par->txbuf.len / 2;

	while (remain) {
		to_copy = min(tx_array_size, remain);
		dev_dbg(par->info->device, "    to_copy=%zu, remain=%zu\n",
						to_copy, remain - to_copy);

#ifdef __LITTLE_ENDIAN
		for (i = 0; i < to_copy; i += 2) {
			txbuf16[i]     = 0x0100 | vmem8[i + 1];
			txbuf16[i + 1] = 0x0100 | vmem8[i];
		}
#else
		for (i = 0; i < to_copy; i++)
			txbuf16[i]   = 0x0100 | vmem8[i];
#endif
		vmem8 = vmem8 + to_copy;
		ret = par->fbtftops.write(par, par->txbuf.buf, to_copy * 2);
		if (ret < 0)
			return ret;
		remain -= to_copy;
	}

	return ret;
}
EXPORT_SYMBOL(fbtft_write_vmem16_bus9);

int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len)
{
	dev_err(par->info->device, "%s: function not implemented\n", __func__);
	return -1;
}
EXPORT_SYMBOL(fbtft_write_vmem8_bus8);

/* 16 bit pixel over 16-bit databus */
int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len)
{
	u16 *vmem16;

	fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
		__func__, offset, len);

	vmem16 = (u16 *)(par->info->screen_buffer + offset);

	if (par->gpio.dc != -1)
		gpio_set_value(par->gpio.dc, 1);

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