/*
 * Atmel mxt probably mxt1188s-a or mxt1664s-a or mxt3432s or mxt143e
 * I think its the mxt143e
 *
 * URL for original source material:
 *	http://www.atmel.com/products/touchsolutions/touchscreens/unlimited_touch.aspx
 * GIT for original source material:
 *	git://github.com/atmel-maxtouch/obp-utils.git
 *
 * cc obp-utils.c test_atmel.c -o /tmp/test -I/usr/src/sys/
 *
 * kldload smb before running test program to get /dev/smb*
 */
#include <sys/types.h>
#include <sys/file.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>
#include <dev/smbus/smb/smb.h>
#include <bus/smbus/smbconf.h>

#include "obp-utils.h"

static const char *
mxt_gettypestring(int type)
{
	static const struct mxt_strinfo strinfo[] = { MXT_INIT_STRINGS };
	int i;

	for (i = 0; i < sizeof(strinfo) / sizeof(strinfo[0]); ++i) {
		if (strinfo[i].type == type)
			return(strinfo[i].id);
	}
	return("unknown");
}

struct mxt_object *
mxt_findobject(struct mxt_rollup *rup, int type)
{
	int i;

	for (i = 0; i < rup->nobjs; ++i) {
		if (rup->objs[i].type == type)
			return(&rup->objs[i]);
	}
	return NULL;
}

static int
mxt_read_reg(int fd, uint16_t reg, void *rbuf, int bytes)
{
	struct smbcmd cmd;
	uint8_t wbuf[2];
	int r;

	bzero(&cmd, sizeof(cmd));
	wbuf[0] = reg & 255;
	wbuf[1] = reg >> 8;
	cmd.slave = 0;
	cmd.rbuf = rbuf;
	cmd.wbuf = wbuf;
	cmd.wcount = 2;
	cmd.rcount = bytes;
	cmd.op = SMB_TRANS_NOCNT | SMB_TRANS_NOCMD | SMB_TRANS_7BIT;

	r = ioctl(fd, SMB_TRANS, &cmd);
	if (r == 0) {
		return cmd.rcount;
	} else {
		printf("status r = %d slave 0x%02x\n", r, cmd.slave);
		return -1;
	}
}

static int
mxt_write_reg_buf(int fd, uint16_t reg, void *xbuf, int bytes)
{
	struct smbcmd cmd;
	uint8_t wbuf[256];
	int r;

	assert(bytes < sizeof(wbuf) - 2);
	wbuf[0] = reg & 0xff;
	wbuf[1] = reg >> 8;
	bcopy(xbuf, wbuf + 2, bytes);

	cmd.slave = 0;
	cmd.rbuf = NULL;
	cmd.wbuf = wbuf;
	cmd.wcount = bytes + 2;
	cmd.rcount = 0;
	cmd.op = SMB_TRANS_NOCNT | SMB_TRANS_NOCMD | SMB_TRANS_7BIT;

	r = ioctl(fd, SMB_TRANS, &cmd);
	if (r == 0) {
		return 0;
	} else {
		printf("status r = %d slave 0x%02x\n", r, cmd.slave);
		return -1;
	}
}

static int
mxt_write_reg(int fd, uint16_t reg, uint8_t val)
{
	return mxt_write_reg_buf(fd, reg, &val, 1);
}

static int
mxt_read_object(int fd, struct mxt_object *obj, void *rbuf, int rbytes)
{
	uint16_t reg = obj->start_pos_lsb + (obj->start_pos_msb << 8);
	int bytes = obj->size_minus_one + 1;

	if (bytes > rbytes)
		bytes = rbytes;
	return mxt_read_reg(fd, reg, rbuf, bytes);
}


static int
mxt_t6_command(int fd, uint16_t t6cmd, uint8_t t6val, int waitforme)
{
	uint8_t status;

	mxt_write_reg(fd, 6 + t6cmd, t6val);

	while (waitforme) {
		if (mxt_read_reg(fd, 6 + t6cmd, &status, 1) != 1)
			break;
		if (status)
			return status;
	}
	return 0;
}

