[libsigrok.git] / src / hardware / chromium-twinkie / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright 2014 Google, Inc
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <stdint.h>
#include <string.h>
#include <libusb.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include "protocol.h"

SR_PRIV int twinkie_start_acquisition(const struct sr_dev_inst *sdi)
{
	(void)sdi;

	return SR_OK;
}

SR_PRIV int twinkie_init_device(const struct sr_dev_inst *sdi)
{
	(void)sdi;

	return SR_OK;
}

static void finish_acquisition(struct sr_dev_inst *sdi)
{
	struct sr_datafeed_packet packet;
	struct dev_context *devc = sdi->priv;

	/* Terminate session. */
	packet.type = SR_DF_END;
	sr_session_send(sdi, &packet);

	/* Remove fds from polling. */
	usb_source_remove(sdi->session, devc->ctx);

	devc->num_transfers = 0;
	g_free(devc->transfers);
	g_free(devc->convbuffer);
}

static void free_transfer(struct libusb_transfer *transfer)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	unsigned int i;

	sdi = transfer->user_data;
	devc = sdi->priv;

	g_free(transfer->buffer);
	transfer->buffer = NULL;
	libusb_free_transfer(transfer);

	for (i = 0; i < devc->num_transfers; i++) {
		if (devc->transfers[i] == transfer) {
			devc->transfers[i] = NULL;
			break;
		}
	}

	devc->submitted_transfers--;
	if (devc->submitted_transfers == 0)
		finish_acquisition(sdi);
}

static void export_samples(const struct sr_dev_inst *sdi, size_t cnt)
{
	struct sr_datafeed_packet packet;
	struct sr_datafeed_logic logic;
	struct dev_context *devc = sdi->priv;

	/* export the received data */
	packet.type = SR_DF_LOGIC;
	packet.payload = &logic;
	if (devc->limit_samples &&
	    cnt > devc->limit_samples - devc->sent_samples)
		cnt = devc->limit_samples - devc->sent_samples;
	logic.length = cnt;
	logic.unitsize = 1;
	logic.data = devc->convbuffer;
	sr_session_send(sdi, &packet);
	devc->sent_samples += cnt;
}

static void expand_sample_data(const struct sr_dev_inst *sdi,
			       const uint8_t *src, size_t srccnt)
{
	struct dev_context *devc = sdi->priv;
	int i, f;
	size_t b;
	size_t rdy_samples, left_samples;
	int frames = srccnt / 64;

	for (f = 0; f < frames; f++) {
		int ch = (src[1] >> 4) & 3; /* samples channel number */
		int bit = 1 << ch; /* channel bit mask */
		struct cc_context *cc = devc->cc + ch;
		uint8_t *dest = devc->convbuffer + cc->idx;

		if (ch >= 2) /* only acquires CCx channels */
			continue;

		/* TODO: check timestamp, overflow, sequence number */

		/* skip header, go to edges data */
		src+=4;
		for (i = 0; i < 60; i++,src++)
			if (*src == cc->prev_src) {
				cc->rollbacks++;
			} else {
				uint8_t diff = *src - cc->prev_src;
				int fixup = cc->rollbacks && (((int)*src < (int)cc->prev_src) || (*src == 0xff));
				size_t total = (fixup ? cc->rollbacks - 1 : cc->rollbacks) * 256 + diff;

				if (total + cc->idx > devc->convbuffer_size) {
					sr_warn("overflow %d+%zd/%zd\n",
						cc->idx, total,
						devc->convbuffer_size);
					/* reset current decoding */
					cc->rollbacks = 0;
					break;
				}

				/* insert bits in the buffer */
				if (cc->level)
					for (b = 0 ; b < total ; b++, dest++)
						*dest |= bit;
				else
					dest += total;
				cc->idx += total;

				/* flip level on the next edge */
				cc->level = ~cc->level;

				cc->rollbacks = 0;
				cc->prev_src = *src;
			}
		/* expand repeated rollbacks */
		if (cc->rollbacks > 1) {
			size_t total = 256 * (cc->rollbacks - 1);
			if (total + cc->idx > devc->convbuffer_size) {
				sr_warn("overflow %d+%zd/%zd\n",
					cc->idx, total, devc->convbuffer_size);
				/* reset current decoding */
				total = 0;
			}
			/* insert bits in the buffer */
			if (cc->level)
				for (b = 0 ; b < total ; b++, dest++)
					*dest |= bit ;
			cc->idx += total;
			cc->rollbacks = 1;
		}
	}

	/* samples ready to be pushed (with both channels) */
	rdy_samples = MIN(devc->cc[0].idx, devc->cc[1].idx);
	left_samples = MAX(devc->cc[0].idx, devc->cc[1].idx) - rdy_samples;
	/* skip empty transfer */
	if (rdy_samples == 0)
		return;

	export_samples(sdi, rdy_samples);

	/* clean up what we have sent */
	memmove(devc->convbuffer, devc->convbuffer + rdy_samples, left_samples);
	memset(devc->convbuffer + left_samples, 0, rdy_samples);
	devc->cc[0].idx -= rdy_samples;
	devc->cc[1].idx -= rdy_samples;
}

