casio-qv-commands.c

/* casio-qv-commands.c
 *
 * Copyright © 2001 Lutz Müller
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
#include "config.h"
#include "casio-qv-commands.h"

#include <stdlib.h>

#define STX 0x02
#define ETX 0x03
#define ENQ 0x05
#define ACK 0x06
#define DC2 0x12
#define NAK 0x15
#define ETB 0x17
#define UNKNOWN1 0xfe
#define UNKNOWN2 0xe0

#define CASIO_QV_RETRIES 5

#define CR(result) {int r = (result); if (r < 0) return (r);}

int
QVping (Camera *camera)
{
	unsigned char c;
	int result = GP_OK, i = 0;

	/* Send ENQ and wait for ACK */
	while (1) {
		c = ENQ;
		CR (gp_port_write (camera->port, &c, 1));
		result = gp_port_read (camera->port, &c, 1);

		/* If we got ACK, everything is fine. */
		if (result >= 0) {
			switch © {
			case ACK:
			case ENQ:
				
				/*
				 * According to gphoto, we need to wait
				 * for ACK. But the camera of 
				 * David Wolfskill <david@catwhisker.org>
				 * seems to return ENQ after some NAK.
				 */
				return (GP_OK);

			case NAK:

				/* The camera is not yet ready. */
				break;

			case UNKNOWN1:
			case UNKNOWN2:

				/* 
				 * David Wolfskill <david@catwhisker.org>
				 * has seen those two bytes if one sends
				 * only ENQs to the camera. The camera first
				 * answers with some NAKs, then with some
				 * ACKs, and finally with UNKNOWN1 and 
				 * UNKNOWN2.
				 */
				while (gp_port_read (camera->port, &c, 1) >= 0);
				break;

			default:
				while (gp_port_read (camera->port, &c, 1) >= 0);
				break;
			}
		}

		if (++i < CASIO_QV_RETRIES)
			continue;

		/* If we got an error from libgphoto2_port, pass it along */
		CR (result);

		/* Return some error code */
		return (GP_ERROR_CORRUPTED_DATA);
	}
}

static int
QVsend (Camera *camera, unsigned char *cmd, int cmd_len,
			       unsigned char *buf, int buf_len)
{
	unsigned char c, checksum;
	int i;

	/* Write the request and calculate the checksum */
	CR (gp_port_write (camera->port, cmd, cmd_len));
	for (i = 0, checksum = 0; i < cmd_len; i++)
		checksum += cmd[i];

	/* Read the checksum */
	CR (gp_port_read (camera->port, &c, 1));
	if (c != ~checksum)
		return (GP_ERROR_CORRUPTED_DATA);

	/* Send ACK */
	c = ACK;
	CR (gp_port_write (camera->port, &c, 1));

	/* Receive the answer */
	if (buf_len)
		CR (gp_port_read (camera->port, buf, buf_len));

	return (GP_OK);
}

static int
QVblockrecv (Camera *camera, unsigned char **buf, unsigned long int *buf_len)
{
	unsigned char c;
	unsigned char buffer[2];
	int pos = 0, size, retries = 0, i;
	unsigned char sum;

	/* Send DC2 */
	CR (gp_port_write (camera->port, &c, 1));

	*buf = NULL;
	*buf_len = 0;
	while (1) {

		/* Read STX */
		CR (gp_port_read (camera->port, &c, 1));
		if (c != STX) {
			retries++;
			c = NAK;
			CR (gp_port_write (camera->port, &c, 1));
			if (retries > CASIO_QV_RETRIES)
				return (GP_ERROR_CORRUPTED_DATA);
			else
				continue;
		}

		/* Read sector size */
		CR (gp_port_read (camera->port, buffer, 2));
		size = (buffer[0] << 8) | buffer[1];
		sum = buffer[0] + buffer[1];

		/* Allocate the memory */
		if (!*buf)
			buf = malloc (sizeof (char) * size);
		else
			buf = realloc (buf, sizeof (char) * (*buf_len + size));
		if (!buf)
			return (GP_ERROR_NO_MEMORY);
		*buf_len += size;

		/* Get the sector */
		CR (gp_port_read (camera->port, *buf + pos, size));
		for (i = 0; i < size; i++)
			sum += *buf[i + pos];

		/* Get EOT or ETX and the checksum */
		CR (gp_port_read (camera->port, buffer, 2));
		sum += buffer[0];

		/* Verify the checksum */
		if (sum != ~buffer[1]) {
			c = NAK;
			CR (gp_port_write (camera->port, &c, 1));
			continue;
		}	

		/* Acknowledge and prepare for next packet */
		c = ACK;
		CR (gp_port_write (camera->port, &c, 1));
		pos += size;

		/* Are we done? */
		if (buffer[0] == ETX)
			break;		/* Yes */
		else if (buffer[0] == ETB)
			continue;	/* No  */
		else
			return (GP_ERROR_CORRUPTED_DATA);
	}

	return (GP_OK);
}

