/*

* This program is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License (either version 2 or

* version 3) as published by the Free Software Foundation.

*

* 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, write to the Free Software

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*

* For more information on the GPL, please go to:

* http://www.gnu.org/copyleft/gpl.html

*/

// Use at your own risk.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <libusb.h>

#define VID 0x04fc

#define PID 0x1528

#define TIMEOUT 1000

libusb_device_handle *device_handle;

void control_out(int request, int value, int index, unsigned char* buf,

int length) {

int n = libusb_control_transfer(device_handle, LIBUSB_ENDPOINT_OUT

| LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE, request,

value, index, buf, length, TIMEOUT);

if (n < 0) {

fprintf(stderr, "Control transfer failed: ");

switch (n) {

case LIBUSB_ERROR_TIMEOUT:

fprintf(stderr, "transfer timed out");

break;

case LIBUSB_ERROR_PIPE:

fprintf(stderr, "control request was not supported "

"by the device");

break;

case LIBUSB_ERROR_NO_DEVICE:

fprintf(stderr, "device has been disconnected");

break;

default:

fprintf(stderr, "error %d", n);

break;

}

fprintf(stderr, "\n");

} else if (n > 0) {

fprintf(stderr, "Write %d bytes:", n);

int i;

for (i = 0; i < n; i++)

fprintf(stderr, " %02x", buf[i]);

fprintf(stderr, "\n");

}

}

void control_in_vendor_device(int request, int value, int index, int length) {

unsigned char *buf = calloc(length, sizeof(unsigned char));

int n = libusb_control_transfer(device_handle, LIBUSB_ENDPOINT_IN

| LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_INTERFACE, request,

value, index, buf, length, TIMEOUT);

if (n < 0) {

fprintf(stderr, "Control transfer failed: ");

switch (n) {

case LIBUSB_ERROR_TIMEOUT:

fprintf(stderr, "transfer timed out");

break;

case LIBUSB_ERROR_PIPE:

fprintf(stderr, "control request was not supported "

"by the device");

break;

case LIBUSB_ERROR_NO_DEVICE:

fprintf(stderr, "device has been disconnected");

break;

default:

fprintf(stderr, "error %d", n);

break;

}

fprintf(stderr, "\n");

} else if (n > 0) {

fprintf(stderr, "Received %d bytes:", n);

int i;

for (i = 0; i < n; i++)

fprintf(stderr, " %02x", buf[i]);

fprintf(stderr, "\n");

}

free(buf);

}

void GetVersion() {

control_in_vendor_device(0x20, 0, 0, 8);

}

void GetVersion1() {

control_in_vendor_device(0x20, 0, 1, 8);

}

void GetVersion2() {

control_in_vendor_device(0x20, 0, 2, 8);

}

void bulk_transfer_error(int code) {

fprintf(stderr, "Bulk transfer failed: ");

switch (code) {

case LIBUSB_ERROR_TIMEOUT:

fprintf(stderr, "transfer timed out");

break;

case LIBUSB_ERROR_PIPE:

fprintf(stderr, "endpoint halted");

break;

case LIBUSB_ERROR_OVERFLOW:

fprintf(stderr, "device sent too much data");

break;

case LIBUSB_ERROR_NO_DEVICE:

fprintf(stderr, "device has been disconnected");

break;

default:

fprintf(stderr, "error %d", code);

break;

}

fprintf(stderr, "\n");

}

int bulk_read(int endpoint, unsigned char *buf, int length) {

int ret, n;

if ((ret = libusb_bulk_transfer(device_handle, LIBUSB_ENDPOINT_IN

| endpoint, buf, length, &n, TIMEOUT)) < 0)

bulk_transfer_error(ret);

return n;

}

int bulk_write(int endpoint, unsigned char *buf, int length) {

int ret, n;

if ((ret = libusb_bulk_transfer(device_handle, LIBUSB_ENDPOINT_OUT

| endpoint, buf, length, &n, TIMEOUT)) < 0)

bulk_transfer_error(ret);

if (n)

fprintf(stderr, "Sent %d bytes\n", n);

return n;

}

int main(int argc, char **argv) {

FILE *pFile = NULL;

int size;

long lSize;

unsigned char *buffer;

unsigned char *buf2 = calloc(300, sizeof(unsigned char));

if (argc < 2) {

fprintf(stderr, "Missing upload filename \n\n");

fprintf(stderr, "Usage: \n");

fprintf(stderr, "ISP808 <uploadfile> \n");

exit(1);;

}

pFile = fopen(argv[1], "rb");

if (pFile == NULL) {

fprintf(stderr, "ERROR: Unable to open file %s \n", argv[1]);

exit(1);

}

// obtain file size:

fseek(pFile, 0, SEEK_END);

lSize = ftell(pFile);

rewind(pFile);

// allocate memory to contain the whole file:

buffer = calloc(lSize, sizeof(unsigned char));

if (buffer == NULL) {

fputs("Memory error", stderr);

exit(2);

}

size = fread(buffer, 1, lSize, pFile);

if (size != lSize) {

fputs("Reading error", stderr);

exit(3);

}

libusb_context *context;

libusb_init(&context);

libusb_set_debug(context, 3);

device_handle = libusb_open_device_with_vid_pid(context, VID, PID);

if (!device_handle) {

fprintf(stderr, "ERROR: Unable to find device "

"(Vendor ID = %04x, Product ID = %04x)\n", VID, PID);

fprintf(stderr, "Press the Mode Button and connect the cam to USB \n");

return 1;

}

libusb_claim_interface(device_handle, 2);

libusb_set_interface_alt_setting(device_handle, 0, 0);

usleep(100);

// Get the installed version

fprintf(stdout, "\nRead 808 Version \n");

GetVersion();

GetVersion1();

GetVersion2();

fprintf(stdout, "\nStart Uploading the file: %s \n",argv[1]);

char defout[] = { 0x00, 0x80, 0x04, 0x00, 0x2d, 0x10, 0x00, 0x00 };

control_in_vendor_device(0x70, 0, 0, 5);

usleep(100);

control_out(0xfd, 0, 0x4f3, defout, 8);

usleep(200); // Fix me

// Download the code

fprintf(stdout, "\nDownload Code.... \n");

bulk_write(3, buffer, lSize);

usleep(200);

char defout2[] = { 0x00, 0x80, 0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,

0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 };

control_out(0xfd, 0, 0x4f1, defout2, 0x10);

usleep(100);

// Dont know why

bulk_write(3, buf2, 256);

fprintf(stdout, "\nDownload Ready.... \n");

usleep(100);

if (pFile)

fclose(pFile);

free(buffer);

libusb_release_interface(device_handle, 0);

libusb_close(device_handle);

libusb_exit(context);

return 0;

}