Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
339 lines (276 sloc) 8.84 KB
/***************************************************************************
* __________ __ ___.
* 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;
}
You can’t perform that action at this time.