| /*************************************************************************** |
| * __________ __ ___. |
| * Open \______ \ ____ ____ | | _\_ |__ _______ ___ |
| * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / |
| * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
| * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
| * \/ \/ \/ \/ \/ |
| * $Id$ |
| * |
| * Copyright (C) 2007 Dave Chapman |
| * |
| * USB code based on ifp-line - http://ifp-driver.sourceforge.net |
| * |
| * ifp-line is (C) Pavel Kriz, Jun Yamishiro and Joe Roback and |
| * licensed under the GPL (v2) |
| * |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| ****************************************************************************/ |
| |
| #include <stdio.h> |
| #include <inttypes.h> |
| #include <usb.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| |
| #define MAX_FIRMWARESIZE (10*1024*1024) /* Arbitrary limit (for safety) */ |
| |
| /* For win32 compatibility: */ |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| |
| struct device_t |
| { |
| char* name; |
| char* label; |
| uint16_t productid; |
| uint32_t loadaddr; |
| uint32_t sdcfg; |
| }; |
| |
| static struct device_t devices[] = |
| { |
| {"c100", "Sansa C100 series", 0xb021, 0x20000000, 0x42e97010 }, |
| {"m200", "Sansa M200 series", 0xb021, 0x20000000, 0x42e97010 }, |
| {"cowond2", "Cowon D2", 0xb011, 0x20000000, 0xa2e92010 }, |
| {"cowonj3", "Cowon J3", 0xb057, 0x20000000, 0xaaac7800 }, |
| {"cowons9", "Cowon S9", 0xb057, 0x20000000, 0xa1102800 }, |
| {"iaudio6", "iAudio 6", 0xb021, 0x20000000, 0x62e97010 }, |
| {"iaudio7", "iAudio 7", 0xb021, 0x20000000, 0x62e97010 }, |
| {"logikdax", "Logik DAX 1GB DAB/MP3 player", 0xb021, 0x20000000, 0x52e97410 }, |
| {"x20", "iRiver X20", 0xb051, 0x20000000, 0x02e92010 }, |
| {"ypp2", "Samsung YP-P2", 0xb011, 0x20000000, 0x22e92010 }, |
| {"ypk3", "Samsung YP-K3", 0xb021, 0x20000000, 0x62e92018 }, |
| {"ypt10", "Samsung YP-T10", 0xb011, 0x20000000, 0x62e97080 }, |
| }; |
| |
| #define NUM_DEVICES ((sizeof(devices) / sizeof(struct device_t))) |
| |
| int find_device(char* devname) |
| { |
| unsigned int i = 0; |
| |
| while ((i < NUM_DEVICES) && (strcmp(devices[i].name,devname))) |
| i++; |
| |
| if (i==NUM_DEVICES) |
| return -1; |
| else |
| return i; |
| } |
| |
| void print_devices(void) |
| { |
| unsigned int i; |
| |
| printf("Valid devices are:\n"); |
| for (i=0; i<NUM_DEVICES; i++) |
| { |
| printf(" %10s - %s\n",devices[i].name,devices[i].label); |
| } |
| } |
| |
| /* USB IDs for USB Boot Mode */ |
| #define TCC_VENDORID 0x140e |
| |
| #define TCC_BULK_TO 1 |
| #define TOUT 5000 |
| #define PACKET_SIZE 64 /* Number of bytes to send in one write */ |
| |
| #ifndef MAX |
| #define MAX(a,b) (((a)>(b))?(a):(b)) |
| #endif |
| |
| static void put_int32le(uint32_t x, char* p) |
| { |
| p[0] = x & 0xff; |
| p[1] = (x >> 8) & 0xff; |
| p[2] = (x >> 16) & 0xff; |
| p[3] = (x >> 24) & 0xff; |
| } |
| |
| int upload_app(usb_dev_handle* dh, int device, char* p, int len) |
| { |
| char buf[PACKET_SIZE]; |
| int err; |
| int i; |
| |
| /* Send the header - Destination address, length and SDCFG value */ |
| memset(buf, 0, PACKET_SIZE); |
| |
| put_int32le(0xf0000000, buf); /* Unknown - always the same */ |
| put_int32le(len / PACKET_SIZE, buf + 4); |
| put_int32le(devices[device].loadaddr, buf + 8); |
| put_int32le(devices[device].sdcfg, buf + 12); |
| |
| err = usb_bulk_write(dh, TCC_BULK_TO, buf, PACKET_SIZE, TOUT); |
| |
| if (err < 0) |
| { |
| fprintf(stderr,"[ERR] Error writing header\n"); |
| fprintf(stderr,"[ERR] Bulk write error (%d, %s)\n", err, strerror(-err)); |
| return -1; |
| } |
| |
| /* Now send the data, PACKET_SIZE bytes at a time. */ |
| |
| for (i=0 ; i < (len / PACKET_SIZE) ; i++) |
| { |
| err = usb_bulk_write(dh, TCC_BULK_TO, p, PACKET_SIZE, TOUT); |
| |
| if (err < 0) |
| { |
| fprintf(stderr,"[ERR] Error writing data\n"); |
| fprintf(stderr,"[ERR] Bulk write error (%d, %s)\n", err, strerror(-err)); |
| return -1; |
| } |
| |
| p += PACKET_SIZE; |
| } |
| |
| return 0; |
| } |
| |
| |
| /* The main function */ |
| |
| int do_patching(int device, char* buf, int len) |
| { |
| struct usb_bus *busses; |
| struct usb_bus *bus; |
| struct usb_device *tmp_dev; |
| struct usb_device *dev = NULL; |
| usb_dev_handle *dh; |
| int err; |
| |
| fprintf(stderr,"[INFO] Searching for TCC device...\n"); |
| |
| usb_init(); |
| if(usb_find_busses() < 0) { |
| fprintf(stderr, "[ERR] Could not find any USB busses.\n"); |
| return -1; |
| } |
| |
| if (usb_find_devices() < 0) { |
| fprintf(stderr, "[ERR] USB devices not found(nor hubs!).\n"); |
| return -1; |
| } |
| |
| /* C calling convention, it's not nice to use global stuff */ |
| busses = usb_get_busses(); |
| |
| for (bus = busses; bus; bus = bus->next) { |
| for (tmp_dev = bus->devices; tmp_dev; tmp_dev = tmp_dev->next) { |
| //printf("Found Vendor %04x Product %04x\n",tmp_dev->descriptor.idVendor, tmp_dev->descriptor.idProduct); |
| if (tmp_dev->descriptor.idVendor == TCC_VENDORID && |
| tmp_dev->descriptor.idProduct == devices[device].productid) { |
| |
| dev = tmp_dev; |
| goto found; |
| |
| } |
| } |
| } |
| |
| if (dev == NULL) { |
| fprintf(stderr, "[ERR] TCC device not found.\n"); |
| fprintf(stderr, "[ERR] Ensure your TCC device is in USB boot mode and run tcctool again.\n"); |
| return -1; |
| } |
| |
| found: |
| if ( (dh = usb_open(dev)) == NULL) { |
| fprintf(stderr,"[ERR] Unable to open TCC device.\n"); |
| return -1; |
| } |
| |
| err = usb_set_configuration(dh, 1); |
| |
| if (err < 0) { |
| fprintf(stderr, "[ERR] usb_set_configuration failed (%d)\n", err); |
| usb_close(dh); |
| return -1; |
| } |
| |
| /* "must be called" written in the libusb documentation */ |
| err = usb_claim_interface(dh, dev->config->interface->altsetting->bInterfaceNumber); |
| if (err < 0) { |
| fprintf(stderr, "[ERR] Unable to claim interface (%d)\n", err); |
| usb_close(dh); |
| return -1; |
| } |
| |
| fprintf(stderr,"[INFO] Found TCC device, uploading application.\n"); |
| |
| /* Now we can transfer the application to the device. */ |
| |
| if ( (err = upload_app(dh, device, buf, len)) < 0) |
| { |
| fprintf(stderr,"[ERR] Upload of application failed.\n"); |
| } |
| else |
| { |
| fprintf(stderr,"[INFO] Patching application uploaded successfully!\n"); |
| } |
| |
| /* release claimed interface */ |
| usb_release_interface(dh, dev->config->interface->altsetting->bInterfaceNumber); |
| usb_close(dh); |
| |
| return err < 0 ? -1: 0; |
| } |
| |
| off_t filesize(int fd) { |
| struct stat buf; |
| |
| if (fstat(fd,&buf) < 0) { |
| perror("[ERR] Checking filesize of input file"); |
| return -1; |
| } else { |
| return(buf.st_size); |
| } |
| } |
| |
| void print_usage(void) |
| { |
| printf("Usage: tcctool -d devicename firmware.bin\n"); |
| } |
| |
| int main(int argc, char* argv[]) |
| { |
| char* buf; |
| int n,len,padded_len; |
| int fd; |
| int device; |
| |
| printf("tcctool " VERSION " - (C) 2007-2010 Dave Chapman\n"); |
| printf("This is free software; see the source for copying conditions. There is NO\n"); |
| printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"); |
| |
| if (argc != 4) |
| { |
| print_usage(); |
| print_devices(); |
| return 1; |
| } |
| |
| if (strcmp(argv[1],"-d")) |
| { |
| print_usage(); |
| print_devices(); |
| return 2; |
| } |
| |
| device = find_device(argv[2]); |
| |
| if (device < 0) |
| { |
| printf("[ERR] Unknown device \"%s\"\n",argv[2]); |
| print_devices(); |
| return 3; |
| } |
| |
| printf("[INFO] Using device \"%s\"\n",devices[device].label); |
| fd = open(argv[3], O_RDONLY|O_BINARY); |
| if (fd < 0) |
| { |
| printf("[ERR] Could not open %s\n", argv[3]); |
| return 4; |
| } |
| |
| len = filesize(fd); |
| |
| if (len > MAX_FIRMWARESIZE) |
| { |
| printf("[ERR] Firmware file too big\n"); |
| close(fd); |
| return 5; |
| } |
| |
| /* Round len up to multiple of PACKET_SIZE */ |
| padded_len = (len + PACKET_SIZE) & ~(PACKET_SIZE-1); |
| |
| buf = malloc(padded_len); |
| if (buf == NULL) |
| { |
| printf("[ERR] Could not allocate memory.\n"); |
| close(fd); |
| return 6; |
| } |
| |
| n = read(fd, buf, len); |
| if (n != len) |
| { |
| printf("[ERR] Short read.\n"); |
| close(fd); |
| return 7; |
| } |
| close(fd); |
| |
| if (do_patching(device, buf, padded_len)) |
| { |
| return 8; |
| } |
| |
| return 0; |
| } |