int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[4]; /* room for dummy report ID */
int err;
if(argc < 2){
usage(argv[0]);
exit(1);
}
if((dev = openDevice()) == NULL)
exit(1);
if(strcasecmp(argv[1], "read") == 0){
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}else{
hexdump(buffer + 1, sizeof(buffer) - 1);
}
}else if(strcasecmp(argv[1], "write") == 0){
int i, pos;
memset(buffer, 0, sizeof(buffer));
for(pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++){
pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos);
}
if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}else{
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
/**************************************************************************************
Function Name : main
Description : Read and Write the Password in the EEPROM
Parameters : commandline arguments
Return : NULL
**************************************************************************************/
int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[129]; /* room for dummy report ID */
int err;
if(argc < 2){
usage(argv[0]);
exit(1);
}
if((dev = openDevice()) == NULL)
exit(1);
if(strcasecmp(argv[1], "read") == 0){
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 0, buffer, &len)) != 0){
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}else{
hexdump(buffer + 1, sizeof(buffer) - 1);
}
}else if(strcasecmp(argv[1], "write") == 0){
memset(buffer, 0, sizeof(buffer));
int i = 1;
while(*argv[2] != '\0'){
buffer[i] += *argv[2]++;
i++;
}
if((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}else{
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
uint8_t HIDwrite(usbDevice_t *dev, uint8_t reportId, uint8_t *buff, uint16_t size)
{
unsigned int i;
int len;
int err;
ucp_request_t request;
ucp_response_t response;
for(i=0; i<size; i+= 8)
{
request.reportid = reportId;
memcpy((void*)&request.data[0], (void*)&buff[i], sizeof(request.data));
if((err = usbhidSetReport(dev, (char*)&request, sizeof(request))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
len = sizeof(response);
if((err = usbhidGetReport(dev, reportId, (char*)&response, &len)) != 0)
{
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}
else
{
hexdump( (void*)&response.data[0], 8);
}
if(usleep(50000) < 0) // sleep 50 ms
{
fprintf( stderr, "sleep ERR\n");
}
}
return 0;
}
int stompbox_read_rom(usbDevice_t *dev, stompbox_rom_t *rom)
{
const int reportsize = 128;
int romsize = 512;
int report, len, err;
for (report = 1, rom->size = 0;
rom->size < romsize;
report++, rom->size += reportsize) {
len = reportsize;
err = usbhidGetReport(dev, report,
(char *) (rom->raw + rom->size), &len);
if (0 != err || reportsize != len) {
fprintf(stderr,
"Error reading ROM at %d: %s\n",
rom->size, (0 != err ? usbErrorMessage(err)
: "reply is too short"));
return -1;
}
}
return 0;
}
// Read HID report
static int d16_read_rep(USBDEVHANDLE dev, int reportnum, char raw_data[8+1])
{
char buffer[10];
int err;
int len = 8 + 1; /* report id 1 byte + 8 bytes data */
memset(buffer, 0, sizeof(buffer));
err = usbhidGetReport(dev, reportnum, buffer, &len);
if ( err ) {
printerr("error reading hid report: %s\n", usbErrorMessage(err));
return -1;
}
if ( len != 9 || buffer[0] != reportnum ) {
printerr("ERROR: wrong HID report returned! %d\n", len);
return -2;
}
if ( raw_data ) {
/* copy raw report data */
memcpy(raw_data, buffer, len);
}
return 0;
}
char* hidtool_read(usb_dev_handle *dev){
memset(readbuffer, 0, 5);
int err;
// convert r/w into struct.
int len = sizeof(readbuffer);
if((err = usbhidGetReport(dev, 0, readbuffer, &len)) != 0){
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}
return readbuffer;
}
int hidtool_write(usb_dev_handle *dev, char *data){
int err;
memset(writebuffer, 0, 5);
memcpy(writebuffer +1, data, 4);
if((err = usbhidSetReport(dev, writebuffer, 5)) != 0){ /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
return 1;
}
return 0;
}
static usbDevice_t *openDevice(void)
{
usbDevice_t *dev = NULL;
unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};
char vendorName[] = {USB_CFG_VENDOR_NAME, 0}, productName[] = {USB_CFG_DEVICE_NAME, 0};
int vid = rawVid[0] + 256 * rawVid[1];
int pid = rawPid[0] + 256 * rawPid[1];
int err;
if((err = usbhidOpenDevice(&dev, vid, vendorName, pid, productName, 0)) != 0){
fprintf(stderr, "error finding %s: %s\n", productName, usbErrorMessage(err));
return NULL;
}
return dev;
}
// Write HID report
static int d16_write_rep(USBDEVHANDLE dev, int reportnum, char buffer[8+1])
{
int err;
int len = 8 + 1; /* report id 1 byte + 8 bytes data */
buffer[0] = (char)reportnum;
err = usbhidSetReport(dev, buffer, len);
if ( err ) {
printerr("error writing hid report: %s\n", usbErrorMessage(err));
return -1;
}
return err;
}
/**
* API: Set the backlight brightness
*/
void
glcd2usb_backlight(PrivateData *p, int state)
{
int err = 0;
CT_glcd2usb_data *ctd = (CT_glcd2usb_data *) p->ct_data;
int promille = (state == BACKLIGHT_ON) ? p->brightness : p->offbrightness;
ctd->tx_buffer.bytes[0] = GLCD2USB_RID_SET_BL;
ctd->tx_buffer.bytes[1] = promille * 255 / 1000;
p->glcd_functions->drv_debug(RPT_DEBUG, "glcd2usb_backlight: new value = %d",
ctd->tx_buffer.bytes[1]);
if ((err = usbSetReport(ctd->device, USB_HID_REPORT_TYPE_FEATURE, ctd->tx_buffer.bytes, 2)) != 0) {
p->glcd_functions->drv_report(RPT_ERR, "Error freeing display: %s\n", usbErrorMessage(err));
}
}
uint8_t HIDread(usbDevice_t *dev, uint8_t reportId, uint8_t *buff, uint16_t size)
{
unsigned int i;
int err;
for(i=0; i<size; i+= 8)
{
ucp_response_t response;
int len = sizeof(response);
if((err = usbhidGetReport(dev, reportId, (char*)&response, &len)) != 0)
{
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}
else
{
memcpy((void*)&buff[i], (void*)&response.data, sizeof(response.data));
hexdump( (void*)&buff[i], 8);
}
}
return 0;
}
/**
* API: Poll for any pressed keys. Converts the bitmap of keys pressed into a
* scancode (1-4) for each pressed key.
* \note Only single key presses are detected.
*/
unsigned char
glcd2usb_poll_keys(PrivateData *p)
{
CT_glcd2usb_data *ctd = (CT_glcd2usb_data *) p->ct_data;
unsigned char keycode = 0;
int err = 0, len = 2;
int i;
if ((err = usbGetReport(ctd->device, USB_HID_REPORT_TYPE_FEATURE,
GLCD2USB_RID_GET_BUTTONS, ctd->tx_buffer.bytes, &len)) != 0) {
p->glcd_functions->drv_report(RPT_ERR, "glcd2usb_poll_keys: Error getting button state: %s",
usbErrorMessage(err));
return 0;
}
for (i = 0; i < 4; i++) {
if (ctd->tx_buffer.bytes[1] & (1 << i)) {
keycode = i + 1;
break;
}
}
return keycode;
}
static int uploadData(char *dataBuffer)
{
usbDevice_t *dev = NULL;
int err = 0, len, mask, pageSize, deviceSize, i;
union{
char bytes[1];
deviceInfo_t info;
deviceData_t data;
} buffer;
if((err = usbOpenDevice(&dev, IDENT_VENDOR_NUM, IDENT_VENDOR_STRING, IDENT_PRODUCT_NUM, IDENT_PRODUCT_STRING, 1)) != 0){
fprintf(stderr, "Error opening HIDBoot device: %s\n", usbErrorMessage(err));
goto errorOccurred;
}
len = sizeof(buffer);
if(endAddress[addressIndex] > startAddress[0]){ // we need to upload data
if((err = usbGetReport(dev, USB_HID_REPORT_TYPE_FEATURE, 1, buffer.bytes, &len)) != 0){
fprintf(stderr, "Error reading page size: %s\n", usbErrorMessage(err));
goto errorOccurred;
}
if(len < sizeof(buffer.info)){
fprintf(stderr, "Not enough bytes in device info report (%d instead of %d)\n", len, (int)sizeof(buffer.info));
err = -1;
goto errorOccurred;
}
pageSize = getUsbInt(buffer.info.pageSize, 2);
deviceSize = getUsbInt(buffer.info.flashSize, 4);
printf("Page size = %d (0x%x)\n", pageSize, pageSize);
printf("Device size = %d (0x%x); %d bytes remaining\n", deviceSize, deviceSize, deviceSize - 2048);
if(endAddress[addressIndex] > deviceSize - 2048){
fprintf(stderr, "Data (%d bytes) exceeds remaining flash size!\n", endAddress[addressIndex]);
err = -1;
goto errorOccurred;
}
if(pageSize < 128){
mask = 127;
}else{
mask = pageSize - 1;
}
for (i = 0; i <= addressIndex; i++)
{
startAddress[i] &= ~mask; /* round down */
endAddress[i] = (endAddress[i] + mask) & ~mask; /* round up */
printf("Uploading %d (0x%x) bytes starting at %d (0x%x)\n", endAddress[i] - startAddress[i], endAddress[i] - startAddress[i], startAddress[i], startAddress[i]);
while(startAddress[i] < endAddress[i]){
buffer.data.reportId = 2;
memcpy(buffer.data.data, dataBuffer + startAddress[i], 128);
setUsbInt(buffer.data.address, startAddress[i], 3);
printf("\r0x%05x ... 0x%05x", startAddress[i], startAddress[i] + (int)sizeof(buffer.data.data));
fflush(stdout);
if((err = usbSetReport(dev, USB_HID_REPORT_TYPE_FEATURE, buffer.bytes, sizeof(buffer.data))) != 0){
//fprintf(stderr, "Error uploading data block: %s\n", usbErrorMessage(err));
continue;
goto errorOccurred;
}
startAddress[i] += sizeof(buffer.data.data);
}
printf("\n");
}
}
if(leaveBootLoader){
/* and now leave boot loader: */
buffer.info.reportId = 1;
usbSetReport(dev, USB_HID_REPORT_TYPE_FEATURE, buffer.bytes, sizeof(buffer.info));
/* Ignore errors here. If the device reboots before we poll the response,
* this request fails.
*/
}
errorOccurred:
if(dev != NULL)
usbCloseDevice(dev);
return err;
}
int main(int argc, char **argv) {
usbDevice_t *dev;
char buffer[REPORT_SIZE]; /* room for dummy report ID */
int err;
if (argc < 2) {
usage(argv[0]);
exit(1);
}
if ((dev = openDevice()) == NULL)
exit(1);
if (strcasecmp(argv[1], "read") == 0) {
int len = sizeof(buffer);
if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
} else {
int16dump(buffer + 1, sizeof(buffer) - 1);
}
} else if (strcasecmp(argv[1], "write") == 0) {
int i, pos;
memset(buffer, 0, sizeof(buffer));
for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos);
}
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else if (strcasecmp(argv[1], "writeinput") == 0) {
int i, pos;
// read initial positions
int len = sizeof(buffer);
if ((err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
}
// int16dump(buffer + 1, sizeof(buffer) - 1);
char input[1000];
int scanfEof;
do {
scanfEof = scanf("%[^\n]%*c", input);
// printf("[%i] %s\n", scanfEof, input);
int16read(buffer + 1, input, sizeof(buffer) - 1);
// int16dump(buffer + 1, sizeof(buffer) - 1);
buffer[0] ++;
int retry = 0;
do {
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}
} while (err != 0 && retry ++ < 3);
if (err != 0) {
// try to reconnect
usbhidCloseDevice(dev);
dev = openDevice();
if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) { /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
}
}
//usleep(20000);
} while (scanfEof > 0);
// for (pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
// pos += int16read(buffer + pos, argv[i], sizeof(buffer) - pos);
// }
// if ((err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
// fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else {
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
// Enum function for building list of devices
static
int enumfunc(USBDEVHANDLE usbh, void *context)
{
static const char vendorName[] = USB_IO16_VENDOR_NAME;
static const char productName[] = USB_IO16_NAME;
int err;
char buffer[128 * sizeof(short)]; // max USB string is 128 UTF-16 chars
int i;
struct usb_io_internal_s *q;
struct enumctx_s *ectx = (struct enumctx_s *)context;
err = usbhidGetVendorString(usbh, buffer, sizeof(buffer));
if ( err )
{
goto next;
}
if ( 0 != strcmp(buffer, vendorName) )
{
goto next;
}
err = usbhidGetProductString(usbh, buffer, sizeof(buffer));
if ( err )
{
goto next;
}
if ( 0 != strcmp(buffer, productName) )
{
goto next;
}
/* Check the unique ID: USB_IO16_ID_STR_LEN bytes at offset 1 (just after the report id) */
err = d16_read_rep(usbh, 0, buffer);
if ( err < 0 )
{
dbgprintf("Error reading report 0: %s\n", usbErrorMessage(err));
goto next;
}
for ( i = 1; i <= USB_IO16_ID_STR_LEN; i++ )
{
unsigned char x = (unsigned char)buffer[i];
if ( x <= 0x20 || x >= 0x7F )
{
dbgprintf("Bad USBIO16 ID string!\n");
goto next;
}
}
dbgprintf("Device %s found: ID=[%.*s]\n", productName, USB_IO16_ID_STR_LEN, &buffer[1]);
// allocate & save info
q = (struct usb_io_internal_s *)calloc(1, sizeof(struct usb_io_internal_s));
if ( !q ) {
dbgprintf("Malloc err\n");
goto next; //$$$ revise
}
/* keep this device, continue */
q->usbh = usbh;
memcpy(q->idstr, &buffer[1], USB_IO16_ID_STR_LEN);
q->type = 16; // put # of pins for now...
q->urdi.serial_number = (void*)&q->idstr[0];
q->urdi.device_path = (char*)g_dummyPath;
if ( !ectx->head ) {
ectx->head = q;
ectx->tail = q;
} else {
ectx->tail->urdi.next = (pusb_io_device_info_t)q;
ectx->tail = q;
}
++ectx->numdevs;
return 1;
next:
/* Continue search */
usbhidCloseDevice(usbh);
return 1;
}
int main(int argc, char **argv)
{
int option = 0; // For getopt temp option
usbDevice_t *dev;
ucp_cmd_t buffer; //room for dummy report ID
int err;
//Initialize globalArgs before we get to work
globalArgs.rFlag = 0; //False
globalArgs.iFlag = 0; //False
globalArgs.wFlag = 0; //False
globalArgs.fFlag = 0; //False
globalArgs.pFlag = 0; //False
globalArgs.hashFlag = 0; //False
globalArgs.kFlag = 0; //False
strncpy(globalArgs.pin,"0000",sizeof(globalArgs.pin)); //Default pin
globalArgs.offset = 0; //Default
globalArgs.size = 512; //Default
globalArgs.fileName = NULL;
globalArgs.file = NULL;
//Check if no arguments at all
if(argc==1) printUsage(argv[0]);
//If there's some argument, parse them
while((option = getopt(argc, argv, "rwif:o:p:Pk:s:h?")) !=-1){
//Check option flags
switch(option){
case 'r':
globalArgs.rFlag = 1; //True
break;
case 'w':
globalArgs.wFlag = 1; //True
break;
case 'i':
globalArgs.iFlag = 1; //True
break;
case 'f':
globalArgs.fFlag = 1; //True
globalArgs.fileName = optarg;
printf("File: %s\n",globalArgs.fileName);
break;
case 'o':
globalArgs.offset = atoi(optarg);
break;
case 'p':
globalArgs.pFlag = 1; //True
strncpy(globalArgs.pin,optarg, sizeof(globalArgs.pin));
break;
case 'P':
globalArgs.hashFlag=1; //True
break;
case 'k':
globalArgs.kFlag = 1; //True
globalArgs.keyboard = optarg;
printf("Keyboard: %s\n", globalArgs.keyboard);
case 's':
globalArgs.size = atoi(optarg);
break;
case 'h':
case '?':
printUsage(argv[0]);
break;
//Unknown flag, don't know what to do
default:
//After getopt prints the error
printUsage(argv[0]);
break;
}
}
//Check that only one action is done at a time
if(globalArgs.rFlag + globalArgs.wFlag + globalArgs.iFlag > 1) printUsage(argv[0]);
//Check that not set PIN and read HASH are given at a time
if(globalArgs.pFlag + globalArgs.hashFlag > 1) printUsage(argv[0]);
//Check that if write from file to device, we are given a file and a pin to encrypt!
if(globalArgs.wFlag && !globalArgs.fFlag) printUsage(argv[0]);
if(globalArgs.wFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Also check pin for read flag
if(globalArgs.rFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Try to open the device, exit if no device present.
if((dev = openDevice()) == NULL) exit(1);
//Clean the buffer before working with it
memset((void*)&buffer, 0, sizeof(buffer));
//Check and perform the desired commands
if(globalArgs.rFlag){ //READ COMMAND
buffer.cmd = UCP_CMD_READ;
deviceRead.offset = globalArgs.offset;
deviceRead.size = globalArgs.size;
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Reading from the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.wFlag){ //WRITE COMMAND
buffer.cmd = UCP_CMD_WRITE;
deviceRead.offset = globalArgs.offset;
deviceRead.size = readXML(globalArgs.fileName);
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Writing to the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.iFlag){ //INFO COMMAND
buffer.cmd = UCP_CMD_INFO;
}else if(globalArgs.hashFlag){ //READ PIN HASH COMMAND
buffer.cmd = UCP_CMD_READ_PIN;
}else if(globalArgs.pFlag){ //SET PIN COMMAND
buffer.cmd = UCP_CMD_SET_PIN;
buffer.buff[0] = 16; //sizeof hash in bytes
}else if(globalArgs.kFlag){
buffer.cmd = UCP_CMD_KEYBOARD;
}
//Add a dummy report ID and send data to device
buffer.reportid = 2;
if((err = usbhidSetReport(dev, (char*)&buffer, sizeof(buffer))) != 0)
fprintf(stderr, "Error sending data to device: %s\n", usbErrorMessage(err));
//Read back report
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 2, (char*)&buffer, &len)) != 0)
{ //... if not OK, print error
fprintf(stderr, "Error reading data from device: %s\n", usbErrorMessage(err));
}
else //... if OK, do things :)
{
fprintf( stderr, "\nMemType CMD Response: ");
hexdump( (void*)&buffer.cmd, sizeof(buffer.cmd)+sizeof(buffer.buff));
fprintf( stderr, "Received data from the device: \n");
switch(buffer.cmd)
{
case UCP_CMD_RESET:
fprintf( stderr, "RESET\n");
break;
case UCP_CMD_READ:
fprintf( stderr, "READ\n");
cmdRead(dev, deviceRead.size);
break;
case UCP_CMD_WRITE:
fprintf( stderr, "WRITE\n");
cmdWrite(dev, flashMemory, deviceRead.size);
fprintf(stderr, "[ENCRYPTION TEST] only hexdump");
break;
case UCP_CMD_SET_PIN:
fprintf(stderr, "SET PIN\n");
cmdSetPin(dev);
break;
case UCP_CMD_READ_PIN:
fprintf(stderr, "READ PIN HASH\n");
cmdReadPinHash(dev);
break;
case UCP_CMD_KEYBOARD:
fprintf(stderr, "KEYBOARD\n");
cmdKeyboard(dev);
break;
case UCP_CMD_DATA:
fprintf( stderr, "DATA\n");
break;
case UCP_CMD_INFO:
fprintf( stderr, "sizeof(info) -> %lu\n", sizeof(deviceInfo));
memcpy((void*)&deviceInfo, (void*)buffer.buff, sizeof(deviceInfo));
/* Call info */
cmdInfo(&deviceInfo);
break;
case UCP_CMD_ERROR: //Wait! the device returned one error!
switch( (unsigned char) buffer.buff[0] )
{
case UCP_ERR:
fprintf( stderr, "GENERIC ERROR\n");
break;
case UCP_ERR_PACKET:
fprintf( stderr, "PACKET ERROR\n");
break;
case UCP_ERR_CMD:
fprintf( stderr, "CMD ERROR\n");
break;
case UCP_ERR_ADDR:
fprintf( stderr, "ADDR ERROR\n");
break;
case UCP_ERR_SIZE:
fprintf( stderr, "SIZE ERRROR\n");
break;
case UCP_ERR_PROTOCOL:
fprintf( stderr, "PROTOCOL ERROR\n");
break;
case UCP_ERR_LOCKED:
fprintf( stderr, "DEVICE LOCKED ERROR\n");
break;
default:
fprintf( stderr, "UNKNOWN ERROR\n");
}
break;
default:
fprintf( stderr, "UNKNOWN CMD ERROR\n");
}
}
usbhidCloseDevice(dev);
return 0;
}
/**
* API: Initialize glcd2usb connection type.
*/
int
glcd2usb_init(Driver *drvthis)
{
PrivateData *p = (PrivateData *)drvthis->private_data;
CT_glcd2usb_data *ctd;
static int didUsbInit = 0;
struct usb_bus *bus;
struct usb_device *dev;
usb_dev_handle *handle = NULL;
int err = 0;
int rval, retries = 3;
int len;
/* Set up connection type low-level functions */
p->glcd_functions->blit = glcd2usb_blit;
p->glcd_functions->close = glcd2usb_close;
p->glcd_functions->set_backlight = glcd2usb_backlight;
p->glcd_functions->poll_keys = glcd2usb_poll_keys;
/* Allocate memory structures */
ctd = (CT_glcd2usb_data *) calloc(1, sizeof(CT_glcd2usb_data));
if (ctd == NULL) {
report(RPT_ERR, "%s/glcd2usb: error allocating connection data", drvthis->name);
return -1;
}
p->ct_data = ctd;
/*
* Try to find and open a device. Only the first device found will be
* recognized.
*/
if (!didUsbInit) {
usb_init();
didUsbInit = 1;
}
usb_find_busses();
usb_find_devices();
for (bus = usb_get_busses(); bus != NULL; bus = bus->next) {
for (dev = bus->devices; dev != NULL; dev = dev->next) {
if (dev->descriptor.idVendor == GLCD2USB_VID
&& dev->descriptor.idProduct == GLCD2USB_PID) {
handle = usb_open(dev);
if (!handle) {
report(RPT_WARNING, "%s/glcd2usb: cannot open USB device: %s",
drvthis->name, usb_strerror());
continue;
}
else {
goto found_dev;
}
}
}
}
found_dev:
if (handle) {
debug(RPT_DEBUG, "%s/glcd2usb: opening device succeeded", drvthis->name);
}
else {
report(RPT_ERR, "%s/glcd2usb: no GLCD2USB device found", drvthis->name);
goto err_out;
}
if (usb_set_configuration(handle, 1))
report(RPT_WARNING, "%s/glcd2usb: could not set configuration: %s",
drvthis->name, usb_strerror());
/*
* now try to claim the interface and detach the kernel HID driver on
* Linux and other operating systems which support the call.
*/
while ((rval = usb_claim_interface(handle, 0)) != 0 && retries-- > 0) {
#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
if (usb_detach_kernel_driver_np(handle, 0) < 0) {
report(RPT_WARNING, "%s/glcd2usb: could not detach kernel HID driver: %s",
drvthis->name, usb_strerror());
}
#endif
}
if (rval != 0)
report(RPT_WARNING, "%s/glcd2usb: could not claim interface", drvthis->name);
/*
* Continue anyway, even if we could not claim the interface. Control
* transfers should still work.
*/
ctd->device = handle;
/* Query device */
memset(&(ctd->tx_buffer), 0, sizeof(ctd->tx_buffer));
len = sizeof(display_info_t);
if ((err = usbGetReport(ctd->device, USB_HID_REPORT_TYPE_FEATURE, GLCD2USB_RID_GET_INFO, ctd->tx_buffer.bytes, &len)) != 0) {
report(RPT_ERR, "%s/glcd2usb: query display parameters: %s",
drvthis->name, usbErrorMessage(err));
goto err_out;
}
if (len < (int)sizeof(ctd->tx_buffer.display_info)) {
report(RPT_ERR, "%s/glcd2usb: incomplete display info report (%d instead of %d)",
drvthis->name, len, (int)sizeof(ctd->tx_buffer.display_info));
goto err_out;
}
if (!(ctd->tx_buffer.display_info.flags & FLAG_VERTICAL_UNITS)) {
report(RPT_ERR, "%s/glcd2usb: unsupported display layout", drvthis->name);
goto err_out;
}
if (ctd->tx_buffer.display_info.width > GLCD_MAX_WIDTH
|| ctd->tx_buffer.display_info.width <= 0
|| ctd->tx_buffer.display_info.height > GLCD_MAX_HEIGHT
|| ctd->tx_buffer.display_info.height <= 0) {
report(RPT_ERR, "%s/glcd2usb: display size out of range: %dx%d",
drvthis->name, ctd->tx_buffer.display_info.width,
ctd->tx_buffer.display_info.height);
goto err_out;
}
p->framebuf.layout = FB_TYPE_VPAGED;
p->framebuf.px_width = ctd->tx_buffer.display_info.width;
p->framebuf.px_height = ctd->tx_buffer.display_info.height;
p->framebuf.size = (p->framebuf.px_height + 7) / 8 * p->framebuf.px_width;
report(RPT_INFO, "%s/glcd2usb: using display size %dx%d", drvthis->name,
ctd->tx_buffer.display_info.width, ctd->tx_buffer.display_info.height);
ctd->paged_buffer = malloc(p->framebuf.size);
if (ctd->paged_buffer == NULL) {
report(RPT_ERR, "%s/glcd2usb: cannot allocate memory", drvthis->name);
goto err_out;
}
memset(ctd->paged_buffer, 0x55, p->framebuf.size);
ctd->dirty_buffer = malloc(p->framebuf.size);
if (ctd->dirty_buffer == NULL) {
report(RPT_ERR, "%s/glcd2usb: cannot allocate memory", drvthis->name);
goto err_out;
}
/* Allocate the display (turn off the 'whirl') */
ctd->tx_buffer.bytes[0] = GLCD2USB_RID_SET_ALLOC;
ctd->tx_buffer.bytes[1] = 1;
if ((err = usbSetReport(ctd->device, USB_HID_REPORT_TYPE_FEATURE, ctd->tx_buffer.bytes, 2)) != 0) {
report(RPT_ERR, "%s/glcd2usb: Error allocating display: %s",
drvthis->name, usbErrorMessage(err));
goto err_out;
}
return 0;
err_out:
glcd2usb_close(p);
return -1;
}
int main(int argc, char **argv)
{
usbDevice_t *dev;
char buffer[65]; /* room for dummy report ID */
int err;
char quiet = 0;
if ( argc < 2) {
usage(argv[0]);
exit(1);
}
if ( (dev = openDevice()) == NULL)
exit(1);
if ( strcasecmp(argv[1], "read") == 0) {
int len = sizeof(buffer);
if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0) {
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
} else {
hexdump(buffer + 1, sizeof(buffer) - 1);
}
} else if ( strcasecmp(argv[1], "write") == 0) {
int i, pos;
bzero(buffer, sizeof(buffer));
for ( pos = 1, i = 2; i < argc && pos < sizeof(buffer); i++) {
pos += hexread(buffer + pos, argv[i], sizeof(buffer) - pos);
}
/*
printf("%d\n",buffer[0]);
printf("%d\n",buffer[1]);
printf("%d\n",buffer[2]);
printf("%d\n",buffer[3]);
*/
//if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) /* add a dummy report ID */
if ( (err = usbhidSetReport(dev, buffer, pos)) != 0) /* add a dummy report ID */
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
} else if ( strcasecmp( argv[1], "interactive" ) == 0 ) {
int t = 0;
for ( t = 0; t < argc; t++ )
if ( strcasecmp(argv[t], "quiet") == 0 )
quiet = 1;
char *help = "q = exit\nr = read\nw = write <Data separated by spaces as decimal or hex (8bit unsigned)>\n";
if ( !quiet )
printf("%s",help);
char exit = 0;
while ( exit != 1 )
{
int nbytes = 350;
if ( !quiet )
printf("> ");
char *input;
input = (char *) malloc (nbytes + 1);
int cnt = getline(&input, &nbytes, stdin);
if ( strncasecmp(input, "q", 1) == 0 )
{
if ( !quiet )
printf("bye.\n");
exit = 1;
} else if ( strncasecmp(input, "r", 1) == 0 ) {
if ( !quiet )
printf("reading...\n");
int len = sizeof(buffer) ;
if ( (err = usbhidGetReport(dev, 0, buffer, &len)) != 0)
{
fprintf(stderr, "error reading data: %s\n", usbErrorMessage(err));
exit = 1;
} else {
hexdump(buffer + 1, sizeof(buffer) - 1);
}
} else if ( strncasecmp(input, "w ", 2) == 0 ) {
int i, pos;
input[0] = 32; // kommando durch leerzeichen ersetzen
bzero(buffer, sizeof(buffer));
if ( !quiet )
printf("sending data... ");
for ( pos = 1, i = 2; i < cnt -1 && pos < sizeof(buffer); i++) {
//printf(">%c\n", input[i]);
pos += hexread( buffer + pos, &input[i], sizeof(buffer) - pos);
}
if ( (err = usbhidSetReport(dev, buffer, sizeof(buffer))) != 0) // add a dummy report ID
{
fprintf(stderr, "error writing data: %s\n", usbErrorMessage(err));
usbhidCloseDevice(dev);
if ( (dev = openDevice()) != NULL)
printf("reconnect...\n");
else
exit = 1;
} else {
if ( !quiet )
printf("ok.\n");
}
} else
printf("%s",help);
}
} else {
usage(argv[0]);
exit(1);
}
usbhidCloseDevice(dev);
return 0;
}