SR_PRIV void LIBUSB_CALL twinkie_receive_transfer(struct libusb_transfer *transfer)
{
	gboolean packet_has_error = FALSE;
	struct sr_dev_inst *sdi;
	struct dev_context *devc;

	sdi = transfer->user_data;
	devc = sdi->priv;

	/*
	 * If acquisition has already ended, just free any queued up
	 * transfer that come in.
	 */
	if (devc->sent_samples < 0) {
		free_transfer(transfer);
		return;
	}

	if (transfer->status || transfer->actual_length)
		sr_info("receive_transfer(): status %d received %d bytes.",
			transfer->status, transfer->actual_length);

	switch (transfer->status) {
	case LIBUSB_TRANSFER_NO_DEVICE:
		devc->sent_samples = -2;
		free_transfer(transfer);
		return;
	case LIBUSB_TRANSFER_COMPLETED:
	case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though. */
		break;
	default:
		packet_has_error = TRUE;
		break;
	}

	if (transfer->actual_length % 64) {
		sr_err("Bad USB packet size.");
		packet_has_error = TRUE;
	}

	if (transfer->actual_length == 0 || packet_has_error)
		goto resubmit;

	/* decode received edges */
	expand_sample_data(sdi, transfer->buffer, transfer->actual_length);

	if (devc->limit_samples &&
			(uint64_t)devc->sent_samples >= devc->limit_samples) {
		devc->sent_samples = -2;
		free_transfer(transfer);
		return;
	}
resubmit:
	if (libusb_submit_transfer(transfer) != LIBUSB_SUCCESS)
		free_transfer(transfer);
}
Commit	Line	Data
744e43bc VP	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright 2014 Google, Inc
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <config.h>
	21	#include <stdint.h>
	22	#include <string.h>
	23	#include <libusb.h>
	24	#include <stdio.h>
	25	#include <errno.h>
	26	#include <math.h>
	27	#include <libsigrok/libsigrok.h>
	28	#include "libsigrok-internal.h"
	29	#include "protocol.h"
	30
	31	SR_PRIV int twinkie_start_acquisition(const struct sr_dev_inst *sdi)
	32	{
	33	(void)sdi;
	34
	35	return SR_OK;
	36	}
	37
	38	SR_PRIV int twinkie_init_device(const struct sr_dev_inst *sdi)
	39	{
	40	(void)sdi;
	41
	42	return SR_OK;
	43	}
	44
	45	static void finish_acquisition(struct sr_dev_inst *sdi)
	46	{
	47	struct sr_datafeed_packet packet;
	48	struct dev_context *devc = sdi->priv;
	49
	50	/* Terminate session. */
	51	packet.type = SR_DF_END;
	52	sr_session_send(sdi, &packet);
	53
	54	/* Remove fds from polling. */
	55	usb_source_remove(sdi->session, devc->ctx);
	56
	57	devc->num_transfers = 0;
	58	g_free(devc->transfers);
	59	g_free(devc->convbuffer);
	60	}
	61
	62	static void free_transfer(struct libusb_transfer *transfer)
	63	{
	64	struct sr_dev_inst *sdi;
65	struct dev_context *devc;
66	unsigned int i;
67
68	sdi = transfer->user_data;
69	devc = sdi->priv;
70
71	g_free(transfer->buffer);
72	transfer->buffer = NULL;
73	libusb_free_transfer(transfer);
74
75	for (i = 0; i < devc->num_transfers; i++) {
76	if (devc->transfers[i] == transfer) {
77	devc->transfers[i] = NULL;
78	break;
79	}
80	}
81
82	devc->submitted_transfers--;
83	if (devc->submitted_transfers == 0)
84	finish_acquisition(sdi);
85	}
86
87	static void export_samples(const struct sr_dev_inst *sdi, size_t cnt)
88	{
89	struct sr_datafeed_packet packet;
90	struct sr_datafeed_logic logic;
91	struct dev_context *devc = sdi->priv;
92
93	/* export the received data */
94	packet.type = SR_DF_LOGIC;
95	packet.payload = &logic;
96	if (devc->limit_samples &&
97	cnt > devc->limit_samples - devc->sent_samples)
98	cnt = devc->limit_samples - devc->sent_samples;
99	logic.length = cnt;
100	logic.unitsize = 1;
101	logic.data = devc->convbuffer;
102	sr_session_send(sdi, &packet);
103	devc->sent_samples += cnt;
104	}
105
106	static void expand_sample_data(const struct sr_dev_inst *sdi,
107	const uint8_t *src, size_t srccnt)
108	{
109	struct dev_context *devc = sdi->priv;
110	int i, f;
111	size_t b;
112	size_t rdy_samples, left_samples;
113	int frames = srccnt / 64;
114
115	for (f = 0; f < frames; f++) {
116	int ch = (src[1] >> 4) & 3; /* samples channel number */
117	int bit = 1 << ch; /* channel bit mask */
118	struct cc_context *cc = devc->cc + ch;
119	uint8_t *dest = devc->convbuffer + cc->idx;
120
121	if (ch >= 2) /* only acquires CCx channels */
122	continue;
123
124	/* TODO: check timestamp, overflow, sequence number */
125
126	/* skip header, go to edges data */
127	src+=4;
128	for (i = 0; i < 60; i++,src++)
129	if (*src == cc->prev_src) {
130	cc->rollbacks++;
131	} else {
132	uint8_t diff = *src - cc->prev_src;
133	int fixup = cc->rollbacks && (((int)src < (int)cc->prev_src) \|\| (src == 0xff));
134	size_t total = (fixup ? cc->rollbacks - 1 : cc->rollbacks) * 256 + diff;
135
136	if (total + cc->idx > devc->convbuffer_size) {
137	sr_warn("overflow %d+%zd/%zd\n",
138	cc->idx, total,
139	devc->convbuffer_size);
140	/* reset current decoding */
141	cc->rollbacks = 0;
142	break;
143	}
144
145	/* insert bits in the buffer */
146	if (cc->level)
147	for (b = 0 ; b < total ; b++, dest++)
148	*dest \|= bit;
149	else
150	dest += total;
151	cc->idx += total;
152
153	/* flip level on the next edge */
154	cc->level = ~cc->level;
155
156	cc->rollbacks = 0;
157	cc->prev_src = *src;
158	}
159	/* expand repeated rollbacks */
160	if (cc->rollbacks > 1) {
161	size_t total = 256 * (cc->rollbacks - 1);
162	if (total + cc->idx > devc->convbuffer_size) {
163	sr_warn("overflow %d+%zd/%zd\n",
164	cc->idx, total, devc->convbuffer_size);
165	/* reset current decoding */
166	total = 0;
167	}
168	/* insert bits in the buffer */
169	if (cc->level)
170	for (b = 0 ; b < total ; b++, dest++)
171	*dest \|= bit ;
172	cc->idx += total;
173	cc->rollbacks = 1;
174	}
175	}
176
177	/* samples ready to be pushed (with both channels) */
178	rdy_samples = MIN(devc->cc[0].idx, devc->cc[1].idx);
179	left_samples = MAX(devc->cc[0].idx, devc->cc[1].idx) - rdy_samples;
180	/* skip empty transfer */
181	if (rdy_samples == 0)
182	return;
183
184	export_samples(sdi, rdy_samples);
185
186	/* clean up what we have sent */
187	memmove(devc->convbuffer, devc->convbuffer + rdy_samples, left_samples);
188	memset(devc->convbuffer + left_samples, 0, rdy_samples);
189	devc->cc[0].idx -= rdy_samples;
190	devc->cc[1].idx -= rdy_samples;
191	}
192
193	SR_PRIV void LIBUSB_CALL twinkie_receive_transfer(struct libusb_transfer *transfer)
194	{
195	gboolean packet_has_error = FALSE;
196	struct sr_dev_inst *sdi;
197	struct dev_context *devc;
198
199	sdi = transfer->user_data;
200	devc = sdi->priv;
201
202	/*
203	* If acquisition has already ended, just free any queued up
204	* transfer that come in.
205	*/
206	if (devc->sent_samples < 0) {
207	free_transfer(transfer);
208	return;
209	}
210
211	if (transfer->status \|\| transfer->actual_length)
212	sr_info("receive_transfer(): status %d received %d bytes.",
213	transfer->status, transfer->actual_length);
214
215	switch (transfer->status) {
216	case LIBUSB_TRANSFER_NO_DEVICE:
217	devc->sent_samples = -2;
218	free_transfer(transfer);
219	return;
220	case LIBUSB_TRANSFER_COMPLETED:
221	case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though. */
222	break;
223	default:
224	packet_has_error = TRUE;
225	break;
226	}
227
228	if (transfer->actual_length % 64) {
229	sr_err("Bad USB packet size.");
230	packet_has_error = TRUE;
231	}
232
233	if (transfer->actual_length == 0 \|\| packet_has_error)
234	goto resubmit;
235
236	/* decode received edges */
237	expand_sample_data(sdi, transfer->buffer, transfer->actual_length);
238
239	if (devc->limit_samples &&
240	(uint64_t)devc->sent_samples >= devc->limit_samples) {
241	devc->sent_samples = -2;
242	free_transfer(transfer);
243	return;
244	}
245	resubmit:
246	if (libusb_submit_transfer(transfer) != LIBUSB_SUCCESS)
247	free_transfer(transfer);
248	}