Index: bootloader/creativezvm.c =================================================================== --- bootloader/creativezvm.c (revision 0) +++ bootloader/creativezvm.c (revision 0) @@ -0,0 +1,500 @@ +/*************************************************************************** +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2008 by Maurus Cuelenaere +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ + +#include "inttypes.h" +#include "string.h" +#include "cpu.h" +#include "system.h" +#include "lcd.h" +#include "kernel.h" +#include "thread.h" +#include "ata.h" +#include "fat.h" +#include "disk.h" +#include "font.h" +#include "adc.h" +#include "backlight.h" +#include "backlight-target.h" +#include "button.h" +#include "panic.h" +#include "power.h" +#include "file.h" +#include "common.h" +#include "rbunicode.h" +#include "usb.h" +#include "spi.h" +#include "uart-target.h" +#include "time.h" +#include "system-arm.h" +#include +#include "sprintf.h" +#include "memory.h" +#include "i2c-dm320.h" +#include "ata-target.h" +#include "timer.h" +#include "usb-target.h" +#include "isp1583.h" + +void i2c_reading(void){ + reset_screen(); + printf("Starting I2C reading..."); + + unsigned char test[16]; + unsigned char msg[40]; + int i, j, ret; + bool flag; + while(true){ + for(i=0;i<0x7F;i++){ //max=7-bit + snprintf(msg, sizeof(char)*20, "0x%x ", i); + lcd_putsxy(260, 0, msg); + lcd_update(); + ret = i2c_read(i, test, 16); + flag = false; + for(j=0;j<16;j++){ + if((test[j]!=0xFF) & (test[j]!=0)) + flag = true; + } + if(flag){ + snprintf(msg, sizeof(char)*40, "%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x", + test[0], test[1], test[2], test[3], test[4], + test[5], test[6], test[7], test[8], test[9], + test[10], test[11], test[12], test[13], test[14], + test[15]); + printf("0x%x: %s [%d]", i, msg, ret); + } + asm volatile("nop\nnop\nnop\nnop\nnop\nnop\nnop\n"); + } + } +} +void display_data(unsigned char* buf, int size) +{ + int l = 0, k, j; + char put[4]; + for(k=0; k < (int)(LCD_HEIGHT/SYSFONT_HEIGHT); k+=SYSFONT_HEIGHT) + { + if(l>size) + break; + for(j=0; j < (int)(LCD_WIDTH/(SYSFONT_WIDTH*2)); j+=SYSFONT_WIDTH*2) + { + if(l>size) + break; + snprintf(put, sizeof(char)*4, "%x", buf[l]); + lcd_putsxy(j, k, put); + l++; + } + } +} + +void do_hdd_browsing(void) +{ + reset_screen(); + printf("Initing HDD..."); + int ret = ata_init(); + if(ret) + printf("ATA error: %d", ret); + ret = disk_init(); + printf("HDD inited... [%d]", ret); + printf("Press BACK to continue..."); + while(button_read_device() ^ BUTTON_BACK); + unsigned short* identify_info; + identify_info = ata_get_identify(); + reset_screen(); + int i; + for(i=0;i<256;i+=16) + printf("%x%x%x%x%x%x%x%x%x%x%x%x%x%x", + identify_info[i], identify_info[i+1], identify_info[i+2], identify_info[i+3],identify_info[i+4], identify_info[i+5], identify_info[i+6], identify_info[i+7], + identify_info[i+8], identify_info[i+9], identify_info[i+10], identify_info[i+11],identify_info[i+12], identify_info[i+13], identify_info[i+14], identify_info[i+15]); + //display_data((unsigned char*)identify_info, 256); + while(button_read_device() ^ BUTTON_CUSTOM); + unsigned char temp[512]; + ata_read_sectors(0, 1, temp); + reset_screen(); + for(i=0;i<512;i+=16) + printf("%x%x%x%x%x%x%x%x%x%x%x%x%x%x", + temp[i], temp[i+1], temp[i+2], temp[i+3],temp[i+4], temp[i+5], temp[i+6], temp[i+7], + temp[i+8], temp[i+9], temp[i+10], temp[i+11],temp[i+12], temp[i+13], temp[i+14], temp[i+15]); + //display_data((unsigned char*)temp, 512); + while(button_read_device() ^ BUTTON_BACK); +#if 0 + reset_screen(); + char msg[30]; + char put[2]; + unsigned char buf[512]; + unsigned int i=0, lasti=0; + int j,k,l; + while(true) + { + if((button_read_device() & BUTTON_RIGHT) && lasti==i) + i++; + else if((button_read_device() & BUTTON_LEFT) && lasti==i) + i--; + if(i != lasti) + { + lasti = i; + ata_read_sectors(i, 0, buf); + l = 0; + for(k=SYSFONT_HEIGHT; k < (int)(LCD_HEIGHT/SYSFONT_HEIGHT); k+=SYSFONT_HEIGHT) + { + if(l>511) + break; + for(j=0; j < (int)(LCD_WIDTH/(SYSFONT_WIDTH*2)); j+=SYSFONT_WIDTH*2) + { + if(l>511) + break; + snprintf(put, sizeof(char)*2, "%x", buf[l]); + lcd_putsxy(j, k, put); + l++; + } + } + snprintf(msg, 30, "%x", i); + lcd_set_foreground(LCD_RGBPACK(255, 0, 0)); + lcd_putsxy(LCD_WIDTH-SYSFONT_WIDTH*4, 0, msg); + lcd_set_foreground(LCD_BLACK); + lcd_update(); + } + ata_spin(); + sleep(1); + } +#endif +} +#define ACCESS_DATA(x) (*(volatile unsigned char *)(address + x)) +void do_data_browsing(unsigned int address) +{ + reset_screen(); + char msg[30]; + char put[4]; + unsigned int i=address, lasti=0; + int j,k,l; + while(true) + { + if((button_read_device() & BUTTON_DOWN) && lasti==i) + i+= LCD_WIDTH/(SYSFONT_WIDTH*2); + else if((button_read_device() & BUTTON_UP) && lasti==i) + i-= LCD_WIDTH/(SYSFONT_WIDTH*2); + else if(button_read_device() & BUTTON_MENU) + { + lcd_set_foreground(LCD_RGBPACK(100, 255, 0)); + while(button_read_device() ^ BUTTON_PLAY) + { + if(button_read_device() & BUTTON_DOWN) + i+= LCD_WIDTH/(SYSFONT_WIDTH*2); + else if(button_read_device() & BUTTON_UP) + i-= LCD_WIDTH/(SYSFONT_WIDTH*2); + snprintf(msg, sizeof(char)*30, "%0x", i); + lcd_putsxy(0, 0, msg); + lcd_update(); + } + lcd_set_foreground(LCD_BLACK); + } + else if(button_read_device() & BUTTON_BACK) + return; + if(iAMOUNT_CHOICES-1) + sel_choice = 0; + lastbtn = btn; + } + lcd_update(); + sleep(1); + } +} + +void read_rtc(void) +{ + unsigned char test[12]; + char temp2[20]; + i2c_read(0x51, test, 12); + snprintf(temp2, sizeof(char)*20, "%x%x%x%x%x%x%x%x%x%x%x%x", + test[0], test[1], test[2], test[3], test[4], + test[5], test[6], test[7], test[8], test[9], + test[10], test[11]); + printf("RTC = %s", temp2); + return; +} +void do_pic(void) +{ + unsigned char test[16]; + char temp2[20]; + int i; + for(i = 0; i < 10; i++) + { + test[0] = i; + i2c_write(0x08, test, 2); + } + return; +} + +void GIO7(void) +{ + printf("GIO7 interrupt..."); + usb_handle_interrupts(); + IO_INTC_IRQ1 = INTR_IRQ1_EXT7; + return; +} + +void main(void) +{ + unsigned char* loadbuffer; + int buffer_size; + int rc; + int(*kernel_entry)(void); + + //power_init(); + system_init(); + kernel_init(); + lcd_init(); + font_init(); + + lcd_enable(true); + lcd_setfont(FONT_SYSFIXED); + reset_screen(); + printf("Rockbox boot loader"); + printf("Version %s", APPSVERSION); + switch (IO_BUSC_REVR) + { + case 0x0010: + printf("DM320 Rev. A"); + break; + case 0x0011: + printf("DM320 Rev. B/C"); + break; + default: + printf("Unknown DM320 Chip ID"); + } + + asm volatile("msr cpsr_c, #0x13"); // Supervisory mode with interrupts(IRQ/FIQ) enabled + + printf("Enabling GIOx interrupts..."); + IO_INTC_EINT1 |= INTR_EINT1_EXT7; + printf("Done"); + + button_init(); + + if(button_read_device() & BUTTON_HOLD) + do_rescue_menu(); + unsigned char test[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + while(1) + { + snprintf(test, sizeof(char)*16, "%x ", button_read_device()); + lcd_putsxy(0, SYSFONT_HEIGHT*7, test); + snprintf(test, sizeof(char)*16, "%x ", current_tick); + lcd_putsxy(0, SYSFONT_HEIGHT*8, test); + lcd_update(); + if(button_read_device() & BUTTON_PLAY) + do_hdd_browsing(); + else if(button_read_device() & BUTTON_MENU) + do_rescue_menu(); + else if(button_read_device() & BUTTON_BACK) + do_pic(); + else if(button_read_device() & BUTTON_CUSTOM) + do_data_browsing(0x90000000); + /*else if(button_read_device() & BUTTON_CUSTOM) + { + reset_screen(); + usb_serial_init(); + while(true) + { + usb_serial_try_put_byte((int)current_tick); + if(button_read_device() & BUTTON_PLAY) + usb_reconnect(); + } + }*/ + yield(); + } + + //adc_init(); + //button_init(); + //backlight_init(); + + + /* Show debug messages if button is pressed */ + // if(button_read_device()) + verbose = true; + +#if 0 + printf("Initing USB..."); + usb_init(); + + char msg[400]; + unsigned int i; + #define TEST_REG(addr) (*(volatile unsigned short *)(addr)) + #define UNK2 TEST_REG(0x4F0000) + #define UNK3 TEST_REG(0x50FFC000) + #define UNK7 TEST_REG(0x50FF600C) + #define MAYBEUSB TEST_REG(0x60FFC0F8) + + const char* const names[] = + { + "IO_GIO_BITSET0","IO_GIO_BITSET1","IO_GIO_BITSET2","IO_GIO_BITCLR0","IO_GIO_BITCLR1","IO_GIO_BITCLR2"//,"IO_GIO_DIR0","IO_GIO_DIR1","IO_GIO_DIR2","IO_GIO_INV0","IO_GIO_INV1","IO_GIO_INV2" + ,"IO_GIO_FSEL0","IO_GIO_FSEL1","IO_GIO_FSEL2","IO_GIO_FSEL3","IO_GIO_FSEL4"//,"IO_GIO_IRQPORT","IO_GIO_IRQEDGE","IO_GIO_CHAT0","IO_GIO_CHAT1","IO_GIO_CHAT2","IO_GIO_NCHAT" + ,"0x4F0000","0x50FFC000","IO_I2C_TXDATA","IO_TIMER1_TMCNT" + //,"IO_CLK_PLLA","IO_CLK_PLLB","IO_CLK_SEL0","IO_CLK_SEL1","IO_CLK_SEL2","IO_CLK_DIV0","IO_CLK_DIV1","IO_CLK_DIV2","IO_CLK_DIV3","IO_CLK_DIV4" + //,"IO_DSPC_HPIB_CONTROL","IO_DSPC_HPIB_STATUS" + ,"IO_CLK_MOD0","IO_CLK_MOD1","IO_CLK_MOD2","current_tick" + ,"IO_INTC_IRQ0","IO_INTC_IRQ1","IO_INTC_IRQ2" + ,"ISP1583_GEN_INT","ISP1583_INIT_MODE","ISP1583_INIT_INTCONF","ISP1583_INIT_OTG","ISP1583_INIT_INTEN" + ,"ISP1583_GEN_UNLCKDEV","MAYBEUSB" + }; + volatile unsigned short * vars[] = + { + &IO_GIO_BITSET0,&IO_GIO_BITSET1,&IO_GIO_BITSET2,&IO_GIO_BITCLR0,&IO_GIO_BITCLR1,&IO_GIO_BITCLR2//,&IO_GIO_DIR0,&IO_GIO_DIR1,&IO_GIO_DIR2,&IO_GIO_INV0,&IO_GIO_INV1,&IO_GIO_INV2 + ,&IO_GIO_FSEL0,&IO_GIO_FSEL1,&IO_GIO_FSEL2,&IO_GIO_FSEL3,&IO_GIO_FSEL4//,&IO_GIO_IRQPORT,&IO_GIO_IRQEDGE,&IO_GIO_CHAT0,&IO_GIO_CHAT1,&IO_GIO_CHAT2,&IO_GIO_NCHAT + ,&UNK2,&UNK3,&IO_I2C_TXDATA,&IO_TIMER1_TMCNT + //,&IO_CLK_PLLA,&IO_CLK_PLLB,&IO_CLK_SEL0,&IO_CLK_SEL1,&IO_CLK_SEL2,&IO_CLK_DIV0,&IO_CLK_DIV1,&IO_CLK_DIV2,&IO_CLK_DIV3,&IO_CLK_DIV4 + //,&IO_DSPC_HPIB_CONTROL,&IO_DSPC_HPIB_STATUS + ,&IO_CLK_MOD0,&IO_CLK_MOD1,&IO_CLK_MOD2,¤t_tick + ,&IO_INTC_IRQ0,&IO_INTC_IRQ1,&IO_INTC_IRQ2 + ,&ISP1583_GEN_INT,&ISP1583_INIT_MODE,&ISP1583_INIT_INTCONF,&ISP1583_INIT_OTG,&ISP1583_INIT_INTEN + ,&ISP1583_GEN_UNLCKDEV,&MAYBEUSB + }; + unsigned int tempval[sizeof(vars)/sizeof(volatile unsigned short*)]; + unsigned int temp; + int flag=0; + reset_screen(); + lcd_set_foreground(LCD_RGBPACK(255,0,0)); + lcd_putsxy(0, LCD_HEIGHT-SYSFONT_HEIGHT, "RED means higher"); + lcd_set_foreground(LCD_RGBPACK(0,255,0)); + lcd_putsxy(100, LCD_HEIGHT-SYSFONT_HEIGHT, "GREEN means lower"); + lcd_set_foreground(LCD_BLACK); + lcd_putsxy(210, LCD_HEIGHT-SYSFONT_HEIGHT, "BLACK means equal"); + while(true) { + for(i=0;itempval[i]) + lcd_set_foreground(LCD_RGBPACK(255,0,0)); + else if(temptempval[i+1]) + lcd_set_foreground(LCD_RGBPACK(255,0,0)); + else if(temp (included via "sha1.h" to define 32 and 8 + * bit unsigned integer types. If your C compiler does not + * support 32 bit unsigned integers, this code is not + * appropriate. + * + * Caveats: + * SHA-1 is designed to work with messages less than 2^64 bits + * long. Although SHA-1 allows a message digest to be generated + * for messages of any number of bits less than 2^64, this + * implementation only works with messages with a length that is + * a multiple of the size of an 8-bit character. + * + */ + +#include "hmac-sha1.h" + +/* + * Define the SHA1 circular left shift macro + */ +#define SHA1CircularShift(bits,word) \ + (((word) << (bits)) | ((word) >> (32-(bits)))) + +/* Local Function Prototyptes */ +void SHA1PadMessage(SHA1Context *); +void SHA1ProcessMessageBlock(SHA1Context *); + +/* + * SHA1Reset + * + * Description: + * This function will initialize the SHA1Context in preparation + * for computing a new SHA1 message digest. + * + * Parameters: + * context: [in/out] + * The context to reset. + * + * Returns: + * sha Error Code. + * + */ +int SHA1Reset(SHA1Context *context) +{ + if (!context) + { + return shaNull; + } + + context->Length_Low = 0; + context->Length_High = 0; + context->Message_Block_Index = 0; + + context->Intermediate_Hash[0] = 0x67452301; + context->Intermediate_Hash[1] = 0xEFCDAB89; + context->Intermediate_Hash[2] = 0x98BADCFE; + context->Intermediate_Hash[3] = 0x10325476; + context->Intermediate_Hash[4] = 0xC3D2E1F0; + + context->Computed = 0; + context->Corrupted = 0; + + return shaSuccess; +} + +/* + * SHA1Result + * + * Description: + * This function will return the 160-bit message digest into the + * Message_Digest array provided by the caller. + * NOTE: The first octet of hash is stored in the 0th element, + * the last octet of hash in the 19th element. + * + * Parameters: + * context: [in/out] + * The context to use to calculate the SHA-1 hash. + * Message_Digest: [out] + * Where the digest is returned. + * + * Returns: + * sha Error Code. + * + */ +int SHA1Result( SHA1Context *context, + uint8_t Message_Digest[SHA1HashSize]) +{ + int i; + + if (!context || !Message_Digest) + { + return shaNull; + } + + if (context->Corrupted) + { + return context->Corrupted; + } + + if (!context->Computed) + { + SHA1PadMessage(context); + for(i=0; i<64; ++i) + { + /* message may be sensitive, clear it out */ + context->Message_Block[i] = 0; + } + context->Length_Low = 0; /* and clear length */ + context->Length_High = 0; + context->Computed = 1; + } + + for(i = 0; i < SHA1HashSize; ++i) + { + Message_Digest[i] = context->Intermediate_Hash[i>>2] + >> 8 * ( 3 - ( i & 0x03 ) ); + } + + return shaSuccess; +} + +/* + * SHA1Input + * + * Description: + * This function accepts an array of octets as the next portion + * of the message. + * + * Parameters: + * context: [in/out] + * The SHA context to update + * message_array: [in] + * An array of characters representing the next portion of + * the message. + * length: [in] + * The length of the message in message_array + * + * Returns: + * sha Error Code. + * + */ +int SHA1Input( SHA1Context *context, + const uint8_t *message_array, + unsigned length) +{ + if (!length) + { + return shaSuccess; + } + + if (!context || !message_array) + { + return shaNull; + } + + if (context->Computed) + { + context->Corrupted = shaStateError; + return shaStateError; + } + + if (context->Corrupted) + { + return context->Corrupted; + } + while(length-- && !context->Corrupted) + { + context->Message_Block[context->Message_Block_Index++] = + (*message_array & 0xFF); + + context->Length_Low += 8; + if (context->Length_Low == 0) + { + context->Length_High++; + if (context->Length_High == 0) + { + /* Message is too long */ + context->Corrupted = 1; + } + } + + if (context->Message_Block_Index == 64) + { + SHA1ProcessMessageBlock(context); + } + + message_array++; + } + + return shaSuccess; +} + +/* + * SHA1ProcessMessageBlock + * + * Description: + * This function will process the next 512 bits of the message + * stored in the Message_Block array. + * + * Parameters: + * None. + * + * Returns: + * Nothing. + * + * Comments: + * Many of the variable names in this code, especially the + * single character names, were used because those were the + * names used in the publication. + * + * + */ +void SHA1ProcessMessageBlock(SHA1Context *context) +{ + const uint32_t K[] = { /* Constants defined in SHA-1 */ + 0x5A827999, + 0x6ED9EBA1, + 0x8F1BBCDC, + 0xCA62C1D6 + }; + int t; /* Loop counter */ + uint32_t temp; /* Temporary word value */ + uint32_t W[80]; /* Word sequence */ + uint32_t A, B, C, D, E; /* Word buffers */ + + /* + * Initialize the first 16 words in the array W + */ + for(t = 0; t < 16; t++) + { + W[t] = context->Message_Block[t * 4] << 24; + W[t] |= context->Message_Block[t * 4 + 1] << 16; + W[t] |= context->Message_Block[t * 4 + 2] << 8; + W[t] |= context->Message_Block[t * 4 + 3]; + } + + for(t = 16; t < 80; t++) + { + W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); + } + + A = context->Intermediate_Hash[0]; + B = context->Intermediate_Hash[1]; + C = context->Intermediate_Hash[2]; + D = context->Intermediate_Hash[3]; + E = context->Intermediate_Hash[4]; + + for(t = 0; t < 20; t++) + { + temp = SHA1CircularShift(5,A) + + ((B & C) | ((~B) & D)) + E + W[t] + K[0]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + for(t = 20; t < 40; t++) + { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + for(t = 40; t < 60; t++) + { + temp = SHA1CircularShift(5,A) + + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + for(t = 60; t < 80; t++) + { + temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]; + E = D; + D = C; + C = SHA1CircularShift(30,B); + B = A; + A = temp; + } + + context->Intermediate_Hash[0] += A; + context->Intermediate_Hash[1] += B; + context->Intermediate_Hash[2] += C; + context->Intermediate_Hash[3] += D; + context->Intermediate_Hash[4] += E; + + context->Message_Block_Index = 0; +} + + +/* + * SHA1PadMessage + * + * Description: + * According to the standard, the message must be padded to an even + * 512 bits. The first padding bit must be a '1'. The last 64 + * bits represent the length of the original message. All bits in + * between should be 0. This function will pad the message + * according to those rules by filling the Message_Block array + * accordingly. It will also call the ProcessMessageBlock function + * provided appropriately. When it returns, it can be assumed that + * the message digest has been computed. + * + * Parameters: + * context: [in/out] + * The context to pad + * ProcessMessageBlock: [in] + * The appropriate SHA*ProcessMessageBlock function + * Returns: + * Nothing. + * + */ + +void SHA1PadMessage(SHA1Context *context) +{ + /* + * Check to see if the current message block is too small to hold + * the initial padding bits and length. If so, we will pad the + * block, process it, and then continue padding into a second + * block. + */ + if (context->Message_Block_Index > 55) + { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 64) + { + context->Message_Block[context->Message_Block_Index++] = 0; + } + + SHA1ProcessMessageBlock(context); + + while(context->Message_Block_Index < 56) + { + context->Message_Block[context->Message_Block_Index++] = 0; + } + } + else + { + context->Message_Block[context->Message_Block_Index++] = 0x80; + while(context->Message_Block_Index < 56) + { + context->Message_Block[context->Message_Block_Index++] = 0; + } + } + + /* + * Store the message length as the last 8 octets + */ + context->Message_Block[56] = context->Length_High >> 24; + context->Message_Block[57] = context->Length_High >> 16; + context->Message_Block[58] = context->Length_High >> 8; + context->Message_Block[59] = context->Length_High; + context->Message_Block[60] = context->Length_Low >> 24; + context->Message_Block[61] = context->Length_Low >> 16; + context->Message_Block[62] = context->Length_Low >> 8; + context->Message_Block[63] = context->Length_Low; + + SHA1ProcessMessageBlock(context); +} +#define SHA_DIGESTSIZE 20 + +#define SHA_BLOCKSIZE 64 + +static void truncate +( + char* d1, /* data to be truncated */ + char* d2, /* truncated data */ + int len /* length in bytes to keep */ +) +{ + int i ; + for (i = 0 ; i < len ; i++) d2[i] = d1[i]; +} + + +/* Function to compute the digest */ +void +hmac_sha +( + char* k, /* secret key */ + int lk, /* length of the key in bytes */ + char* d, /* data */ + int ld, /* length of data in bytes */ + char* out, /* output buffer, at least "t" bytes */ + int t +) +{ + SHA1Context ictx, octx ; + char isha[SHA_DIGESTSIZE], osha[SHA_DIGESTSIZE] ; + char key[SHA_DIGESTSIZE] ; + char buf[SHA_BLOCKSIZE] ; + int i ; + + if (lk > SHA_BLOCKSIZE) { + + SHA1Context tctx ; + + SHA1Reset(&tctx) ; + SHA1Input(&tctx, k, lk) ; + SHA1Result(&tctx, key) ; + + k = key ; + lk = SHA_DIGESTSIZE ; + } + + /**** Inner Digest ****/ + + SHA1Reset(&ictx) ; + + /* Pad the key for inner digest */ + for (i = 0 ; i < lk ; ++i) buf[i] = k[i] ^ 0x36 ; + for (i = lk ; i < SHA_BLOCKSIZE ; ++i) buf[i] = 0x36 ; + + SHA1Input(&ictx, buf, SHA_BLOCKSIZE) ; + SHA1Input(&ictx, d, ld) ; + + SHA1Result(&ictx, isha) ; + + /**** Outter Digest ****/ + + SHA1Reset(&octx) ; + + /* Pad the key for outter digest */ + + + for (i = 0 ; i < lk ; ++i) buf[i] = k[i] ^ 0x5C ; + for (i = lk ; i < SHA_BLOCKSIZE ; ++i) buf[i] = 0x5C ; + + SHA1Input(&octx, buf, SHA_BLOCKSIZE) ; + SHA1Input(&octx, isha, SHA_DIGESTSIZE) ; + + SHA1Result(&octx, osha) ; + + /* truncate and print the results */ + t = t > SHA_DIGESTSIZE ? SHA_DIGESTSIZE : t ; + truncate(osha, out, t) ; + +} Index: tools/hmac-sha1.h =================================================================== --- tools/hmac-sha1.h (revision 0) +++ tools/hmac-sha1.h (revision 0) @@ -0,0 +1,84 @@ +/* + * sha1.h + * + * Description: + * This is the header file for code which implements the Secure + * Hashing Algorithm 1 as defined in FIPS PUB 180-1 published + * April 17, 1995. + * + * Many of the variable names in this code, especially the + * single character names, were used because those were the names + * used in the publication. + * + * Please read the file sha1.c for more information. + * + */ + +#ifndef _SHA1_H_ +#define _SHA1_H_ + +#include +/* + * If you do not have the ISO standard stdint.h header file, then you + * must typdef the following: + * name meaning + * uint32_t unsigned 32 bit integer + * uint8_t unsigned 8 bit integer (i.e., unsigned char) + * int_least16_t integer of >= 16 bits + * + */ + +#ifndef _SHA_enum_ +#define _SHA_enum_ +enum +{ + shaSuccess = 0, + shaNull, /* Null pointer parameter */ + shaInputTooLong, /* input data too long */ + shaStateError /* called Input after Result */ +}; +#endif +#define SHA1HashSize 20 + +/* + * This structure will hold context information for the SHA-1 + * hashing operation + */ +typedef struct SHA1Context +{ + uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */ + + uint32_t Length_Low; /* Message length in bits */ + uint32_t Length_High; /* Message length in bits */ + + /* Index into message block array */ + int_least16_t Message_Block_Index; + uint8_t Message_Block[64]; /* 512-bit message blocks */ + + int Computed; /* Is the digest computed? */ + int Corrupted; /* Is the message digest corrupted? */ +} SHA1Context; + +/* + * Function Prototypes + */ + +int SHA1Reset( SHA1Context *); +int SHA1Input( SHA1Context *, + const uint8_t *, + unsigned int); +int SHA1Result( SHA1Context *, + uint8_t Message_Digest[SHA1HashSize]); + +void +hmac_sha +( + char* k, + int lk, + char* d, + int ld, + char* out, + int t +); + +#endif Index: tools/Makefile =================================================================== --- tools/Makefile (revision 16682) +++ tools/Makefile (working copy) @@ -13,16 +13,18 @@ CLEANALL := scramble descramble iriver sh2d bmp2rb rdf2binary convbdf \ generate_rocklatin mkboot ipod_fw codepages uclpack mi4 gigabeat database \ - lngdump telechips gigabeats mktccboot mknkboot rbspeexenc + lngdump telechips gigabeats creative hmac-sha1 mktccboot mknkboot rbspeexenc all: @echo "Run make in your build directory!" -scramble: scramble.o iriver.o mi4.o gigabeat.o gigabeats.o telechips.o +scramble: scramble.o iriver.o mi4.o gigabeat.o gigabeats.o telechips.o creative.o hmac-sha1.o descramble: descramble.o iriver.o gigabeat.o -scramble.o: scramble.c iriver.h mi4.h gigabeat.h telechips.h +scramble.o: scramble.c iriver.h mi4.h gigabeat.h telechips.h creative.h descramble.o: descramble.c iriver.h gigabeat.h +creative.o: creative.c creative.h +hmac-sha1.o: hmac-sha1.c hmac-sha1.h iriver.o: iriver.c iriver.h gigabeat.o: gigabeat.c gigabeat.h gigabeats.o: gigabeats.c gigabeats.h Index: tools/creative.c =================================================================== --- tools/creative.c (revision 0) +++ tools/creative.c (revision 0) @@ -0,0 +1,159 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include "creative.h" +#include "hmac-sha1.h" +#include +#include + +/* +Create a Zen Vision:M FRESCUE structure file +*/ + + +static int make_ciff_file(char *inbuf, int length, char *outbuf, int device) +{ + memcpy(outbuf, "FFIC", 4); + int2le(length+90, &outbuf[4]); + memcpy(&outbuf[8], "FNIC", 4); + int2le(96, &outbuf[0xC]); + memcpy(&outbuf[0x10], devices[device].cinf, devices[device].cinf_size); + memset(&outbuf[0x10+devices[device].cinf_size], 0, 96 - devices[device].cinf_size); + memcpy(&outbuf[0x70], "ATAD", 4); + int2le(length+32, &outbuf[0x74]); + memcpy(&outbuf[0x78], "H\0j\0u\0k\0e\0b\0o\0x\0\x32\0.\0j\0r\0m", 32); /*Unicode encoded*/ + memcpy(&outbuf[0x98], inbuf, length); + memcpy(&outbuf[0x98+length], "LLUN", 4); + int2le(20, &outbuf[0x98+length+4]); + /* Do checksum */ + char key[20]; + hmac_sha((char*)devices[device].null, strlen(devices[device].null), outbuf, 0x98+length, key, 20); + memcpy(&outbuf[0x98+length+8], key, 20); + return length+0x90+0x1C+8; +} + +static int make_jrm_file(char *inbuf, int length, char *outbuf) +{ + int i; + unsigned int sum = 0; + /* Calculate checksum for later use in header */ + for(i=0; i>16); + + /* Clear the header area to zero */ + memset(outbuf, 0, 0x18); + + /* Header (EDOC) */ + memcpy(outbuf, "EDOC", 4); + /* Total Size */ + int2le(length+0x20, &outbuf[0x4]); + /* 4 bytes of zero */ + + /* Address = 0x900000 */ + int2le(0x900000, &outbuf[0xC]); + /* Size */ + int2le(length, &outbuf[0x10]); + /* Checksum */ + int2le(sum, &outbuf[0x14]); + outbuf[0x16] = 0; + outbuf[0x17] = 0; + /* Data starts here... */ + memcpy(&outbuf[0x18], inbuf, length); + + /* Second block starts here ... */ + /* Address = 0x0 */ + /* Size */ + int2le(0x4, &outbuf[0x18+length+0x4]); + /* Checksum */ + outbuf[0x18+length+0x8] = 0xA9; + outbuf[0x18+length+0x9] = 0xD9; + /* Data: MOV PC, 0x900000 */ + outbuf[0x18+length+0xC] = 0x09; + outbuf[0x18+length+0xD] = 0xF6; + outbuf[0x18+length+0xE] = 0xA0; + outbuf[0x18+length+0xF] = 0xE3; + + return length+0x18+0x10; +} + +int zvm_encode(char *iname, char *oname, int device) +{ + size_t len; + int length; + FILE *file; + unsigned char *outbuf; + unsigned char *buf; + int i; + + file = fopen(iname, "rb"); + if (!file) { + perror(iname); + return -1; + } + fseek(file, 0, SEEK_END); + length = ftell(file); + + fseek(file, 0, SEEK_SET); + + buf = (unsigned char*)malloc(length); + if ( !buf ) { + printf("out of memory!\n"); + return -1; + } + + len = fread(buf, 1, length, file); + if(len < length) { + perror(iname); + return -2; + } + fclose(file); + + outbuf = (unsigned char*)malloc(length+0x300); + if ( !outbuf ) { + free(buf); + printf("out of memory!\n"); + return -1; + } + length = make_jrm_file(buf, length, outbuf); + free(buf); + buf = (unsigned char*)malloc(length+0x200); + memset(buf, 0, length+0x200); + length = make_ciff_file(outbuf, length, buf, device); + free(outbuf); + + file = fopen(oname, "wb"); + if (!file) { + free(buf); + perror(oname); + return -3; + } + + len = fwrite(buf, 1, length, file); + if(len < length) { + free(buf); + perror(oname); + return -4; + } + + free(buf); + + fclose(file); + + return 0; +} Index: tools/creative.h =================================================================== --- tools/creative.h (revision 0) +++ tools/creative.h (revision 0) @@ -0,0 +1,50 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef CREATIVE_H_ +#define CREATIVE_H_ + +enum +{ + ZENVISIONM = 0, + ZENVISIONM60 = 1, + ZENVISION = 2 +}; + +static struct device_info +{ + const char* cinf; /*Must be Unicode encoded*/ + const int cinf_size; + const char* null; +} device_info; + +static const char null_key_v1[] = "CTL:N0MAD|PDE0.SIGN."; +static const char null_key_v2[] = "CTL:N0MAD|PDE0.DPMP."; +static const char null_key_v3[] = "CTL:Z3N07|PDE0.DPMP."; + +static const struct device_info devices[] = +{ + {"C\0r\0e\0a\0t\0i\0v\0e\0 \0Z\0e\0n\0 \0V\0i\0s\0i\0o\0n\0:\0M", 42, null_key_v2}, + {"C\0r\0e\0a\0t\0i\0v\0e\0 \0Z\0e\0n\0 \0V\0i\0s\0i\0o\0n\0:\0M\0 \0G\0o\0!", 50, null_key_v2}, + {"C\0r\0e\0a\0t\0i\0v\0e\0 \0Z\0e\0n\0 \0V\0i\0s\0i\0o\0n\0 \0©\0T\0L", 48, null_key_v2} +}; + +int zvm_encode(char *iname, char *oname, int device); + +#endif /*CREATIVE_H_*/ Index: tools/configure =================================================================== --- tools/configure (revision 16682) +++ tools/configure (working copy) @@ -1403,7 +1403,7 @@ target_id=35 modelname="creativezvm" target="-DCREATIVE_ZVM" - memory=32 # always + memory=64 arm926ejscc bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" bmp2rb_native="$rootdir/tools/bmp2rb -f 4" @@ -1411,10 +1411,10 @@ bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" output="rockbox.zvm" appextra="recorder:gui" - plugins="yes" + plugins="" swcodec="yes" toolset=$gigabeatbitmaptools - boottool="$rootdir/tools/scramble -zvm" + boottool="$rootdir/tools/scramble -creative=zvm" bootoutput="rockbox.zvmboot" # architecture, manufacturer and model for the target-tree build t_cpu="arm" @@ -1931,7 +1931,7 @@ -e "s,@VOICETOOLSET@,${voicetoolset},g" \ -e "s,@LANGS@,${buildlangs},g" \ <>16); - - /* Clear the header area to zero */ - memset(outbuf, 0, 0x18); - - /* Header (EDOC) */ - memcpy((char*)outbuf, "EDOC", 4); - /* Total Size */ - int2le(length+0x20, &outbuf[0x4]); - /* 4 bytes of zero */ - - /* Address = 0x900000 */ - int2le(0x900000, &outbuf[0xC]); - /* Size */ - int2le(length, &outbuf[0x10]); - /* Checksum */ - int2le(sum, &outbuf[0x14]); - outbuf[0x16] = 0; - outbuf[0x17] = 0; - /* Data starts here... */ - - /* Second block starts here ... */ - /* Address = 0x0 */ - /* Size */ - int2le(0x4, &outbuf[0x18+length+0x4]); - /* Checksum */ - outbuf[0x18+length+0x8] = 0xB7; - outbuf[0x18+length+0x9] = 0xD5; - /* Data: LDR PC, =0x900000 */ - outbuf[0x18+length+0xC] = 0x18; - outbuf[0x18+length+0xD] = 0xF0; - outbuf[0x18+length+0xE] = 0x9F; - outbuf[0x18+length+0xF] = 0xE5; - - - file = fopen(oname, "wb"); - if (!file) { - perror(oname); - return -3; - } - - len = fwrite(outbuf, 1, length+0x28, file); - if(len < length+0x18) { - perror(oname); - return -4; - } - - free(outbuf); - - fclose(file); - - return 0; -} - Index: firmware/export/dm320.h =================================================================== --- firmware/export/dm320.h (revision 16682) +++ firmware/export/dm320.h (working copy) @@ -8,6 +8,7 @@ * $Id$ * * Copyright (C) 2007 by Karl Kurbjun + * Copyright (C) 2008 by Maurus Cuelenaere * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. @@ -24,7 +25,7 @@ #ifndef __DM320_H__ #define __DM320_H__ -#define LCD_BUFFER_SIZE (640*480*2) +#define LCD_BUFFER_SIZE (LCD_WIDTH*LCD_HEIGHT*2) #define TTB_SIZE (0x4000) /* must be 16Kb (0x4000) aligned */ #define TTB_BASE ((unsigned int *)(0x04900000 - TTB_SIZE)) /* End of memory */ @@ -96,7 +97,7 @@ #define IO_UART1_SR DM320_REG(0x038C) /* Watchdog Timer */ -#define IO_WATCHDOG_MODE 0x0400 +#define IO_WATCHDOG_MODE DM320_REG(0x0400) #define IO_WATCHDOG_RESET 0x0402 #define IO_WATCHDOG_PRESCALAR 0x0404 #define IO_WATCHDOG_DIVISOR 0x0406 @@ -342,49 +343,49 @@ #define IO_CCD_FMTPTNB 0x0758 /* NTSC/PAL Encoder */ -#define IO_VID_ENC_VMOD 0x0800 -#define IO_VID_ENC_VDCTL 0x0802 -#define IO_VID_ENC_VDPRO 0x0804 -#define IO_VID_ENC_SYNCCTL 0x0806 -#define IO_VID_ENC_HSPLS 0x0808 -#define IO_VID_ENC_VSPLS 0x080A -#define IO_VID_ENC_HINT 0x080C -#define IO_VID_ENC_HSTART 0x080E -#define IO_VID_ENC_HVALID 0x0810 -#define IO_VID_ENC_VINT 0x0812 -#define IO_VID_ENC_VSTART 0x0814 -#define IO_VID_ENC_VVALID 0x0816 -#define IO_VID_ENC_HSDLY 0x0818 -#define IO_VID_ENC_VSDLY 0x081A -#define IO_VID_ENC_YCCTL 0x081C -#define IO_VID_ENC_RGBCTL 0x081E -#define IO_VID_ENC_RGBCLP 0x0820 -#define IO_VID_ENC_LNECTL 0x0822 -#define IO_VID_ENC_CULLLNE 0x0824 -#define IO_VID_ENC_LCDOUT 0x0826 -#define IO_VID_ENC_BRTS 0x0828 -#define IO_VID_ENC_BRTW 0x082A -#define IO_VID_ENC_ACCTL 0x082C -#define IO_VID_ENC_PWMP 0x082E -#define IO_VID_ENC_PWMW 0x0830 -#define IO_VID_ENC_DCLKCTL 0x0832 -#define IO_VID_ENC_DCLKPTN0 0x0834 -#define IO_VID_ENC_DCLKPTN1 0x0836 -#define IO_VID_ENC_DCLKPTN2 0x0838 -#define IO_VID_ENC_DCLKPTN3 0x083A -#define IO_VID_ENC_DCLKPTN0A 0x083C -#define IO_VID_ENC_DCLKPTN1A 0x083E -#define IO_VID_ENC_DCLKPTN2A 0x0840 -#define IO_VID_ENC_DCLKPTN3A 0x0842 -#define IO_VID_ENC_DCLKHS 0x0844 -#define IO_VID_ENC_DCLKHSA 0x0846 -#define IO_VID_ENC_DCLKHR 0x0848 -#define IO_VID_ENC_DCLKVS 0x084A -#define IO_VID_ENC_DCLKVR 0x084C -#define IO_VID_ENC_CAPCTL 0x084E -#define IO_VID_ENC_CAPDO 0x0850 -#define IO_VID_ENC_CAPDE 0x0852 -#define IO_VID_ENC_ATR0 0x0854 +#define IO_VID_ENC_VMOD DM320_REG(0x0800) +#define IO_VID_ENC_VDCTL DM320_REG(0x0802) +#define IO_VID_ENC_VDPRO DM320_REG(0x0804) +#define IO_VID_ENC_SYNCCTL DM320_REG(0x0806) +#define IO_VID_ENC_HSPLS DM320_REG(0x0808) +#define IO_VID_ENC_VSPLS DM320_REG(0x080A) +#define IO_VID_ENC_HINT DM320_REG(0x080C) +#define IO_VID_ENC_HSTART DM320_REG(0x080E) +#define IO_VID_ENC_HVALID DM320_REG(0x0810) +#define IO_VID_ENC_VINT DM320_REG(0x0812) +#define IO_VID_ENC_VSTART DM320_REG(0x0814) +#define IO_VID_ENC_VVALID DM320_REG(0x0816) +#define IO_VID_ENC_HSDLY DM320_REG(0x0818) +#define IO_VID_ENC_VSDLY DM320_REG(0x081A) +#define IO_VID_ENC_YCCTL DM320_REG(0x081C) +#define IO_VID_ENC_RGBCTL DM320_REG(0x081E) +#define IO_VID_ENC_RGBCLP DM320_REG(0x0820) +#define IO_VID_ENC_LNECTL DM320_REG(0x0822) +#define IO_VID_ENC_CULLLNE DM320_REG(0x0824) +#define IO_VID_ENC_LCDOUT DM320_REG(0x0826) +#define IO_VID_ENC_BRTS DM320_REG(0x0828) +#define IO_VID_ENC_BRTW DM320_REG(0x082A) +#define IO_VID_ENC_ACCTL DM320_REG(0x082C) +#define IO_VID_ENC_PWMP DM320_REG(0x082E) +#define IO_VID_ENC_PWMW DM320_REG(0x0830) +#define IO_VID_ENC_DCLKCTL DM320_REG(0x0832) +#define IO_VID_ENC_DCLKPTN0 DM320_REG(0x0834) +#define IO_VID_ENC_DCLKPTN1 DM320_REG(0x0836) +#define IO_VID_ENC_DCLKPTN2 DM320_REG(0x0838) +#define IO_VID_ENC_DCLKPTN3 DM320_REG(0x083A) +#define IO_VID_ENC_DCLKPTN0A DM320_REG(0x083C) +#define IO_VID_ENC_DCLKPTN1A DM320_REG(0x083E) +#define IO_VID_ENC_DCLKPTN2A DM320_REG(0x0840) +#define IO_VID_ENC_DCLKPTN3A DM320_REG(0x0842) +#define IO_VID_ENC_DCLKHS DM320_REG(0x0844) +#define IO_VID_ENC_DCLKHSA DM320_REG(0x0846) +#define IO_VID_ENC_DCLKHR DM320_REG(0x0848) +#define IO_VID_ENC_DCLKVS DM320_REG(0x084A) +#define IO_VID_ENC_DCLKVR DM320_REG(0x084C) +#define IO_VID_ENC_CAPCTL DM320_REG(0x084E) +#define IO_VID_ENC_CAPDO DM320_REG(0x0850) +#define IO_VID_ENC_CAPDE DM320_REG(0x0852) +#define IO_VID_ENC_ATR0 DM320_REG(0x0854) /* Clock Controller */ #define IO_CLK_PLLA DM320_REG(0x0880) @@ -414,102 +415,102 @@ #define IO_CLK_PWM1H DM320_REG(0x08B0) /* Bus Controller */ -#define IO_BUSC_ECR 0x0900 -#define IO_BUSC_EBYTER 0x0902 -#define IO_BUSC_EBITR 0x0904 -#define IO_BUSC_REVR 0x0906 +#define IO_BUSC_ECR DM320_REG(0x0900) +#define IO_BUSC_EBYTER DM320_REG(0x0902) +#define IO_BUSC_EBITR DM320_REG(0x0904) +#define IO_BUSC_REVR DM320_REG(0x0906) /* SDRAM Controller */ -#define IO_SDRAM_SDBUFD0L 0x0980 -#define IO_SDRAM_SDBUFD0H 0x0982 -#define IO_SDRAM_SDBUFD1L 0x0984 -#define IO_SDRAM_SDBUFD1H 0x0986 -#define IO_SDRAM_SDBUFD2L 0x0988 -#define IO_SDRAM_SDBUFD2H 0x098A -#define IO_SDRAM_SDBUFD3L 0x098C -#define IO_SDRAM_SDBUFD3H 0x098E -#define IO_SDRAM_SDBUFD4L 0x0990 -#define IO_SDRAM_SDBUFD4H 0x0992 -#define IO_SDRAM_SDBUFD5L 0x0994 -#define IO_SDRAM_SDBUFD5H 0x0996 -#define IO_SDRAM_SDBUFD6L 0x0998 -#define IO_SDRAM_SDBUFD6H 0x099A -#define IO_SDRAM_SDBUFD7L 0x099C -#define IO_SDRAM_SDBUFD7H 0x099E -#define IO_SDRAM_SDBUFAD1 0x09A0 -#define IO_SDRAM_SDBUFAD2 0x09A2 -#define IO_SDRAM_SDBUFCTL 0x09A4 -#define IO_SDRAM_SDMODE 0x09A6 -#define IO_SDRAM_REFCTL 0x09A8 -#define IO_SDRAM_SDPRTY1 0x09AA -#define IO_SDRAM_SDPRTY2 0x09AC -#define IO_SDRAM_SDPRTY3 0x09AE -#define IO_SDRAM_SDPRTY4 0x09B0 -#define IO_SDRAM_SDPRTY5 0x09B2 -#define IO_SDRAM_SDPRTY6 0x09B4 -#define IO_SDRAM_SDPRTY7 0x09B6 -#define IO_SDRAM_SDPRTY8 0x09B8 -#define IO_SDRAM_SDPRTY9 0x09BA -#define IO_SDRAM_SDPRTY10 0x09BC -#define IO_SDRAM_SDPRTY11 0x09BE -#define IO_SDRAM_SDPRTY12 0x09C0 -#define IO_SDRAM_RSV 0x09C2 -#define IO_SDRAM_SDPRTYON 0x09C4 -#define IO_SDRAM_SDDMASEL 0x09C6 +#define IO_SDRAM_SDBUFD0L DM320_REG(0x0980) +#define IO_SDRAM_SDBUFD0H DM320_REG(0x0982) +#define IO_SDRAM_SDBUFD1L DM320_REG(0x0984) +#define IO_SDRAM_SDBUFD1H DM320_REG(0x0986) +#define IO_SDRAM_SDBUFD2L DM320_REG(0x0988) +#define IO_SDRAM_SDBUFD2H DM320_REG(0x098A) +#define IO_SDRAM_SDBUFD3L DM320_REG(0x098C) +#define IO_SDRAM_SDBUFD3H DM320_REG(0x098E) +#define IO_SDRAM_SDBUFD4L DM320_REG(0x0990) +#define IO_SDRAM_SDBUFD4H DM320_REG(0x0992) +#define IO_SDRAM_SDBUFD5L DM320_REG(0x0994) +#define IO_SDRAM_SDBUFD5H DM320_REG(0x0996) +#define IO_SDRAM_SDBUFD6L DM320_REG(0x0998) +#define IO_SDRAM_SDBUFD6H DM320_REG(0x099A) +#define IO_SDRAM_SDBUFD7L DM320_REG(0x099C) +#define IO_SDRAM_SDBUFD7H DM320_REG(0x099E) +#define IO_SDRAM_SDBUFAD1 DM320_REG(0x09A0) +#define IO_SDRAM_SDBUFAD2 DM320_REG(0x09A2) +#define IO_SDRAM_SDBUFCTL DM320_REG(0x09A4) +#define IO_SDRAM_SDMODE DM320_REG(0x09A6) +#define IO_SDRAM_REFCTL DM320_REG(0x09A8) +#define IO_SDRAM_SDPRTY1 DM320_REG(0x09AA) +#define IO_SDRAM_SDPRTY2 DM320_REG(0x09AC) +#define IO_SDRAM_SDPRTY3 DM320_REG(0x09AE) +#define IO_SDRAM_SDPRTY4 DM320_REG(0x09B0) +#define IO_SDRAM_SDPRTY5 DM320_REG(0x09B2) +#define IO_SDRAM_SDPRTY6 DM320_REG(0x09B4) +#define IO_SDRAM_SDPRTY7 DM320_REG(0x09B6) +#define IO_SDRAM_SDPRTY8 DM320_REG(0x09B8) +#define IO_SDRAM_SDPRTY9 DM320_REG(0x09BA) +#define IO_SDRAM_SDPRTY10 DM320_REG(0x09BC) +#define IO_SDRAM_SDPRTY11 DM320_REG(0x09BE) +#define IO_SDRAM_SDPRTY12 DM320_REG(0x09C0) +#define IO_SDRAM_RSV DM320_REG(0x09C2) +#define IO_SDRAM_SDPRTYON DM320_REG(0x09C4) +#define IO_SDRAM_SDDMASEL DM320_REG(0x09C6) /* EMIF Controller */ -#define IO_EMIF_CS0CTRL1 0x0A00 -#define IO_EMIF_CS0CTRL2 0x0A02 -#define IO_EMIF_CS0CTRL3 0x0A04 -#define IO_EMIF_CS1CTRL1A 0x0A06 -#define IO_EMIF_CS1CTRL1B 0x0A08 -#define IO_EMIF_CS1CTRL2 0x0A0A -#define IO_EMIF_CS2CTRL1 0x0A0C -#define IO_EMIF_CS2CTRL2 0x0A0E -#define IO_EMIF_CS3CTRL1 0x0A10 -#define IO_EMIF_CS3CTRL2 0x0A12 -#define IO_EMIF_CS4CTRL1 0x0A14 -#define IO_EMIF_CS4CTRL2 0x0A16 -#define IO_EMIF_BUSCTRL 0x0A18 -#define IO_EMIF_BUSRLS 0x0A1A -#define IO_EMIF_CFCTRL1 0x0A1C -#define IO_EMIF_CFCTRL2 0x0A1E -#define IO_EMIF_SMCTRL 0x0A20 -#define IO_EMIF_BUSINTEN 0x0A22 -#define IO_EMIF_BUSSTS 0x0A24 -#define IO_EMIF_BUSWAITMD 0x0A26 -#define IO_EMIF_ECC1CP 0x0A28 -#define IO_EMIF_ECC1LP 0x0A2A -#define IO_EMIF_ECC2CP 0x0A2C -#define IO_EMIF_ECC2LP 0x0A2E -#define IO_EMIF_ECC3CP 0x0A30 -#define IO_EMIF_ECC3LP 0x0A32 -#define IO_EMIF_ECC4CP 0x0A34 -#define IO_EMIF_ECC4LP 0x0A36 -#define IO_EMIF_ECC5CP 0x0A38 -#define IO_EMIF_ECC5LP 0x0A3A -#define IO_EMIF_ECC6CP 0x0A3C -#define IO_EMIF_ECC6LP 0x0A3E -#define IO_EMIF_ECC7CP 0x0A40 -#define IO_EMIF_ECC7LP 0x0A42 -#define IO_EMIF_ECC8CP 0x0A44 -#define IO_EMIF_ECC8LP 0x0A46 -#define IO_EMIF_ECCCLR 0x0A48 -#define IO_EMIF_PAGESZ 0x0A4A -#define IO_EMIF_PRIORCTL 0x0A4C -#define IO_EMIF_MGDSPDEST 0x0A4E -#define IO_EMIF_MGDSPADDH 0x0A50 -#define IO_EMIF_MGDSPADDL 0x0A52 -#define IO_EMIF_AHBADDH 0x0A54 -#define IO_EMIF_AHBADDL 0x0A56 -#define IO_EMIF_MTCADDH 0x0A58 -#define IO_EMIF_MTCADDL 0x0A5A -#define IO_EMIF_DMASIZE 0x0A5C -#define IO_EMIF_DMAMTCSEL 0x0A5E -#define IO_EMIF_DMACTL 0x0A60 +#define IO_EMIF_CS0CTRL1 DM320_REG(0x0A00) +#define IO_EMIF_CS0CTRL2 DM320_REG(0x0A02) +#define IO_EMIF_CS0CTRL3 DM320_REG(0x0A04) +#define IO_EMIF_CS1CTRL1A DM320_REG(0x0A06) +#define IO_EMIF_CS1CTRL1B DM320_REG(0x0A08) +#define IO_EMIF_CS1CTRL2 DM320_REG(0x0A0A) +#define IO_EMIF_CS2CTRL1 DM320_REG(0x0A0C) +#define IO_EMIF_CS2CTRL2 DM320_REG(0x0A0E) +#define IO_EMIF_CS3CTRL1 DM320_REG(0x0A10) +#define IO_EMIF_CS3CTRL2 DM320_REG(0x0A12) +#define IO_EMIF_CS4CTRL1 DM320_REG(0x0A14) +#define IO_EMIF_CS4CTRL2 DM320_REG(0x0A16) +#define IO_EMIF_BUSCTRL DM320_REG(0x0A18) +#define IO_EMIF_BUSRLS DM320_REG(0x0A1A) +#define IO_EMIF_CFCTRL1 DM320_REG(0x0A1C) +#define IO_EMIF_CFCTRL2 DM320_REG(0x0A1E) +#define IO_EMIF_SMCTRL DM320_REG(0x0A20) +#define IO_EMIF_BUSINTEN DM320_REG(0x0A22) +#define IO_EMIF_BUSSTS DM320_REG(0x0A24) +#define IO_EMIF_BUSWAITMD DM320_REG(0x0A26) +#define IO_EMIF_ECC1CP DM320_REG(0x0A28) +#define IO_EMIF_ECC1LP DM320_REG(0x0A2A) +#define IO_EMIF_ECC2CP DM320_REG(0x0A2C) +#define IO_EMIF_ECC2LP DM320_REG(0x0A2E) +#define IO_EMIF_ECC3CP DM320_REG(0x0A30) +#define IO_EMIF_ECC3LP DM320_REG(0x0A32) +#define IO_EMIF_ECC4CP DM320_REG(0x0A34) +#define IO_EMIF_ECC4LP DM320_REG(0x0A36) +#define IO_EMIF_ECC5CP DM320_REG(0x0A38) +#define IO_EMIF_ECC5LP DM320_REG(0x0A3A) +#define IO_EMIF_ECC6CP DM320_REG(0x0A3C) +#define IO_EMIF_ECC6LP DM320_REG(0x0A3E) +#define IO_EMIF_ECC7CP DM320_REG(0x0A40) +#define IO_EMIF_ECC7LP DM320_REG(0x0A42) +#define IO_EMIF_ECC8CP DM320_REG(0x0A44) +#define IO_EMIF_ECC8LP DM320_REG(0x0A46) +#define IO_EMIF_ECCCLR DM320_REG(0x0A48) +#define IO_EMIF_PAGESZ DM320_REG(0x0A4A) +#define IO_EMIF_PRIORCTL DM320_REG(0x0A4C) +#define IO_EMIF_MGDSPDEST DM320_REG(0x0A4E) +#define IO_EMIF_MGDSPADDH DM320_REG(0x0A50) +#define IO_EMIF_MGDSPADDL DM320_REG(0x0A52) +#define IO_EMIF_AHBADDH DM320_REG(0x0A54) +#define IO_EMIF_AHBADDL DM320_REG(0x0A56) +#define IO_EMIF_MTCADDH DM320_REG(0x0A58) +#define IO_EMIF_MTCADDL DM320_REG(0x0A5A) +#define IO_EMIF_DMASIZE DM320_REG(0x0A5C) +#define IO_EMIF_DMAMTCSEL DM320_REG(0x0A5E) +#define IO_EMIF_DMACTL DM320_REG(0x0A60) /* Preivew Engine */ -#define IO_PREV_ENG_PVEN 0x0A80 +#define IO_PREV_ENG_PVEN DM320_REG(0x0A80) #define IO_PREV_ENG_PVSET1 0x0A82 #define IO_PREV_ENG_RADRH 0x0A84 #define IO_PREV_ENG_RADRL 0x0A86 @@ -640,10 +641,58 @@ #define IO_ATM_ 0x0D00 /* I2C */ -#define IO_I2C_TXDATA 0x0D80 -#define IO_I2C_RXDATA 0x0D82 -#define IO_I2C_SCS 0x0D84 +#define IO_I2C_TXDATA DM320_REG(0x0D80) +#define IO_I2C_RXDATA DM320_REG(0x0D82) +#define IO_I2C_SCS DM320_REG(0x0D84) +/* VLYNQ */ +#define VL_ID DM320_REG(0x30300) +#define VL_CTRL DM320_REG(0x30304) +#define VL_STAT DM320_REG(0x30308) +#define VL_INTPRI DM320_REG(0x3030c) +#define VL_INTST DM320_REG(0x30310) +#define VL_INTPND DM320_REG(0x30314) +#define VL_INTPTR DM320_REG(0x30318) +#define VL_TXMAP DM320_REG(0x3031c) +#define VL_RXMAPSZ1 DM320_REG(0x30320) +#define VL_RXMAPOF1 DM320_REG(0x30324) +#define VL_RXMAPSZ2 DM320_REG(0x30328) +#define VL_RXMAPOF2 DM320_REG(0x3032c) +#define VL_RXMAPSZ3 DM320_REG(0x30330) +#define VL_RXMAPOF3 DM320_REG(0x30334) +#define VL_RXMAPSZ4 DM320_REG(0x30338) +#define VL_RXMAPOF4 DM320_REG(0x3033c) +#define VL_CHIPVER DM320_REG(0x30340) +#define VL_AUTONEG DM320_REG(0x30344) +#define VL_MANNEG DM320_REG(0x30348) +#define VL_NEGSTAT DM320_REG(0x3034c) +#define VL_ENDIAN DM320_REG(0x3035c) +#define VL_INTVEC30 DM320_REG(0x30360) +#define VL_INTVEC74 DM320_REG(0x30364) +#define VL_ID_R DM320_REG(0x30380) +#define VL_CTRL_R DM320_REG(0x30384) +#define VL_STAT_R DM320_REG(0x30388) +#define VL_INTPRI_R DM320_REG(0x3038c) +#define VL_INTST_R DM320_REG(0x30390) +#define VL_INTPND_R DM320_REG(0x30394) +#define VL_INTPTR_R DM320_REG(0x30398) +#define VL_TXMAP_R DM320_REG(0x3039c) +#define VL_RXMAPSZ1_R DM320_REG(0x303a0) +#define VL_RXMAPOF1_R DM320_REG(0x303a4) +#define VL_RXMAPSZ2_R DM320_REG(0x303a8) +#define VL_RXMAPOF2_R DM320_REG(0x303ac) +#define VL_RXMAPSZ3_R DM320_REG(0x303b0) +#define VL_RXMAPOF3_R DM320_REG(0x303b4) +#define VL_RXMAPSZ4_R DM320_REG(0x303b8) +#define VL_RXMAPOF4_R DM320_REG(0x303bc) +#define VL_CHIPVER_R DM320_REG(0x303c0) +#define VL_AUTONEG_R DM320_REG(0x303c4) +#define VL_MANNEG_R DM320_REG(0x303c8) +#define VL_NEGSTAT_R DM320_REG(0x303cc) +#define VL_ENDIAN_R DM320_REG(0x303dc) +#define VL_INTVEC30_R DM320_REG(0x303e0) +#define VL_INTVEC74_R DM320_REG(0x303e4) + /* Taken from linux/include/asm-arm/arch-itdm320/irqs.h * * Copyright (C) 1999 ARM Limited @@ -738,5 +787,116 @@ #define CONFIG_TIMER3_TMMD_TRG_READY 0x1000 #define CONFIG_TIMER3_TMMD_SIGNAL 0x2000 +/* + * IO_MODx bits + */ +#define CLK_MOD0_HPIB (1 << 11) +#define CLK_MOD0_DSP (1 << 10) +#define CLK_MOD0_EXTHOST (1 << 9) +#define CLK_MOD0_SDRAMC (1 << 8) +#define CLK_MOD0_EMIF (1 << 7) +#define CLK_MOD0_INTC (1 << 6) +#define CLK_MOD0_AIM (1 << 5) +#define CLK_MOD0_E2ICE (1 << 4) +#define CLK_MOD0_ETM (1 << 3) +#define CLK_MOD0_AHB (1 << 2) +#define CLK_MOD0_BUSC (1 << 1) +#define CLK_MOD0_ARM (1 << 0) +#define CLK_MOD1_CPBUS (1 << 11) +#define CLK_MOD1_SEQ (1 << 10) +#define CLK_MOD1_DCT (1 << 9) +#define CLK_MOD1_IMGBUF (1 << 8) +#define CLK_MOD1_IMX (1 << 7) +#define CLK_MOD1_VLCD (1 << 6) +#define CLK_MOD1_DAC (1 << 5) +#define CLK_MOD1_VENC (1 << 4) +#define CLK_MOD1_OSD (1 << 3) +#define CLK_MOD1_PRV (1 << 2) +#define CLK_MOD1_H3A (1 << 1) +#define CLK_MOD1_CCDC (1 << 0) + +#define CLK_MOD2_TEST (1 << 15) +#define CLK_MOD2_MS (1 << 14) +#define CLK_MOD2_VLYNQ (1 << 13) +#define CLK_MOD2_I2C (1 << 12) +#define CLK_MOD2_MMC (1 << 11) +#define CLK_MOD2_SIF1 (1 << 10) +#define CLK_MOD2_SIF0 (1 << 9) +#define CLK_MOD2_UART1 (1 << 8) +#define CLK_MOD2_UART0 (1 << 7) +#define CLK_MOD2_USB (1 << 6) +#define CLK_MOD2_GIO (1 << 5) +#define CLK_MOD2_CCDTMR1 (1 << 4) +#define CLK_MOD2_CCDTMR0 (1 << 3) +#define CLK_MOD2_TMR1 (1 << 2) +#define CLK_MOD2_TMR0 (1 << 1) +#define CLK_MOD2_WDT (1 << 0) + +/* + * IO_EINTx bits + */ +#define INTR_EINT0_USB1 (1 << 15) +#define INTR_EINT0_USB0 (1 << 14) +#define INTR_EINT0_UART1 (1 << 13) +#define INTR_EINT0_UART0 (1 << 12) +#define INTR_EINT0_IMGBUF (1 << 11) +#define INTR_EINT0_EXTHOST (1 << 10) +#define INTR_EINT0_SP1 (1 << 9) +#define INTR_EINT0_SP0 (1 << 8) +#define INTR_EINT0_VENC (1 << 7) +#define INTR_EINT0_CCDWEN (1 << 6) +#define INTR_EINT0_CCDVD1 (1 << 5) +#define INTR_EINT0_CCDVD0 (1 << 4) +#define INTR_EINT0_TMR3 (1 << 3) +#define INTR_EINT0_TMR2 (1 << 2) +#define INTR_EINT0_TMR1 (1 << 1) +#define INTR_EINT0_TMR0 (1 << 0) + +#define INTR_EINT1_EXT10 (1 << 15) +#define INTR_EINT1_EXT9 (1 << 14) +#define INTR_EINT1_EXT8 (1 << 13) +#define INTR_EINT1_EXT7 (1 << 12) +#define INTR_EINT1_EXT6 (1 << 11) +#define INTR_EINT1_EXT5 (1 << 10) +#define INTR_EINT1_EXT4 (1 << 9) +#define INTR_EINT1_EXT3 (1 << 8) +#define INTR_EINT1_EXT2 (1 << 7) +#define INTR_EINT1_EXT1 (1 << 6) +#define INTR_EINT1_EXT0 (1 << 5) +#define INTR_EINT1_MMCSDMS1 (1 << 4) +#define INTR_EINT1_MMCSDMS0 (1 << 3) +#define INTR_EINT1_MTC1 (1 << 2) +#define INTR_EINT1_MTC0 (1 << 1) +#define INTR_EINT1_VLYNQ (1 << 0) + +#define INTR_EINT2_RSVINT (1 << 13) +#define INTR_EINT2_ARMCOMTX (1 << 12) +#define INTR_EINT2_ARMCOMRX (1 << 11) +#define INTR_EINT2_E2ICE (1 << 10) +#define INTR_EINT2_INTRC (1 << 9) +#define INTR_EINT2_I2C (1 << 8) +#define INTR_EINT2_WDT (1 << 7) +#define INTR_EINT2_PREV1 (1 << 6) +#define INTR_EINT2_PREV0 (1 << 5) +#define INTR_EINT2_EXT15 (1 << 4) +#define INTR_EINT2_EXT14 (1 << 3) +#define INTR_EINT2_EXT13 (1 << 2) +#define INTR_EINT2_EXT12 (1 << 1) +#define INTR_EINT2_EXT11 (1 << 0) + +/* +* IO_IRQx bits +*/ +#define INTR_IRQ0_TMR0 INTR_EINT0_TMR0 +#define INTR_IRQ0_TMR1 INTR_EINT0_TMR1 +#define INTR_IRQ0_TMR2 INTR_EINT0_TMR2 +#define INTR_IRQ0_TMR3 INTR_EINT0_TMR3 +#define INTR_IRQ0_UART1 INTR_EINT0_UART1 +#define INTR_IRQ0_CCDVD1 INTR_EINT0_CCDVD1 + +#define INTR_IRQ1_EXT0 INTR_EINT1_EXT0 +#define INTR_IRQ1_EXT2 INTR_EINT1_EXT2 +#define INTR_IRQ1_EXT7 INTR_EINT1_EXT7 + #endif Index: firmware/export/config-creativezvm.h =================================================================== --- firmware/export/config-creativezvm.h (revision 16682) +++ firmware/export/config-creativezvm.h (working copy) @@ -62,15 +62,10 @@ /* Define this if your LCD can be enabled/disabled */ #define HAVE_LCD_ENABLE -#define LCD_REMOTE_PIXELFORMAT VERTICAL_PACKING - -#define MIN_REMOTE_CONTRAST_SETTING 0 -#define MAX_REMOTE_CONTRAST_SETTING 15 -#define DEFAULT_REMOTE_CONTRAST_SETTING 7 - #define CONFIG_KEYPAD MROBE500_PAD +#define HAS_BUTTON_HOLD +#define HAVE_HEADPHONE_DETECTION //#define HAVE_TOUCHPAD -#define HAVE_BUTTON_DATA /* Define this if you do software codec */ #define CONFIG_CODEC SWCODEC @@ -81,7 +76,7 @@ /* Define this for LCD backlight available */ //#define HAVE_BACKLIGHT -#define HAVE_BACKLIGHT_BRIGHTNESS +//#define HAVE_BACKLIGHT_BRIGHTNESS /* Main LCD backlight brightness range and defaults */ #define MIN_BRIGHTNESS_SETTING 0 @@ -90,7 +85,8 @@ #define DEFAULT_DIMNESS_SETTING 22 /* OF "most dim" */ /* Define this if you have a software controlled poweroff */ -#define HAVE_SW_POWEROFF +//#define HAVE_SW_POWEROFF +//TODO: enable this back /* The number of bytes reserved for loadable codecs */ #define CODEC_SIZE 0x80000 @@ -99,13 +95,13 @@ #define PLUGIN_BUFFER_SIZE 0x100000 /* Define this if you have the TLV320 audio codec */ -//#define HAVE_TLV320 +#define HAVE_TLV320 -/* Define this if you want to use the adaptive bass capibility of the 8751 */ -/* #define USE_ADAPTIVE_BASS */ +/* TLV320 has no tone controls, so we use the software ones */ +#define HAVE_SW_TONE_CONTROLS #define HW_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | \ - SAMPR_CAP_11) + SAMPR_CAP_11) #define BATTERY_CAPACITY_DEFAULT 1100 /* default battery capacity */ #define BATTERY_CAPACITY_MIN 500 /* min. capacity selectable */ @@ -124,8 +120,7 @@ /* Define this if you have a Texas Instruments TSC2100 touch screen */ //#define HAVE_TSC2100 -/* Define this if you want to use coldfire's i2c interface */ -//#define CONFIG_I2C I2C_S3C2440 +#define CONFIG_USBOTG USBOTG_ISP1583 /* define this if the hardware can be powered off while charging */ #define HAVE_POWEROFF_WHILE_CHARGING @@ -158,4 +153,15 @@ #define BOOTFILE "rockbox." BOOTFILE_EXT #define BOOTDIR "/.rockbox" +//DEBUGGING! +#define THREAD_EXTRA_CHECKS 1 +#define DEBUG 1 +#define debug(msg) printf(msg) +#define BUTTON_DEBUG + +#define DO_THREAD_TEST + + +//Uncomment next line to make this build Zen Vision compatible +//#define ZEN_VISION #endif Index: firmware/export/config.h =================================================================== --- firmware/export/config.h (revision 16682) +++ firmware/export/config.h (working copy) @@ -168,6 +168,7 @@ /* USB On-the-go */ #define USBOTG_ISP1362 1362 /* iriver H300 */ +#define USBOTG_ISP1538 1538 /* Creative Zen Vision:M */ #define USBOTG_M5636 5636 /* iAudio X5 */ #define USBOTG_ARC 5020 /* PortalPlayer 502x */ Index: firmware/export/isp1583.h =================================================================== --- firmware/export/isp1583.h (revision 0) +++ firmware/export/isp1583.h (revision 0) @@ -0,0 +1,47 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ +#ifndef ISP1583_H +#define ISP1583_H + +/* Initialization registers */ +#define ISP1583_INIT_ADDRESS (*((volatile unsigned char*)(ISP1583_IOBASE+0x0))) +#define ISP1583_INIT_MODE (*((volatile unsigned char*)(ISP1583_IOBASE+0xC))) +#define ISP1583_INIT_INTCONF (*((volatile unsigned char*)(ISP1583_IOBASE+0x10))) +#define ISP1583_INIT_OTG (*((volatile unsigned char*)(ISP1583_IOBASE+0x12))) +#define ISP1583_INIT_INTEN (*((volatile unsigned int*)(ISP1583_IOBASE+0x14))) +/* Data flow registers */ +#define ISP1583_DFLOW_EPINDEX (*((volatile unsigned char*)(ISP1583_IOBASE+0xC2))) +#define ISP1583_DFLOW_CTRLFUN (*((volatile unsigned char*)(ISP1583_IOBASE+0x28))) +#define ISP1583_DFLOW_DATA (*((volatile unsigned short*)(ISP1583_IOBASE+0x20))) +#define ISP1583_DFLOW_BUFLEN (*((volatile unsigned short*)(ISP1583_IOBASE+0x1C))) +#define ISP1583_DFLOW_BUFSTAT (*((volatile unsigned char*)(ISP1583_IOBASE+0x1E))) +#define ISP1583_DFLOW_MAXPKSZ (*((volatile unsigned short*)(ISP1583_IOBASE+0x04))) +#define ISP1583_DFLOW_EPTYPE (*((volatile unsigned short*)(ISP1583_IOBASE+0x08))) +/* DMA registers */ +/* General registers */ +#define ISP1583_GEN_INT (*((volatile unsigned int*)(ISP1583_IOBASE+0x18))) +#define ISP1583_GEN_CHIPID (*((volatile unsigned int*)(ISP1583_IOBASE+0x70))) //Size=3 bytes +#define ISP1583_GEN_FRAMEN0 (*((volatile unsigned short*)(ISP1583_IOBASE+0x74))) +#define ISP1583_GEN_SCRATCH (*((volatile unsigned short*)(ISP1583_IOBASE+0x78))) +#define ISP1583_GEN_UNLCKDEV (*((volatile unsigned short*)(ISP1583_IOBASE+0x7C))) +#define ISP1583_GEN_TSTMOD (*((volatile unsigned char*)(ISP1583_IOBASE+0x84))) + +#define ISP1583_UNLOCK_CODE 0xaa37 + +#endif Index: firmware/panic.c =================================================================== --- firmware/panic.c (revision 16682) +++ firmware/panic.c (working copy) @@ -124,6 +124,8 @@ #elif CONFIG_KEYPAD == ONDIO_PAD if (!(PCDR & 0x0008)) #endif /* CONFIG_KEYPAD */ +#elif defined(CREATIVE_ZVM) + if(false) #endif /* CPU */ system_reboot(); #endif /* !SIMULATOR */ Index: firmware/SOURCES =================================================================== --- firmware/SOURCES (revision 16682) +++ firmware/SOURCES (working copy) @@ -242,7 +242,9 @@ #endif #else /* !defined(HAVE_USBSTACK) */ #if CONFIG_USBOTG == USBOTG_ISP1362 -drivers/isp1362.c +drivers/isp1362.c +#elif CONFIG_USBOTG == USBOTG_ISP1583 +drivers/isp1583.c #elif CONFIG_USBOTG == USBOTG_M5636 drivers/m5636.c #endif @@ -683,6 +685,26 @@ #endif /* SIMULATOR */ #endif /* MROBE_500 */ +#ifdef CREATIVE_ZVM +#ifndef SIMULATOR +target/arm/lcd-as-memframe.S +target/arm/mmu-arm.c +target/arm/tms320dm320/creative-zvm/lcd-creativezvm.c +target/arm/tms320dm320/creative-zvm/ata-creativezvm.c +target/arm/tms320dm320/creative-zvm/pic-creativezvm.c +target/arm/tms320dm320/creative-zvm/usb-creativezvm.c +target/arm/tms320dm320/creative-zvm/usb-test.c +target/arm/tms320dm320/debug-dm320.c +target/arm/tms320dm320/i2c-dm320.c +target/arm/tms320dm320/kernel-dm320.c +target/arm/tms320dm320/spi-dm320.c +target/arm/tms320dm320/system-dm320.c +target/arm/tms320dm320/timer-dm320.c +target/arm/tms320dm320/uart-dm320.c +target/arm/tms320dm320/dsp-dm320.c +#endif /* SIMULATOR */ +#endif /* CREATIVE_ZVM */ + #ifdef MROBE_100 #ifndef SIMULATOR drivers/sw_i2c.c Index: firmware/target/arm/tms320dm320/uart-dm320.c =================================================================== --- firmware/target/arm/tms320dm320/uart-dm320.c (revision 16682) +++ firmware/target/arm/tms320dm320/uart-dm320.c (working copy) @@ -36,11 +36,11 @@ void uart_init(void) { // 8-N-1 - IO_UART1_MSR=0x8000; - IO_UART1_BRSR=0x0057; + IO_UART1_MSR = 0x8000; + IO_UART1_BRSR = 0x0057; IO_UART1_RFCR = 0x8010; /* Trigger later */ /* gio 27 is input, uart1 rx - gio 28 is output, uart1 tx */ + gio 28 is output, uart1 tx */ IO_GIO_DIR1 |= (1<<11); /* gio 27 */ IO_GIO_DIR1 &= ~(1<<12); /* gio 28 */ @@ -50,7 +50,7 @@ uart1_recieve_write=0; /* Enable the interrupt */ - IO_INTC_EINT0 |= (1< RECIEVE_RING_SIZE) - panicf("UART1 buffer overflow"); + panicf("UART1 buffer overflow"); else { if(uart1_recieve_write==RECIEVE_RING_SIZE) - uart1_recieve_write=0; + uart1_recieve_write=0; uart1_recieve_buffer_ring[uart1_recieve_write] = IO_UART1_DTRR & 0xff; uart1_recieve_write++; @@ -129,5 +129,5 @@ } } - IO_INTC_IRQ0 = (1< ) \___| < | \_\ ( <_> > < < - * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ - * \/ \/ \/ \/ \/ - * $Id$ - * - * Copyright (C) 2007 by Karl Kurbjun - * - * All files in this archive are subject to the GNU General Public License. - * See the file COPYING in the source tree root for full license agreement. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - ****************************************************************************/ +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2008 by Maurus Cuelenaere +* +* DM320 I²C driver +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ #include "system.h" +#include "thread.h" #include "i2c-dm320.h" -#if 0 -static int i2c_getack(void) +#define I2C_SCS_COND_START 0x0001 +#define I2C_SCS_COND_STOP 0x0002 +#define I2C_SCS_XMIT 0x0004 + +#define I2C_TX_ACK (1 << 20) + +static struct mutex i2c_mtx; + +static inline void i2c_begin(void) { - return 0; + mutex_lock(&i2c_mtx); } -static int i2c_start(void) +static inline void i2c_end(void) { - return 0; + mutex_unlock(&i2c_mtx); } -static void i2c_stop(void) +static inline bool i2c_getack(void) { + return (IO_I2C_RXDATA & 0x100)>>8; +} +#define WAIT_FOR_I2C if(IO_I2C_SCS & 0x4){ \ + while(IO_I2C_SCS & 0x4) { \ + asm volatile("nop"); \ + } \ + } \ + +static inline void i2c_start(void) +{ + IO_I2C_SCS |= I2C_SCS_XMIT; + return; } -static int i2c_outb(unsigned char byte) +int i2c_write(unsigned short address, const unsigned char *buf, int count) { - (void) byte; - return 0; + int i; + int ret=0; + i2c_begin(); + IO_I2C_TXDATA = ( (address << 1) & 0xFF ) | (address>0x7F ? 0 : 1 ) | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //clear conditions + IO_I2C_SCS |= I2C_SCS_COND_START; // write 'start condition' + i2c_start(); + WAIT_FOR_I2C; + /* experimental */ + if(address>0x7F){ // check if it is 10-bit instead of 7-bit + IO_I2C_TXDATA = ( (address >> 7) & 0xFF) | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //normal transfer + i2c_start(); + WAIT_FOR_I2C; + IO_I2C_TXDATA = ( (address << 1) & 0xFF) | 1 | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //clear conditions + IO_I2C_SCS |= I2C_SCS_COND_START; //write 'start condition' + i2c_start(); + WAIT_FOR_I2C; + } + + for(i=0; i0x7F ? 0 : 1 ) | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //clear conditions + IO_I2C_SCS |= I2C_SCS_COND_START; // write 'start condition' + i2c_start(); + WAIT_FOR_I2C; + /* experimental */ + if(address>0x7F){ // check if it is 10-bit instead of 7-bit + IO_I2C_TXDATA = ( (address >> 7) & 0xFF ) | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //normal transfer + i2c_start(); + WAIT_FOR_I2C; + IO_I2C_TXDATA = ( (address << 1) & 0xFF ) | 1 | I2C_TX_ACK; + IO_I2C_SCS &= ~0x3; //clear conditions + IO_I2C_SCS |= I2C_SCS_COND_START; //write 'start condition' + i2c_start(); + WAIT_FOR_I2C; + } + + for(i=0; i> 8; + } + IO_I2C_SCS &= ~0x3; //clear conditions + IO_I2C_SCS |= I2C_SCS_COND_STOP; //write 'stop condition' + i2c_start(); + WAIT_FOR_I2C; + i2c_end(); + return ack; } void i2c_init(void) { - +#if 0 //TODO: mimic OF I2C clock settings; currently this is done by the bootloader + IO_CLK_MOD2 &= ~CLK_MOD2_I2C; // turn I²C clock off (just to be sure) + IO_CLK_LPCTL1 &= ~1; // set Powerdown mode to off + IO_CLK_SEL0 &= ~0x800; // set I²C clock to PLLA + IO_CLK_DIV4 &= ~0x1F; // I²C clock division = 1 + IO_CLK_MOD2 |= CLK_MOD2_I2C; // enable I²C clock +#endif + IO_I2C_SCS &= ~0x8; //set clock to 100 kHz + IO_INTC_EINT2 &= ~INTR_EINT2_I2C; // disable I²C interrupt } Index: firmware/target/arm/tms320dm320/timer-dm320.c =================================================================== --- firmware/target/arm/tms320dm320/timer-dm320.c (revision 16682) +++ firmware/target/arm/tms320dm320/timer-dm320.c (working copy) @@ -8,6 +8,7 @@ * $Id$ * * Copyright (C) 2007 by Karl Kurbjun +* Copyright (C) 2008 by Maurus Cuelenaere * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. @@ -24,12 +25,12 @@ #include "logf.h" /* GPB0/TOUT0 should already have been configured as output so that pin - should not be a functional pin and TIMER0 output unseen there */ + should not be a functional pin and TIMER0 output unseen there */ void TIMER0(void) { if (pfn_timer != NULL) pfn_timer(); - IO_INTC_IRQ0 |= 1<65535 && prescaler<1024) { @@ -67,23 +70,27 @@ static void stop_timer(void) { - IO_INTC_EINT0 &= ~(1< ) \___| < | \_\ ( <_> > < < - * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ - * \/ \/ \/ \/ \/ - * $Id$ - * - * Copyright (C) 2007 by Karl Kurbjun - * - * All files in this archive are subject to the GNU General Public License. - * See the file COPYING in the source tree root for full license agreement. - * - * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY - * KIND, either express or implied. - * - ****************************************************************************/ +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2007 by Karl Kurbjun +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ #include "config.h" #include "system.h" @@ -27,21 +27,25 @@ void tick_start(unsigned int interval_in_ms) { +/* TODO: set up TIMER1 clock settings + IO_CLK_MOD2 &= ~CLK_MOD2_TMR1; //disable TIMER1 clock + IO_CLK_SEL0 |= (1 << 2); //set TIMER1 clock to PLLIN*/ + IO_CLK_MOD2 |= CLK_MOD2_TMR1; //enable TIMER1 clock!!!!!!!!! IO_TIMER1_TMMD = CONFIG_TIMER1_TMMD_STOP; /* Setup the Prescalar (Divide by 10) - * Based on linux/include/asm-arm/arch-integrator/timex.h - */ + * Based on linux/include/asm-arm/arch-integrator/timex.h + */ IO_TIMER1_TMPRSCL = 0x0009; /* Setup the Divisor */ - IO_TIMER1_TMDIV = (TIMER_FREQ / (10*1000))*interval_in_ms; - + IO_TIMER1_TMDIV = (TIMER_FREQ / (10*1000))*interval_in_ms - 1; + /* Turn Timer1 to Free Run mode */ IO_TIMER1_TMMD = CONFIG_TIMER1_TMMD_FREE_RUN; - + /* Enable the interrupt */ - IO_INTC_EINT0 |= 1< ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ - * $Id: i2c-meg-fx.h 13720 2007-06-26 02:11:30Z jethead71 $ + * $Id$ * - * Copyright (C) 2007 by Michael Sevakis + * Copyright (C) 2008 by Maurus Cuelenaere * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. @@ -17,28 +17,7 @@ * ****************************************************************************/ -/* chip-specific i2c functions */ - -/* IICCON */ -#define I2C_ACKGEN (1 << 7) -#define I2C_TXCLK_512 (1 << 6) -#define I2C_TXRX_INTENB (1 << 5) -#define I2C_TXRX_INTPND (1 << 4) - -/* IICSTAT */ -#define I2C_MODE_MASTER (2 << 6) -#define I2C_MODE_TX (1 << 6) -#define I2C_BUSY (1 << 5) -#define I2C_START (1 << 5) -#define I2C_RXTX_ENB (1 << 4) -#define I2C_BUS_ARB_FAILED (1 << 3) -#define I2C_S_ADDR_STAT (1 << 2) -#define I2C_S_ADDR_MATCH (1 << 1) -#define I2C_ACK_L (1 << 0) - -/* IICLC */ -#define I2C_FLT_ENB (1 << 2) - void i2c_init(void); -void i2c_write(int addr, const unsigned char *data, int count); +int i2c_write(unsigned short address, const unsigned char *data, int count); +int i2c_read(unsigned short address, unsigned char* buf, int count); Index: firmware/target/arm/tms320dm320/system-dm320.c =================================================================== --- firmware/target/arm/tms320dm320/system-dm320.c (revision 16682) +++ firmware/target/arm/tms320dm320/system-dm320.c (working copy) @@ -8,6 +8,7 @@ * $Id$ * * Copyright (C) 2007 by Karl Kurbjun + * Copyright (C) 2008 by Maurus Cuelenaere * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. @@ -114,7 +115,12 @@ asm volatile( "stmfd sp!, {r0-r7, ip, lr} \n" /* Store context */ "sub sp, sp, #8 \n"); /* Reserve stack */ - irqvector[(IO_INTC_IRQENTRY0>>2)-1](); + unsigned short addr = IO_INTC_IRQENTRY0>>2; + if(addr != 0) + { + addr--; + irqvector[addr](); + } asm volatile( "add sp, sp, #8 \n" /* Cleanup stack */ "ldmfd sp!, {r0-r7, ip, lr} \n" /* Restore context */ "subs pc, lr, #4 \n"); /* Return from FIQ */ @@ -141,7 +147,22 @@ void system_reboot(void) { - + /* Code taken from linux/include/asm-arm/arch-itdm320-20/system.h at NeuroSVN */ + __asm__ __volatile__( + "mov ip, #0\n" + "mcr p15, 0, ip, c7, c7, 0 @ invalidate cache \n" + "mcr p15, 0, ip, c8, c7, 0 @ flush TLB (v4) \n" + "mrc p15, 0, ip, c1, c0, 0 @ get ctrl register\n" + "bic ip, ip, #0x000f @ ............wcam \n" + "bic ip, ip, #0x2100 @ ..v....s........ \n" + "mcr p15, 0, ip, c1, c0, 0 @ ctrl register \n" + "mov ip, #0xFF000000 \n" + "orr ip, ip, #0xFF0000 @ ip = 0xFFFF0000 \n" + "mov pc, ip \n" + : + : + : "cc" + ); } void system_init(void) @@ -167,16 +188,28 @@ IO_INTC_FISEL1 = 0; IO_INTC_FISEL2 = 0; + /* IRQENTRY only reflects enabled interrupts */ + IO_INTC_RAW = 0; + IO_INTC_ENTRY_TBA0 = 0; IO_INTC_ENTRY_TBA1 = 0; - /* Turn off other timers */ + unsigned short i; + /* Reset interrupt priorities to default values */ + for(i = 0; i < 23; i++) + DM320_REG(0x0540+i*2) = ( (i*2+1) << 8 ) | i*2 ;//IO_INTC_PRIORITYx + + /* Turn off all timers */ + IO_TIMER0_TMMD = CONFIG_TIMER0_TMMD_STOP; + IO_TIMER1_TMMD = CONFIG_TIMER1_TMMD_STOP; IO_TIMER2_TMMD = CONFIG_TIMER2_TMMD_STOP; IO_TIMER3_TMMD = CONFIG_TIMER3_TMMD_STOP; +#ifndef CREATIVE_ZVM /* set GIO26 (reset pin) to output and low */ IO_GIO_BITCLR1=(1<<10); IO_GIO_DIR1&=~(1<<10); +#endif uart_init(); spi_init(); @@ -186,9 +219,18 @@ /* Make sure everything is mapped on itself */ map_section(0, 0, 0x1000, CACHE_NONE); /* Enable caching for RAM */ - map_section(0x00900000, 0x00900000, 64, CACHE_ALL); + map_section(CONFIG_SDRAM_START, CONFIG_SDRAM_START, MEM, CACHE_ALL); /* enable buffered writing for the framebuffer */ map_section((int)FRAME, (int)FRAME, 1, BUFFERED); +#ifdef CREATIVE_ZVM + //mimic OF + map_section(0x00100000, 0x00100000, 4, CACHE_NONE); + map_section(0x04700000, 0x04700000, 2, BUFFERED); + map_section(0x40000000, 0x40000000, 16, CACHE_NONE); + map_section(0x50000000, 0x50000000, 16, CACHE_NONE); + map_section(0x60000000, 0x60000000, 16, CACHE_NONE); + map_section(0x80000000, 0x80000000, 1, CACHE_NONE); +#endif enable_mmu(); } Index: firmware/target/arm/tms320dm320/debug-dm320.c =================================================================== --- firmware/target/arm/tms320dm320/debug-dm320.c (revision 16682) +++ firmware/target/arm/tms320dm320/debug-dm320.c (working copy) @@ -8,6 +8,7 @@ * $Id$ * * Copyright (C) 2007 by Karl Kurbjun + * Copyright (C) 2008 by Maurus Cuelenaere * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. @@ -37,8 +38,11 @@ extern int r_button; bool __dbg_hw_info(void) { - int line = 0, button, oldline; + int line = 0, oldline; +#ifndef CREATIVE_ZVM + int button; int *address=0x0; +#endif bool done=false; char buf[100]; @@ -58,12 +62,25 @@ IO_CLK_DIV3, IO_CLK_DIV4, IO_CLK_BYP, IO_CLK_INV); lcd_puts(0, line++, buf); snprintf(buf, sizeof(buf), "IO_CLK_MOD0: 0x%04x IO_CLK_MOD1: 0x%04x IO_CLK_MOD2: 0x%04x IO_CLK_LPCTL0: 0x%04x", IO_CLK_MOD0, IO_CLK_MOD1, IO_CLK_MOD2, IO_CLK_LPCTL0); lcd_puts(0, line++, buf); + + lcd_puts(0, line++, "Board revision:"); + switch (IO_BUSC_REVR) { + case 0x0010: + lcd_puts(0, line++, "DM320 Rev. A"); + break; + case 0x0011: + lcd_puts(0, line++, "DM320 Rev. B/C"); + break; + default: + lcd_puts(0, line++, "Unknown DM320 Chip ID"); + } line++; oldline=line; while(!done) { line = oldline; +#ifndef CREATIVE_ZVM button = button_get(false); button&=~BUTTON_REPEAT; if (button == BUTTON_POWER) @@ -76,19 +93,24 @@ address+=0x800; else if (button==BUTTON_RC_REW) address-=0x800; +#endif snprintf(buf, sizeof(buf), "Buffer: 0x%02x%02x%02x%02x%02x", r_buffer[0], r_buffer[1], r_buffer[2], r_buffer[3],r_buffer[4] ); lcd_puts(0, line++, buf); +#ifndef CREATIVE_ZVM snprintf(buf, sizeof(buf), "Button: 0x%08x, HWread: 0x%08x", (unsigned int)button, r_button); lcd_puts(0, line++, buf); +#endif snprintf(buf, sizeof(buf), "current tick: %08x Seconds running: %08d", (unsigned int)current_tick, (unsigned int)current_tick/100); lcd_puts(0, line++, buf); +#ifndef CREATIVE_ZVM snprintf(buf, sizeof(buf), "Address: 0x%08x Data: 0x%08x", (unsigned int)address, *address); lcd_puts(0, line++, buf); snprintf(buf, sizeof(buf), "Address: 0x%08x Data: 0x%08x", (unsigned int)(address+1), *(address+1)); lcd_puts(0, line++, buf); snprintf(buf, sizeof(buf), "Address: 0x%08x Data: 0x%08x", (unsigned int)(address+2), *(address+2)); lcd_puts(0, line++, buf); +#endif lcd_update(); } Index: firmware/target/arm/tms320dm320/spi-dm320.c =================================================================== --- firmware/target/arm/tms320dm320/spi-dm320.c (revision 16682) +++ firmware/target/arm/tms320dm320/spi-dm320.c (working copy) @@ -31,6 +31,7 @@ #define GIO_TS_ENABLE (1<<2) #define GIO_RTC_ENABLE (1<<12) #define GIO_BL_ENABLE (1<<13) +#define GIO_LCD_ENABLE (1<<5) struct mutex spi_mtx; @@ -42,9 +43,12 @@ #define reg(a) ((volatile unsigned short *)(PHY_IO_BASE+a)) struct SPI_info spi_targets[] = { +#ifndef CREATIVE_ZVM [SPI_target_TSC2100] = { &IO_GIO_BITCLR1, &IO_GIO_BITSET1, GIO_TS_ENABLE }, - [SPI_target_RX5X348AB] = { &IO_GIO_BITSET0, &IO_GIO_BITCLR0, GIO_RTC_ENABLE }, + [SPI_target_RX5X348AB] = { &IO_GIO_BITSET0, &IO_GIO_BITCLR0, GIO_RTC_ENABLE}, [SPI_target_BACKLIGHT] = { &IO_GIO_BITCLR1, &IO_GIO_BITSET1, GIO_BL_ENABLE }, +#endif + [SPI_target_LTV250QV] = { &IO_GIO_BITCLR2, &IO_GIO_BITSET2, GIO_LCD_ENABLE}, }; static void spi_disable_all_targets(void) @@ -98,11 +102,12 @@ IO_SERIAL0_MODE |= 1<<10; /* Enable TX */ IO_SERIAL0_TX_ENABLE = 0x0001; - +#ifndef CREATIVE_ZVM /* Set GIO 18 to output for touch screen slave enable */ IO_GIO_DIR1 &= ~GIO_TS_ENABLE; /* Set GIO 12 to output for rtc slave enable */ IO_GIO_DIR0 &= ~GIO_RTC_ENABLE; - +#endif spi_disable_all_targets(); /* make sure only one is ever enabled at a time */ + } Index: firmware/target/arm/tms320dm320/spi-target.h =================================================================== --- firmware/target/arm/tms320dm320/spi-target.h (revision 16682) +++ firmware/target/arm/tms320dm320/spi-target.h (working copy) @@ -27,6 +27,7 @@ SPI_target_TSC2100 = 0, SPI_target_RX5X348AB, SPI_target_BACKLIGHT, + SPI_target_LTV250QV, SPI_MAX_TARGETS, }; Index: firmware/target/arm/tms320dm320/crt0.S =================================================================== --- firmware/target/arm/tms320dm320/crt0.S (revision 16682) +++ firmware/target/arm/tms320dm320/crt0.S (working copy) @@ -159,7 +159,7 @@ and r4, pc, r2 /* Copy bootloader to safe area - 0x01900000 */ - mov r5, #0x01900000 + mov r5, #0x1900000 ldr r6, = _dataend sub r0, r6, r5 /* length of loader */ add r0, r4, r0 /* r0 points to start of loader */ Index: firmware/target/arm/tms320dm320/creative-zvm/ata-target.h =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/ata-target.h (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/ata-target.h (revision 0) @@ -0,0 +1,71 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2007 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef ATA_TARGET_H +#define ATA_TARGET_H + +/* Plain C read & write loops */ +#define PREFER_C_READING +#define PREFER_C_WRITING + +#define ATA_IOBASE 0x50FEE000 +#define ATA_DATA (*((volatile unsigned short*)(ATA_IOBASE))) +#define ATA_ERROR (*((volatile unsigned char*)(ATA_IOBASE+0x2))) +#define ATA_NSECTOR (*((volatile unsigned char*)(ATA_IOBASE+0x4))) +#define ATA_SECTOR (*((volatile unsigned char*)(ATA_IOBASE+0x6))) +#define ATA_LCYL (*((volatile unsigned char*)(ATA_IOBASE+0x8))) +#define ATA_HCYL (*((volatile unsigned char*)(ATA_IOBASE+0xA))) +#define ATA_SELECT (*((volatile unsigned char*)(ATA_IOBASE+0xC))) +#define ATA_COMMAND (*((volatile unsigned char*)(ATA_IOBASE+0xE))) +#define ATA_CONTROL (*((volatile unsigned char*)(ATA_IOBASE+0x800C))) //just to set ATA_CONTROL to *some* value +//0x50FFC000 +//0x50FF6000 +//0x50FF600C + +#define STATUS_BSY 0x80 +#define STATUS_RDY 0x40 +#define STATUS_DF 0x20 +#define STATUS_DRQ 0x08 +#define STATUS_ERR 0x01 +#define ERROR_ABRT 0x04 + +#define WRITE_PATTERN1 0xa5 +#define WRITE_PATTERN2 0x5a +#define WRITE_PATTERN3 0xaa +#define WRITE_PATTERN4 0x55 + +#define READ_PATTERN1 0xa5 +#define READ_PATTERN2 0x5a +#define READ_PATTERN3 0xaa +#define READ_PATTERN4 0x55 + +#define READ_PATTERN1_MASK 0xff +#define READ_PATTERN2_MASK 0xff +#define READ_PATTERN3_MASK 0xff +#define READ_PATTERN4_MASK 0xff + +#define SET_REG(reg,val) reg = (val) +#define SET_16BITREG(reg,val) reg = (val) + +void ata_reset(void); +void ata_device_init(void); +bool ata_is_coldstart(void); +void ide_power_enable(bool on); + +#endif Index: firmware/target/arm/tms320dm320/creative-zvm/lcd-creativezvm.c =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/lcd-creativezvm.c (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/lcd-creativezvm.c (revision 0) @@ -0,0 +1,375 @@ +/*************************************************************************** +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2008 by Maurus Cuelenaere +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ +#include "config.h" + +#include "hwcompat.h" +#include "kernel.h" +#include "lcd.h" +#include "system.h" +#include "memory.h" +#include "cpu.h" +#include "spi.h" +#include "spi-target.h" +#include "lcd-target.h" + +/* Power and display status */ +static bool display_on = false; /* Is the display turned on? */ + +int lcd_default_contrast(void) +{ + return 0x1f; +} + +void lcd_set_contrast(int val) +{ + /* iirc there is an ltv250qv command to do this */ + #warning function not implemented + (void)val; +} + + +/* LTV250QV panel functions */ + +static void lcd_write_reg(unsigned char reg, unsigned short val) +{ + unsigned char block[3]; + block[0] = 0x74; + block[1] = 0; + block[2] = reg | 0xFF; + spi_block_transfer(SPI_target_LTV250QV, block, sizeof(block), NULL, 0); + block[0] = 0x76; + block[1] = (val >> 8) & 0xFF; + block[2] = val & 0xFF; + spi_block_transfer(SPI_target_LTV250QV, block, sizeof(block), NULL, 0); +} + +static void sleep_ms(unsigned int ms) +{ + unsigned int temp = current_tick; + while(current_tick> 16; + IO_OSD_OSDWIN0ADL=addr & 0xFFFF; + +#ifndef ZEN_VISION + IO_OSD_BASEPX=26; + IO_OSD_BASEPY=5; +#else + IO_OSD_BASEPX=80; + IO_OSD_BASEPY=0; +#endif + + IO_OSD_OSDWIN0XP=0; + IO_OSD_OSDWIN0YP=0; + IO_OSD_OSDWIN0XL=LCD_WIDTH; + IO_OSD_OSDWIN0YL=LCD_HEIGHT; +#if 0 + //TODO: set LCD clock! + IO_CLK_MOD1 &= ~0x18; // disable OSD clock and VENC clock + IO_CLK_02DIV = 3; + IO_CLK_OSEL = (IO_CLK_OSEL & ~0xF00) | 0x400; // reset 'General purpose clock output (GIO26, GIO34)' and set to 'PLLIN clock' + IO_CLK_SEL1 = (IO_CLK_SEL1 | 7) | 0x1000; // set to 'GP clock output 2 (GIO26, GIO34)' and turn on 'VENC clock' + IO_CLK_MOD1 |= 0x18; // enable OSD clock and VENC clock + + /* Set LCD values in OSD */ + IO_VID_ENC_VMOD = ( ( (IO_VID_ENC_VMOD & 0xFFFF8C00) | 0x14) | 0x2400 ); // disable NTSC/PAL encoder & set mode to RGB666 parallel 18 bit + IO_VID_ENC_VDCTL = ( ( (IO_VID_ENC_VDCTL & 0xFFFFCFE8) | 0x20) | 0x4000 ); + //TODO: finish this... +#endif + set_irq_level(oldlevel); +} + + +/*** Update functions ***/ + + + +/* Update a fraction of the display. */ +void lcd_update_rect(int x, int y, int width, int height) +{ + register fb_data *dst, *src; + + if (!display_on) + return; + + if (x + width > LCD_WIDTH) + width = LCD_WIDTH - x; /* Clip right */ + if (x < 0) + width += x, x = 0; /* Clip left */ + if (width <= 0) + return; /* nothing left to do */ + + if (y + height > LCD_HEIGHT) + height = LCD_HEIGHT - y; /* Clip bottom */ + if (y < 0) + height += y, y = 0; /* Clip top */ + if (height <= 0) + return; /* nothing left to do */ + +#if CONFIG_ORIENTATION == SCREEN_PORTAIT + dst = (fb_data *)FRAME + LCD_WIDTH*y + x; + src = &lcd_framebuffer[y][x]; + + /* Copy part of the Rockbox framebuffer to the second framebuffer */ + if (width < LCD_WIDTH) + { + /* Not full width - do line-by-line */ + lcd_copy_buffer_rect(dst, src, width, height); + } + else + { + /* Full width - copy as one line */ + lcd_copy_buffer_rect(dst, src, LCD_WIDTH*height, 1); + } +#else + src = &lcd_framebuffer[y][x]; + + register int xc, yc; + register fb_data *start=FRAME + LCD_HEIGHT*(LCD_WIDTH-x-1) + y + 1; + + for(yc=0;yc= 2 or else */ + width &= ~1; + height >>= 1; + + fb_data *dst = (fb_data*)FRAME + x * LCD_WIDTH + (LCD_WIDTH - y) - 1; + + z = stride*src_y; + yuv_src[0] = src[0] + z + src_x; + yuv_src[1] = src[1] + (z >> 2) + (src_x >> 1); + yuv_src[2] = src[2] + (yuv_src[1] - src[1]); + + do + { + lcd_write_yuv420_lines(dst, chroma_buf, yuv_src, width, + stride); + + yuv_src[0] += stride << 1; /* Skip down two luma lines */ + yuv_src[1] += stride >> 1; /* Skip down one chroma line */ + yuv_src[2] += stride >> 1; + dst -= 2; + } + while (--height > 0); +} + Index: firmware/target/arm/tms320dm320/creative-zvm/adc-target.h =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/adc-target.h (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/adc-target.h (revision 0) @@ -0,0 +1,38 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id: adc-target.h 14817 2007-09-22 15:43:38Z kkurbjun $ + * + * Copyright (C) 2007 by Karl Kurbjun + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef _ADC_TARGET_H_ +#define _ADC_TARGET_H_ + +/* only two channels used by the Gigabeat */ +#define NUM_ADC_CHANNELS 2 + +#define ADC_BATTERY 0 +#define ADC_HPREMOTE 1 +#define ADC_UNKNOWN_3 2 +#define ADC_UNKNOWN_4 3 +#define ADC_UNKNOWN_5 4 +#define ADC_UNKNOWN_6 5 +#define ADC_UNKNOWN_7 6 +#define ADC_UNKNOWN_8 7 + +#define ADC_UNREG_POWER ADC_BATTERY /* For compatibility */ +#define ADC_READ_ERROR 0xFFFF + +#endif Index: firmware/target/arm/tms320dm320/creative-zvm/backlight-target.h =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/backlight-target.h (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/backlight-target.h (revision 0) @@ -0,0 +1,31 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id: backlight-target.h 15599 2007-11-12 18:49:53Z amiconn $ + * + * Copyright (C) 2007 by Karl Kurbjun + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef BACKLIGHT_TARGET_H +#define BACKLIGHT_TARGET_H + +bool _backlight_init(void); +void _backlight_on(void); +void _backlight_off(void); +void _backlight_set_brightness(int brightness); + +/* true: backlight fades off - false: backlight fades on */ +void __backlight_dim(bool dim); + +#endif Index: firmware/target/arm/tms320dm320/creative-zvm/button-target.h =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/button-target.h (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/button-target.h (revision 0) @@ -0,0 +1,61 @@ +/*************************************************************************** +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2008 by Maurus Cuelenaere +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ + +#ifndef _BUTTON_TARGET_H_ +#define _BUTTON_TARGET_H_ + +#include "config.h" + +#define BUTTON_BACK (1 << 0) +#define BUTTON_CUSTOM (1 << 1) +#define BUTTON_MENU (1 << 2) + +#define BUTTON_LEFT (1 << 3) +#define BUTTON_RIGHT (1 << 4) +#define BUTTON_UP (1 << 5) +#define BUTTON_DOWN (1 << 6) +#define BUTTON_SELECT (1 << 7) + +#define BUTTON_POWER (1 << 8) +#define BUTTON_PLAY (1 << 9) + +#define BUTTON_HOLD (1 << 10) + +#define BUTTON_LONG (1 << 11) + +#define BUTTON_MAIN (BUTTON_BACK|BUTTON_MENU|BUTTON_LEFT|BUTTON_RIGHT \ + |BUTTON_UP|BUTTON_DOWN|BUTTON_SELECT|BUTTON_POWER \ + |BUTTON_PLAY|BUTTON_HOLD|BUTTON_CUSTOM) + +#define POWEROFF_BUTTON BUTTON_POWER +#define POWEROFF_COUNT 10 + +#define NONBUTTON_HEADPHONE (1 << 0) +#define NONBUTTON_DOCK (1 << 1) +#define NONBUTTON_USB (1 << 2) +#define NONBUTTON_POWER (1 << 3) +#define NONBUTTON_VIDEOUT (1 << 4) + +void button_init_device(void); +int button_read_device(void); +bool headphones_inserted(void); +bool button_hold(void); +bool button_usb_connected(void); + +#endif /* _BUTTON_TARGET_H_ */ Index: firmware/target/arm/tms320dm320/creative-zvm/pic-creativezvm.c =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/pic-creativezvm.c (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/pic-creativezvm.c (revision 0) @@ -0,0 +1,297 @@ +/*************************************************************************** +* __________ __ ___. +* Open \______ \ ____ ____ | | _\_ |__ _______ ___ +* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +* \/ \/ \/ \/ \/ +* $Id$ +* +* Copyright (C) 2008 by Maurus Cuelenaere +* +* Creative Zen Vision:M interrupt based PIC driver +* +* All files in this archive are subject to the GNU General Public License. +* See the file COPYING in the source tree root for full license agreement. +* +* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY +* KIND, either express or implied. +* +****************************************************************************/ + +#include "config.h" +#include "system.h" +#include "kernel.h" +#include "button-target.h" +#include "i2c-dm320.h" + + +#include "lcd-target.h" +#include "lcd.h" +#include "sprintf.h" +#include "font.h" + +#ifndef ZEN_VISION +/* Creative Zen Vision:M */ +#define BTN_LEFT 0xAF00 +#define BTN_RIGHT 0xA700 +#define BTN_BACK 0xDF00 +#define BTN_CUSTOM 0xC700 +#define BTN_PLAY 0x9700 +#define BTN_POWER 0x8700 +#define BTN_MENU 0xCF00 +#define BTN_HOLD 0xCF07 +#define BTN_UNHOLD 0xD707 + +#define BTN_LONG (1 << 15) + +#define BTN_TOUCHPAD_PRESS 0x8F00 +#define BTN_TOUCHPAD_DOWN_A 0x8701 +#define BTN_TOUCHPAD_DOWN_B 0x8F01 +#define BTN_TOUCHPAD_UP_A 0x8706 +#define BTN_TOUCHPAD_UP_B 0x9706 +#define BTN_TOUCHPAD_CORNER_DOWN 0xD700 +#define BTN_TOUCHPAD_CORNER_UP 0x9F00 + +#define HEADPHONE_PLUGIN_A 0x5707 +#define HEADPHONE_PLUGIN_B 0x5F07 +#define HEADPHONE_UNPLUG_A 0x3707 +#define HEADPHONE_UNPLUG_B 0x3F07 + +#define DOCK_INSERT 0x6707 +#define DOCK_UNPLUG 0x6F07 +#define DOCK_USB_INSERT 0x1707 +#define DOCK_USB_UNPLUG_A 0x1F03 +#define DOCK_USB_UNPLUG_B 0x1F07 +#define DOCK_POWER_INSERT 0x2707 +#define DOCK_POWER_UNPLUG 0x2F07 + +#else +/* Creative Zen Vision */ +#define BTN_LEFT 0xCF00 +#define BTN_RIGHT 0xEF00 +#define BTN_BACK 0xBF00 +#define BTN_CUSTOM 0x0 +#define BTN_PLAY 0x2F00 +#define BTN_POWER 0x0F00 +#define BTN_MENU 0x9F00 +#define BTN_HOLD 0x9F06 +#define BTN_UNHOLD 0xAF06 +/* TODO: other values +First number is just pressing it, second is when you release it or keep it pressed a bit longer +On/Off = 0F00 && 0F01 +Hold = 9F06 && AF06 +Volume Up = 6F00 && 6F01 +Vol Down = 7F00 && 7F01 +Up = DF00 && DF01 +Right = EF00 && EF01 +Down = FF00 && FF01 +Left = CF00 && CF01 +Back = BF00 && BF01 +Menu = 9F00 && Etcetera +Ok = 1F00 +Play = 2F00 +Next = 4F00 +Prev = 5F00 + +USB = 2F06 +USB ouot = 3F06 +Headphones= AF06 +Hdphns out= BF06 +Charger = 4F06 -> 9F05 +Chgrout = 5F06 -> 8F05 +AV in = 8F06 +AV out = 9F06 */ + +#define BTN_LONG 1 + +#define BTN_TOUCHPAD_PRESS 0x8F00 +#define BTN_TOUCHPAD_LONG_PRESS 0x0F00 +#define BTN_TOUCHPAD_CORNER_DOWN 0xD700 +#define BTN_TOUCHPAD_CORNER_LONG_DOWN 0x5700 +#define BTN_TOUCHPAD_CORNER_UP 0x9F00 +#define BTN_TOUCHPAD_CORNER_LONG_UP 0x1F00 + +#define HEADPHONE_PLUGIN_A 0xAF06 +#define HEADPHONE_PLUGIN_B 0xAF06 +#define HEADPHONE_UNPLUG_A 0xBF06 +#define HEADPHONE_UNPLUG_B 0xBF06 + +#define DOCK_INSERT 0x0 +#define DOCK_UNPLUG 0x0 +#define DOCK_USB_INSERT 0x2F06 +#define DOCK_USB_UNPLUG_A 0x3F06 +#define DOCK_USB_UNPLUG_B 0x3F06 +#define DOCK_POWER_INSERT 0x4F06 +#define DOCK_POWER_UNPLUG 0x5F06 +#define DOCK_AV_INSERT 0x8F06 +#define DOCK_AV_UNPLUG 0x9F06 +#endif + +#define PIC_READ_ADR 0x07 +#define PIC_WRITE_ADR 0x08 + +static int btn; +static unsigned char nonbtn; + +/* Taken from scramble.c */ +inline unsigned int le2int(unsigned char* buf) +{ + return (unsigned int)(buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]; +} + +#define do_short(BtN) btn = (btn ^ BtN) & ~BUTTON_LONG; +#define do_long(BtN) btn |= BtN | BUTTON_LONG; + +#ifdef BUTTON_DEBUG +static bool sw = false; +#endif + +void GIO0(void) +{ + unsigned char msg[16]; + i2c_read(PIC_READ_ADR, msg, 16); + switch(le2int(msg) & 0xFFFF) + { + case BTN_LEFT: + do_short(BUTTON_LEFT); + break; + case BTN_LEFT ^ BTN_LONG: + do_long(BUTTON_LEFT); + break; + case BTN_RIGHT: + do_short(BUTTON_RIGHT); + break; + case BTN_RIGHT ^ BTN_LONG: + do_long(BUTTON_RIGHT); + break; + case BTN_BACK: + do_short(BUTTON_BACK); + break; + case BTN_BACK ^ BTN_LONG: + do_long(BUTTON_BACK); + break; + case BTN_CUSTOM: + do_short(BUTTON_CUSTOM); + break; + case BTN_CUSTOM ^ BTN_LONG: + do_long(BUTTON_CUSTOM); + break; + case BTN_MENU: + do_short(BUTTON_MENU); + break; + case BTN_MENU ^ BTN_LONG: + do_long(BUTTON_MENU); + break; + case BTN_PLAY: + do_short(BUTTON_PLAY); + break; + case BTN_PLAY ^ BTN_LONG: + do_long(BUTTON_PLAY); + break; + case BTN_POWER: + do_short(BUTTON_POWER); + break; + case BTN_POWER ^ BTN_LONG: + do_long(BUTTON_POWER); + break; + case BTN_HOLD: + btn |= BUTTON_HOLD; + break; + case BTN_UNHOLD: + btn &= ~BUTTON_HOLD; + btn &= ~BUTTON_POWER; + break; + case BTN_TOUCHPAD_PRESS: + do_short(BUTTON_SELECT); + break; + case BTN_TOUCHPAD_PRESS ^ BTN_LONG: + do_long(BUTTON_SELECT); + break; + case BTN_TOUCHPAD_CORNER_DOWN: + do_short(BUTTON_DOWN); + break; + case BTN_TOUCHPAD_CORNER_DOWN ^ BTN_LONG: + do_long(BUTTON_DOWN); + break; + case BTN_TOUCHPAD_CORNER_UP: + do_short(BUTTON_UP); + break; + case BTN_TOUCHPAD_CORNER_UP ^ BTN_LONG: + do_long(BUTTON_UP); + break; + case HEADPHONE_PLUGIN_A: + case HEADPHONE_PLUGIN_B: + nonbtn |= NONBUTTON_HEADPHONE; + break; + case HEADPHONE_UNPLUG_A: + case HEADPHONE_UNPLUG_B: + nonbtn &= ~NONBUTTON_HEADPHONE; + break; + case DOCK_INSERT: + nonbtn |= NONBUTTON_DOCK; + break; + case DOCK_UNPLUG: + nonbtn &= ~NONBUTTON_DOCK; + nonbtn &= ~NONBUTTON_USB; + nonbtn &= ~NONBUTTON_POWER; + break; + case DOCK_USB_INSERT: + nonbtn |= NONBUTTON_USB; + break; + case DOCK_USB_UNPLUG_A: + case DOCK_USB_UNPLUG_B: + nonbtn &= ~NONBUTTON_USB; + break; + case DOCK_POWER_INSERT: + nonbtn |= NONBUTTON_POWER; + break; + case DOCK_POWER_UNPLUG: + nonbtn &= ~NONBUTTON_POWER; + break; + } +//#ifdef BUTTON_DEBUG + unsigned char weergvn[10]; + lcd_set_foreground((sw ? LCD_RGBPACK(255,0,0) : LCD_RGBPACK(0,255,0) )); + snprintf(weergvn, sizeof(char)*10, "%x", (unsigned int)(msg[3] << 24) | (msg[2] << 16) | (msg[1] << 8) | msg[0]); + lcd_putsxy(LCD_WIDTH-SYSFONT_WIDTH*10, LCD_HEIGHT-SYSFONT_HEIGHT*10, weergvn); + snprintf(weergvn, sizeof(char)*10, "%x", (unsigned int)(msg[7] << 24) | (msg[6] << 16) | (msg[5] << 8) | msg[4]); + lcd_putsxy(LCD_WIDTH-SYSFONT_WIDTH*10, LCD_HEIGHT-SYSFONT_HEIGHT*9, weergvn); + snprintf(weergvn, sizeof(char)*10, "%x", (unsigned int)(msg[11] << 24) | (msg[10] << 16) | (msg[9] << 8) | msg[8]); + lcd_putsxy(LCD_WIDTH-SYSFONT_WIDTH*10, LCD_HEIGHT-SYSFONT_HEIGHT*8, weergvn); + snprintf(weergvn, sizeof(char)*10, "%x", (unsigned int)(msg[15] << 24) | (msg[14] << 16) | (msg[13] << 8) | msg[12]); + lcd_putsxy(LCD_WIDTH-SYSFONT_WIDTH*10, LCD_HEIGHT-SYSFONT_HEIGHT*7, weergvn); + lcd_set_foreground(LCD_BLACK); + lcd_update(); + sw = !sw; +//#endif + IO_INTC_IRQ1 = INTR_IRQ1_EXT0; /* Mask GIO0 interrupt */ + return; +} + +bool headphones_inserted(void) +{ + return (bool)(nonbtn & NONBUTTON_HEADPHONE); +} + +void button_init_device(void) +{ + /* TODO: I suppose GIO0 has to be set to input and enable interrupts on it? */ + IO_INTC_EINT1 |= INTR_EINT1_EXT0; /* Enable GIO0 interrupt */ + btn = 0; + nonbtn = 0; +} +int button_read_device(void) +{ + return btn; +} + +bool button_hold(void) +{ + return (bool)(btn & BUTTON_HOLD); +} + +bool button_usb_connected(void) +{ + return (bool)(nonbtn & NONBUTTON_USB); +} Index: firmware/target/arm/tms320dm320/creative-zvm/lcd-target.h =================================================================== --- firmware/target/arm/tms320dm320/creative-zvm/lcd-target.h (revision 0) +++ firmware/target/arm/tms320dm320/creative-zvm/lcd-target.h (revision 0) @@ -0,0 +1,25 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2007 by Karl Kurbjun + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#ifndef _LCD_TARGET_H_ +#define _LCD_TARGET_H_ + +extern void lcd_enable(bool state); + +#endif Index: firmware/timer.c =================================================================== --- firmware/timer.c (revision 16682) +++ firmware/timer.c (working copy) @@ -304,7 +304,7 @@ #elif CONFIG_CPU == PNX0101 TIMER1.ctrl &= ~0x80; /* disable timer 1 */ irq_disable_int(IRQ_TIMER1); -#elif CONFIG_CPU == S3C2440 +#else __TIMER_UNREGISTER(); #endif pfn_timer = NULL; Index: firmware/FILES =================================================================== --- firmware/FILES (revision 16682) +++ firmware/FILES (working copy) @@ -42,6 +42,7 @@ target/arm/tcc780x/*.[chS] target/arm/tcc780x/cowond2/*.[chS] target/arm/tms320dm320/*.[chS] +target/arm/tms320dm320/creative-zvm/*.[chS] target/arm/tms320dm320/mrobe-500/*.[chS] target/coldfire/*.[chS] target/coldfire/iaudio/*.[chS] Index: firmware/drivers/ata.c =================================================================== --- firmware/drivers/ata.c (revision 16682) +++ firmware/drivers/ata.c (working copy) @@ -175,19 +175,18 @@ STATICIRAM int wait_for_rdy(void) ICODE_ATTR; STATICIRAM int wait_for_rdy(void) { + long timeout; if (!wait_for_bsy()) return 0; timeout = current_tick + HZ*10; - while (TIME_BEFORE(current_tick, timeout) && !(ATA_ALT_STATUS & STATUS_RDY)) { last_disk_activity = current_tick; priority_yield(); } - if (TIME_BEFORE(current_tick, timeout)) return STATUS_RDY; else @@ -1060,7 +1059,7 @@ for (i=0; i ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + + #include "i2c-dm320.h" + + #define I2C_ADDRESS 0x51 + + unsigned char* rtc_send_command(short unk1, short unk2) + { + unsigned char ret[12]; + i2c_write(I2C_ADDRESS, (unk2 & 0xFF) | (unk << 8), 1); + i2c_read(I2C_ADDRESS, ret, 12); + return ret; + } + + unsigned char* rtc_read(void) + { + unsigned char ret[12]; + i2c_read(I2C_ADDRESS, ret, 12); + return ret; + } \ No newline at end of file Index: firmware/drivers/audio/tlv320.c =================================================================== --- firmware/drivers/audio/tlv320.c (revision 16682) +++ firmware/drivers/audio/tlv320.c (working copy) @@ -43,7 +43,7 @@ /* +6 to -73dB 1dB steps (plus mute == 80levels) 7bits */ /* 1111111 == +6dB (0x7f) */ /* 1111001 == 0dB (0x79) */ - /* 0110000 == -73dB (0x30 */ + /* 0110000 == -73dB (0x30) */ /* 0101111 == mute (0x2f) */ if (db < VOLUME_MIN) { Index: firmware/drivers/isp1583.c =================================================================== --- firmware/drivers/isp1583.c (revision 0) +++ firmware/drivers/isp1583.c (revision 0) @@ -0,0 +1,58 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include "config.h" +#include "usb-target.h" +#include "usb_drv.h" +#include "isp1583.h" + +struct usb_endpoint +{ + unsigned char *out_buf; + short out_len; + short out_ptr; + void (*out_done)(int, unsigned char *, int); + unsigned char out_in_progress; + + unsigned char *in_buf; + short in_min_len; + short in_max_len; + short in_ptr; + void (*in_done)(int, unsigned char *, int); + unsigned char in_ack; + + unsigned char halt[2]; + unsigned char enabled[2]; + short max_pkt_size[2]; +}; + +void usb_drv_init(void) +{ + +} + +void usb_drv_exit(void) +{ + +} + +void usb_drv_int(void) +{ + +}