int
QVsetspeed (Camera *camera, QVSpeed speed)
{
	unsigned char cmd[3];

	cmd[0] = 'C';
	cmd[1] = 'B';
	cmd[3] = (unsigned char) speed;
	CR (QVsend (camera, cmd, 3, NULL, 0));

	return (GP_OK);
}

int
QVbattery (Camera *camera, float *battery)
{
	unsigned char cmd[6];
	unsigned char b;

	cmd[0] = 'R';
	cmd[1] = 'B';
	cmd[2] = ENQ;
	cmd[3] = 0xff;
	cmd[4] = 0xfe;
	cmd[5] = 0xe6;
	CR (QVsend (camera, cmd, 6, &b, 1));
	*battery = b / 16.;

	return (GP_OK);
}

int
QVrevision (Camera *camera, long int *revision)
{
	unsigned char cmd[2];
	unsigned char buf[4];

	cmd[0] = 'S';
	cmd[1] = 'U';
	CR (QVsend (camera, cmd, 2, buf, 4));
	*revision = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];

	return (GP_OK);
}

int
QVnumpic (Camera *camera)
{
	unsigned char cmd[2];
	unsigned char b;

	cmd[0] = 'M';
	cmd[1] = 'P';
	CR (QVsend (camera, cmd, 2, &b, 1));

	return (b);
}

int
QVpicattr (Camera *camera, int n, unsigned char *picattr)
{
	unsigned char cmd[2];
	unsigned char b;

	cmd[0] = 'D';
	cmd[1] = 'Y';
	CR (QVsend (camera, cmd, 2, &b, 1));
	*picattr = b;

	return (GP_OK);
}

int
QVshowpic (Camera *camera, int n)
{
	unsigned char cmd[3];

	cmd[0] = 'D';
	cmd[1] = 'A';
	cmd[2] = n;
	CR (QVsend (camera, cmd, 3, NULL, 0));

	return (GP_OK);
}

int
QVsetpic (Camera *camera)
{
	unsigned char cmd[2];

	cmd[0] = 'D';
	cmd[1] = 'L';
	CR (QVsend (camera, cmd, 2, NULL, 0));

	return (GP_OK);
}

int
QVgetpic (Camera *camera, unsigned char **data, unsigned long int *size)
{
	unsigned char cmd[2];

	cmd[0] = 'M';
	cmd[1] = 'G';
	CR (QVsend (camera, cmd, 2, NULL, 0));
	CR (QVblockrecv (camera, data, size));

	return (GP_OK);
}

int
QVgetthumb (Camera *camera, unsigned char **data, unsigned long int *size)
{
	unsigned char cmd[2];

	cmd[0] = 'M';
	cmd[1] = 'K';
	CR (QVsend (camera, cmd, 2, NULL, 0));
	CR (QVblockrecv (camera, data, size));

	return (GP_OK);
}

int
QVdelete (Camera *camera, int n)
{
	unsigned char cmd[4];

	cmd[0] = 'D';
	cmd[1] = 'F';
	cmd[2] = n;
	cmd[3] = 0xff;
	CR (QVsend (camera, cmd, 4, NULL, 0));

	return (GP_OK);
}

int
QVsize (Camera *camera, long int *size)
{
	unsigned char cmd[2];
	unsigned char buf[4];

	cmd[0] = 'E';
	cmd[1] = 'M';
	CR (QVsend (camera, cmd, 2, buf, 4));
	*size = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];

	return (GP_OK);
}

int
QVcapture (Camera *camera)
{
	unsigned char cmd[2];

	cmd[0] = 'D';
	cmd[1] = 'R';
	CR (QVsend (camera, cmd, 2, NULL, 0));

	return (GP_OK);
}