int camera_init (Camera *camera, GPContext *context) {
GPPortSettings settings;
int speed;
/* First, set up all the function pointers */
camera->functions->capture = camera_capture;
camera->functions->summary = camera_summary;
camera->functions->manual = camera_manual;
camera->functions->about = camera_about;
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
/* Configure the port (remember the speed) */
gp_port_get_settings (camera->port, &settings);
speed = settings.serial.speed;
settings.serial.speed = 9600;
settings.serial.bits = 8;
settings.serial.parity = 0;
settings.serial.stopbits = 1;
gp_port_set_settings (camera->port, settings);
gp_port_set_timeout (camera->port, TIMEOUT);
/* Reset the camera to 9600 */
gp_port_send_break (camera->port, 2);
/* Wait for it to update */
GP_SYSTEM_SLEEP(1500);
if (dc120_set_speed (camera, speed) == GP_ERROR) {
return (GP_ERROR);
}
/* Try to talk after speed change */
if (dc120_get_status(camera, NULL, context) == GP_ERROR) {
return (GP_ERROR);
}
return (GP_OK);
}
int digita_serial_open(CameraPrivateLibrary *dev, Camera *camera)
{
GPPortSettings settings;
int selected_speed;
int ret, retries, negotiated = 0;
unsigned char buffer[20];
unsigned short s;
unsigned int l;
/* Get the settings */
ret = gp_port_get_settings(camera->port, &settings);
if (ret < 0)
return ret;
/* Remember the selected speed */
selected_speed = settings.serial.speed;
if (!selected_speed)
selected_speed = 115200; /* Try the maximum speed */
/* Set the settings */
settings.serial.speed = 9600;
settings.serial.bits = 8;
settings.serial.parity = 0;
settings.serial.stopbits = 1;
ret = gp_port_set_settings(camera->port, settings);
if (ret < 0)
return ret;
dev->send = digita_serial_send;
dev->read = digita_serial_read;
gp_port_send_break(dev->gpdev, 4);
usleep(10000);
/* FIXME: In some situations we may want to try a slower speed */
for (retries = 0; !negotiated && retries < MAX_BEACON_RETRIES; retries++) {
unsigned char csum;
int i, timeouts = 0;
/*
* Read the beacon
*/
memset(buffer, 0, sizeof(buffer));
for (i = 0; (i < BEACON_LEN * 2) && (timeouts < MAX_BEACON_TIMEOUTS); i++) {
/* We specifically eat as much as we can to catch any */
/* garbage before or after */
ret = gp_port_read(dev->gpdev, (void *)buffer, 1);
if (ret < 0) {
GP_DEBUG("couldn't read beacon (ret = %d)", ret);
timeouts++;
continue;
}
if (buffer[0] == 0xA5)
break;
}
if (timeouts >= MAX_BEACON_TIMEOUTS)
continue;
ret = gp_port_read(dev->gpdev, (void *)(buffer + 1), BEACON_LEN - 1);
if (ret < 0) {
GP_DEBUG("couldn't read beacon (ret = %d)", ret);
continue;
}
if (buffer[0] != 0xA5 || buffer[1] != 0x5A) {
GP_DEBUG("Invalid header for beacon 0x%02x 0x%02x", buffer[0], buffer[1]);
continue;
}
csum = buffer[6];
buffer[6] = 0;
if (checksum(buffer, BEACON_LEN) != csum) {
GP_DEBUG("Beacon checksum failed (calculated 0x%02x, received 0x%02x)",
checksum(buffer, BEACON_LEN), csum);
continue;
}
memcpy((void *)&s, &buffer[2], 2);
GP_DEBUG("Vendor: 0x%04x", be16toh(s));
memcpy((void *)&s, &buffer[4], 2);
GP_DEBUG("Product: 0x%04x", be16toh(s));
/*
* Send the beacon acknowledgement
*/
buffer[0] = 0x5A; /* Magic */
buffer[1] = 0xA5;
buffer[2] = 0x55; /* I/F Type */
buffer[3] = 0; /* Comm Flag */
l = htobe32(selected_speed);
memcpy(&buffer[4], (void *)&l, 4); /* Data speed */
s = htobe16(1023);
memcpy(&buffer[8], (void *)&s, 2); /* Device Frame Size */
s = htobe16(1023);
memcpy(&buffer[10], (void *)&s, 2); /* Host Frame Size */
buffer[12] = 0;
buffer[12] = checksum(buffer, BEACON_ACK_LENGTH);
ret = gp_port_write(dev->gpdev, (void *)buffer, BEACON_ACK_LENGTH);
if (ret < 0) {
GP_DEBUG("couldn't write beacon (ret = %d)", ret);
return -1;
}
/*
* Read the beacon completion
*/
ret = gp_port_read(dev->gpdev, (void *)buffer, BEACON_COMP_LENGTH);
if (ret < 0) {
GP_DEBUG("couldn't read beacon_comp (ret = %d)", ret);
continue;
}
if ((signed char)buffer[0] < 0) {
GP_DEBUG("Bad status %d during beacon completion", (signed int)buffer[0]);
continue;
}
memcpy((void *)&s, &buffer[6], sizeof(s));
dev->deviceframesize = be16toh(s);
memcpy((void *)&l, &buffer[2], sizeof(l));
GP_DEBUG("negotiated %d", be32toh(l));
settings.serial.speed = be32toh(l);
usleep(100000); /* Wait before */
ret = gp_port_set_settings(dev->gpdev, settings);
if (ret < 0)
return ret;
usleep(100000); /* Wait after */
/*
* The host interface spec mentions kTestSerialData, but
* doesn't elaborate anywhere else on it. So, I guess we
* assume everything is working here
*/
negotiated = 1;
}
return negotiated ? 0 : -1;
}
/* reset camera */
int
mesa_reset( GPPort *port )
{
return gp_port_send_break( port, 1 );
}
int
camera_init (Camera *camera, GPContext *context)
{
int ret, selected_speed = 0;
GPPortSettings settings;
/* First, set up all the function pointers */
camera->functions->exit = camera_exit;
camera->functions->capture = camera_capture;
camera->functions->summary = camera_summary;
camera->functions->about = camera_about;
/* Set up the CameraFilesystem */
gp_filesystem_set_funcs (camera->fs, &fsfuncs, camera);
ret = gp_port_get_settings (camera->port, &settings);
if (ret < 0)
return (ret);
switch (camera->port->type) {
case GP_PORT_SERIAL:
/* Remember the selected speed */
selected_speed = settings.serial.speed;
settings.serial.speed = 9600;
settings.serial.bits = 8;
settings.serial.parity = 0;
settings.serial.stopbits = 1;
break;
case GP_PORT_USB:
settings.usb.inep = 0x82;
settings.usb.outep = 0x01;
settings.usb.config = 1;
settings.usb.interface = 0;
settings.usb.altsetting = 0;
break;
default:
return (GP_ERROR_UNKNOWN_PORT);
}
ret = gp_port_set_settings (camera->port, settings);
if (ret < 0)
return (ret);
ret = gp_port_set_timeout (camera->port, TIMEOUT);
if (ret < 0)
return (ret);
if (camera->port->type == GP_PORT_SERIAL) {
char buf[8];
/* Reset the camera to 9600 */
gp_port_send_break(camera->port, 1);
/* Used to have a 1500 msec pause here to give
* the camera time to reset - but, since
* the serial port sometimes returns a garbage
* character or two after the break, we do
* a couple of TIMEOUT (750 msec) pauses here
* force the delay as well as flush the port
*/
gp_port_read(camera->port, buf, 8);
gp_port_read(camera->port, buf, 8);
ret = dc240_set_speed (camera, selected_speed);
if (ret < 0)
return (ret);
}
/* Open the CF card */
ret = dc240_open (camera);
if (ret < 0)
return (ret);
ret = dc240_packet_set_size (camera, HPBS+2);
if (ret < 0)
return (ret);
return (GP_OK);
}
