static int open_app_files(void)
{
int i;
for (i = 0; i < ncpus; i++) {
if (open_cpu_files(i, app_dirname, percpu_basename,
percpu_out_basename) < 0) {
control_write(app_dirname, "enabled", 0);
control_write(app_dirname, "create", 0);
return -1;
}
}
return 0;
}
static void
handle_ep0_control(
struct vhci_usb_t * p,
struct _ep * ep0,
struct usb_vhci_urb * urb)
{
int res;
if (urb->bmRequestType &0x80) {
res = control_read(p,ep0,
urb->bmRequestType,
urb->bRequest,
urb->wValue,
urb->wIndex,
urb->wLength,
urb->buffer);
if (res>=0) {
urb->buffer_actual=res;
res=0;
}
}
else
res = control_write(p,ep0,
urb->bmRequestType,
urb->bRequest,
urb->wValue,
urb->wIndex,
urb->wLength,
urb->buffer);
if (res==AVR_IOCTL_USB_STALL)
urb->status = USB_VHCI_STATUS_STALL;
else
urb->status = USB_VHCI_STATUS_SUCCESS;
}
/**
* create_percpu_threads - create per-cpu threads
*/
static int create_percpu_threads(void)
{
unsigned long i;
for (i = 0; i < ncpus; i++) {
/* create a thread for each per-cpu buffer */
if (pthread_create(&reader[i], NULL, reader_thread,
(void *)i) < 0) {
printf("Couldn't create thread\n");
control_write(app_dirname, "enabled", 0);
control_write(app_dirname, "create", 0);
return -1;
}
}
return 0;
}
void
control_write_hex(struct client *c, const char *buf, int len)
{
for (int i = 0; i < len; i++) {
char temp[3];
snprintf(temp, sizeof(temp), "%02x", ((int) buf[i]) & 0xff);
control_write(c, temp, 2);
}
}
/* Control error callback. */
static enum cmd_retval
control_error(struct cmdq_item *item, void *data)
{
struct client *c = item->client;
char *error = data;
cmdq_guard(item, "begin", 1);
control_write(c, "parse error: %s", error);
cmdq_guard(item, "error", 1);
free(error);
return (CMD_RETURN_NORMAL);
}
/* from bases.py FitBitAnt.init */
void
fitbit_ant_init (void)
{
int n;
unsigned char buf[128];
control_write (0x00, 0xFFFF, 0x0, NULL, 0);
control_write (0x01, 0x2000, 0x0, NULL, 0);
/*
* At this point, we get a 4096 buffer, then start all over
* again? Apparently doesn't require an explicit receive
*/
control_write (0x00, 0x0, 0x0, NULL, 0);
control_write (0x00, 0xFFFF, 0x0, NULL, 0);
control_write (0x01, 0x2000, 0x0, NULL, 0);
control_write (0x01, 0x4A, 0x0, NULL, 0);
/* Receive 1 byte, should be 0x2 */
n = control_read (0xff, 0x370b, 0, buf, sizeof buf);
if (n < 1) {
dbg ("fitbit_ant_init: first read %d %s\n", n, errstr (n));
exit (1);
}
if (buf[0] != 2) {
dbg ("fitbit_ant_init: first read expected 2 got 0x%x\n",
buf[0]);
exit (1);
}
control_write (0x03, 0x800, 0x0, NULL, 0);
memset (buf, 0, sizeof buf);
buf[0] = 0x08;
buf[4] = 0x40;
control_write (0x13, 0x0, 0x0, buf, 16);
control_write (0x12, 0x0C, 0x0, NULL, 0);
dbg ("initial soak...\n");
soak (0.010);
dbg ("done\n");
}
/* Control input callback. Read lines and fire commands. */
void
control_callback(struct client *c, int closed, unused void *data)
{
char *line, *cause;
struct cmd_ctx ctx;
struct cmd_list *cmdlist;
if (closed)
c->flags |= CLIENT_EXIT;
for (;;) {
line = evbuffer_readln(c->stdin_data, NULL, EVBUFFER_EOL_LF);
if (line == NULL)
break;
if (*line == '\0') { /* empty line exit */
c->flags |= CLIENT_EXIT;
break;
}
ctx.msgdata = NULL;
ctx.cmdclient = NULL;
ctx.curclient = c;
ctx.error = control_msg_error;
ctx.print = control_msg_print;
ctx.info = control_msg_info;
if (cmd_string_parse(line, &cmdlist, &cause) != 0) {
control_write(c, "%%error in line \"%s\": %s", line,
cause);
xfree(cause);
} else {
cmd_list_exec(cmdlist, &ctx);
cmd_list_free(cmdlist);
}
xfree(line);
}
}
/* Control input callback. Read lines and fire commands. */
void
control_callback(struct client *c, int closed, unused void *data)
{
char *line, *cause;
struct cmd_list *cmdlist;
struct cmd *cmd;
if (closed)
c->flags |= CLIENT_EXIT;
for (;;) {
line = evbuffer_readln(c->stdin_data, NULL, EVBUFFER_EOL_LF);
if (line == NULL)
break;
if (*line == '\0') { /* empty line exit */
c->flags |= CLIENT_EXIT;
break;
}
if (cmd_string_parse(line, &cmdlist, NULL, 0, &cause) != 0) {
c->cmdq->time = time(NULL);
c->cmdq->number++;
cmdq_guard(c->cmdq, "begin", 1);
control_write(c, "parse error: %s", cause);
cmdq_guard(c->cmdq, "error", 1);
free(cause);
} else {
TAILQ_FOREACH(cmd, &cmdlist->list, qentry)
cmd->flags |= CMD_CONTROL;
cmdq_run(c->cmdq, cmdlist);
cmd_list_free(cmdlist);
}
free(line);
}
}
void
control_write_str(struct client *c, const char *str)
{
control_write(c, str, strlen(str));
}
static int do_command(uint16_t command, uint16_t seqnum, uint16_t varid,
uint8_t *value, uint16_t length)
{
unsigned char cp[254], rp[254];
uint8_t cmd[10];
uint16_t size;
int len, offset = 0;
size = (length < 8) ? 9 : ((length + 1) / 2) + 5;
cmd[0] = command & 0xff;
cmd[1] = command >> 8;
cmd[2] = size & 0xff;
cmd[3] = size >> 8;
cmd[4] = seqnum & 0xff;
cmd[5] = seqnum >> 8;
cmd[6] = varid & 0xff;
cmd[7] = varid >> 8;
cmd[8] = 0x00;
cmd[9] = 0x00;
memset(cp, 0, sizeof(cp));
cp[0] = 0x00;
cp[1] = 0xfc;
cp[2] = (size * 2) + 1;
cp[3] = 0xc2;
memcpy(cp + 4, cmd, sizeof(cmd));
memcpy(cp + 14, value, length);
interrupt_read(handle, USB_ENDPOINT_IN | 0x01, rp, sizeof(rp));
control_write(handle, cp, (size * 2) + 4);
switch (varid) {
case CSR_VARID_COLD_RESET:
case CSR_VARID_WARM_RESET:
case CSR_VARID_COLD_HALT:
case CSR_VARID_WARM_HALT:
return 0;
}
do {
len = interrupt_read(handle, USB_ENDPOINT_IN | 0x01,
rp + offset, sizeof(rp) - offset);
if (len < 0)
break;
offset += len;
} while (len > 0);
if (rp[0] != 0xff || rp[2] != 0xc2) {
errno = EIO;
return -1;
}
if ((rp[11] + (rp[12] << 8)) != 0) {
errno = ENXIO;
return -1;
}
memcpy(value, rp + 13, length);
return 0;
}
int main(int argc, char **argv)
{
extern char *optarg;
extern int optopt;
int i, c, signal;
size_t opt_subbuf_size = 0;
size_t opt_n_subbufs = 0;
sigset_t signals;
pthread_mutex_init(&processing_mutex, NULL);
sigemptyset(&signals);
sigaddset(&signals, SIGINT);
sigaddset(&signals, SIGTERM);
pthread_sigmask(SIG_BLOCK, &signals, NULL);
while ((c = getopt(argc, argv, "b:n:")) != -1) {
switch (c) {
case 'b':
opt_subbuf_size = (unsigned)atoi(optarg);
if (!opt_subbuf_size)
usage();
break;
case 'n':
opt_n_subbufs = (unsigned)atoi(optarg);
if (!opt_n_subbufs)
usage();
break;
case '?':
printf("Unknown option -%c\n", optopt);
usage();
break;
default:
break;
}
}
if ((opt_n_subbufs && !opt_subbuf_size) ||
(!opt_n_subbufs && opt_subbuf_size))
usage();
if (opt_n_subbufs && opt_n_subbufs) {
subbuf_size = opt_subbuf_size;
n_subbufs = opt_n_subbufs;
}
ncpus = sysconf(_SC_NPROCESSORS_ONLN);
control_write(app_dirname, "subbuf_size", subbuf_size);
control_write(app_dirname, "n_subbufs", n_subbufs);
/* disable logging in case we exited badly in a previous run */
control_write(app_dirname, "enabled", 0);
fprintf(stderr, "control_write: create\n");
control_write(app_dirname, "create", 1);
if (open_app_files())
return -1;
if (open_control_files(app_dirname, percpu_basename)) {
close_app_files();
return -1;
}
if (create_percpu_threads()) {
close_control_files();
close_app_files();
return -1;
}
control_write(app_dirname, "enabled", 1);
printf("Creating channel with %lu sub-buffers of size %lu.\n",
n_subbufs, subbuf_size);
printf("Logging... Press Control-C to stop.\n");
sigemptyset(&signals);
sigaddset(&signals, SIGINT);
sigaddset(&signals, SIGTERM);
while (sigwait(&signals, &signal) == 0) {
switch(signal) {
case SIGINT:
case SIGTERM:
control_write(app_dirname, "enabled", 0);
kill_percpu_threads(ncpus);
while(1) {
pthread_mutex_lock(&processing_mutex);
if (!processing) {
pthread_mutex_unlock(&processing_mutex);
break;
}
pthread_mutex_unlock(&processing_mutex);
}
for (i = 0; i < ncpus; i++)
check_buffer(i);
summarize();
close_control_files();
close_app_files();
control_write(app_dirname, "create", 0);
exit(0);
}
}
}