static
const char *
msgflagsstr(uint8_t flags)
{
	static char buf[9];

	buf[0] = (flags & MXT_MSGF_DETECT) ? 'D' : '.';
	buf[1] = (flags & MXT_MSGF_PRESS) ? 'P' : '.';
	buf[2] = (flags & MXT_MSGF_RELEASE) ? 'R' : '.';
	buf[3] = (flags & MXT_MSGF_MOVE) ? 'M' : '.';
	buf[4] = (flags & MXT_MSGF_VECTOR) ? 'V' : '.';
	buf[5] = (flags & MXT_MSGF_AMP) ? 'A' : '.';
	buf[6] = (flags & MXT_MSGF_SUPPRESS) ? 'S' : '.';
	buf[7] = (flags & MXT_MSGF_UNGRIP) ? 'U' : '.';

	return buf;
}

int
main(int ac, char **av)
{
	uint8_t rbuf[1024];
	struct mxt_rollup rup;
	struct mxt_object *obj;
	int fd;
	int i;
	int n;
	int r;
	size_t blksize;
	size_t totsize;
	uint32_t crc;

	fd = open("/dev/smb1-4a", O_RDWR);
	printf("fd = %d\n", fd);

	r = mxt_t6_command(fd, 0/*RESET*/, 0x01, 1);
	printf("reset result %d\n", r);

	n = mxt_read_reg(fd, 0, &rup.info, sizeof(rup.info));
	for (i = 0; i < n; ++i)
		printf(" %02x", ((uint8_t *)&rup.info)[i]);
	printf("\n");
	rup.nobjs = rup.info.num_objects;

	blksize = sizeof(rup.info) +
		  rup.nobjs * sizeof(struct mxt_object);
	totsize = blksize + sizeof(struct mxt_raw_crc);
	assert(totsize < sizeof(rbuf));

	n = mxt_read_reg(fd, 0, rbuf, totsize);
	if (n != totsize) {
		printf("mxt_read_reg: config failed: %d/%d\n", n, totsize);
		exit(1);
	}
	crc = obp_convert_crc((struct mxt_raw_crc *)(rbuf + blksize));
	if (obp_crc24(rbuf, blksize) != crc) {
		printf("info: crc failed %08x/%08x\n",
			crc,
			obp_crc24(rbuf, blksize));
		exit(1);
	}
	rup.objs = (void *)(rbuf + sizeof(rup.info));
	for (i = 0; i < rup.nobjs; ++i) {
		obj = &rup.objs[i];
		printf("object %d (%s) {\n",
			obj->type,
			mxt_gettypestring(obj->type));
		printf("    position = %d\n",
			obj->start_pos_lsb + (obj->start_pos_msb << 8));
		printf("    size     = %d\n",
			obj->size_minus_one + 1);
		printf("    instances= %d\n",
			obj->instances_minus_one + 1);
		printf("    numids   = %d\n",
			obj->num_report_ids);
	}
	printf("\n");
	fflush(stdout);

	obj = mxt_findobject(&rup, MXT_GEN_MESSAGEPROCESSOR);
	assert(obj != NULL);

	for (;;) {
		mxt_message_t msg;

		n = mxt_read_object(fd, obj, &msg, sizeof(msg));
		if (msg.any.reportid == 255)
			continue;
		for (i = 0; i < n; ++i)
			printf(" %02x", ((uint8_t *)&msg)[i]);
		printf("  trk=%02x f=%s x=%-4d y=%-4d p=%d amp=%d\n",
			msg.any.reportid,
			msgflagsstr(msg.touch.flags),
			(msg.touch.pos[0] << 4) |
				((msg.touch.pos[2] >> 4) & 0x0F),
			(msg.touch.pos[1] << 4) |
				((msg.touch.pos[2]) & 0x0F),
			msg.touch.area,
			msg.touch.amplitude);
		usleep(100000);
	}
}