static void ata_power_down(void)
{
if (!ata_powered) return;
ata_powered = false;
if (ceata)
{
memset(ceata_taskfile, 0, 16);
ceata_taskfile[0xf] = 0xe0;
ceata_wait_idle();
ceata_write_multiple_register(0, ceata_taskfile, 16);
sleep(HZ);
PWRCON(0) |= (1 << 9);
}
else
{
ata_wait_for_rdy(1000000);
ata_write_cbr(&ATA_PIO_DVR, 0);
ata_write_cbr(&ATA_PIO_CSD, 0xe0);
ata_wait_for_rdy(1000000);
sleep(HZ / 30);
ATA_CONTROL = 0;
while (!(ATA_CONTROL & BIT(1))) yield();
PWRCON(0) |= (1 << 5);
}
ide_power_enable(false);
}
void power_init(void)
{
ide_power_enable(true); /* Power up the drive */
/* Power down pin */
IO_GIO_BITCLR1 = 1<<10; /* Make sure it is not active */
}
void power_init(void)
{
/* Initialize IDE power pin */
GPGCON=( GPGCON&~(1<<23) ) | (1<<22); /* Make the pin an output */
GPGUP |= 1<<11; /* Disable pullup in SOC as we are now driving */
ide_power_enable(true);
/* Charger detect */
}
void ata_enable(bool on)
{
static bool init = true;
/* Ide power toggling is a nasty hack to allow USB bridge operation
* in rockbox. For some reason GL811E bridge doesn't like the state
* in which rockbox leaves drive (and vice versa). The only way
* I found out to recover is to do disk power cycle (I tried toggling
* reset line of the disk but it doesn't work).
*/
/* GPO36 /reset line of GL811E */
if (on)
{
and_l(~(1<<4), &GPIO1_OUT);
#ifndef BOOTLOADER
if ( !init )
{
ide_power_enable(false);
sleep(1);
ide_power_enable(true);
}
#endif
init = false;
}
else
{
#ifndef BOOTLOADER
ide_power_enable(false);
sleep(1);
ide_power_enable(true);
#endif
or_l((1<<4), &GPIO1_OUT);
}
or_l((1<<4), &GPIO1_ENABLE);
or_l((1<<4), &GPIO1_FUNCTION);
}
static void charging_screen(void)
{
unsigned int button;
const char* msg;
ide_power_enable(false); /* power down the disk, else would be spinning */
lcd_clear_display();
do
{
#ifdef ARCHOS_RECORDER
if (charge_state == CHARGING)
msg = "charging";
else if (charge_state == TOPOFF)
msg = "topoff charge";
else if (charge_state == TRICKLE)
msg = "trickle charge";
else
msg = "not charging";
#else
msg = "charging";
#endif
lcd_puts(0, 0, msg);
{
char buf[32];
int battv = battery_voltage();
snprintf(buf, sizeof(buf), "%d.%02dV %d%%",
battv / 1000, (battv % 1000) / 10, battery_level());
lcd_puts(0, 1, buf);
}
lcd_update();
button = button_get_w_tmo(HZ/2);
#ifdef BUTTON_ON
if (button == (BUTTON_ON | BUTTON_REL))
#else
if (button == (BUTTON_RIGHT | BUTTON_REL))
#endif
break; /* start */
else
{
if (usb_detect() == USB_INSERTED)
break;
else if (!charger_inserted())
power_off(); /* charger removed: power down */
}
} while (1);
}
void power_init(void)
{
/* GPIO53 has to be high - low resets device */
/* GPIO49 is FM related */
or_l((1<<21)|(1<<17), &GPIO1_OUT);
or_l((1<<21)|(1<<17), &GPIO1_ENABLE);
or_l((1<<21)|(1<<17)|(1<<14), &GPIO1_FUNCTION);
and_l(~(1<<15), &GPIO_OUT);
or_l((1<<15),&GPIO_ENABLE);
or_l((1<<15),&GPIO_FUNCTION);
or_l((1<<23), &GPIO_OUT);
and_l(~(1<<23), &GPIO_ENABLE);
or_l((1<<23), &GPIO_FUNCTION);
#ifndef BOOTLOADER
/* The boot loader controls the power */
ide_power_enable(true);
#endif
}
void ata_reset(void)
{
int old_level = disable_irq_save();
if(!ide_powered())
{
ide_power_enable(true);
sleep_ms(150);
}
else
{
IO_GIO_BITSET0 = (1 << 5);
IO_GIO_BITCLR0 = (1 << 3);
sleep_ms(1);
}
IO_GIO_BITCLR0 = (1 << 5);
sleep_ms(10);
IO_GIO_BITSET0 = (1 << 3);
while(!(ATA_COMMAND & STATUS_RDY))
sleep_ms(10);
restore_irq(old_level);
}
void main(void)
{
unsigned char* loadbuffer;
int buffer_size;
int rc;
int(*kernel_entry)(void);
/* Make sure interrupts are disabled */
set_irq_level(IRQ_DISABLED);
set_fiq_status(FIQ_DISABLED);
system_init();
kernel_init();
/* Now enable interrupts */
set_irq_level(IRQ_ENABLED);
set_fiq_status(FIQ_ENABLED);
lcd_init();
backlight_init();
font_init();
button_init();
usb_init();
power_init();
// enable_irq();
// enable_fiq();
adc_init();
lcd_setfont(FONT_SYSFIXED);
/* Show debug messages if button is pressed */
// if(button_read_device())
verbose = true;
printf("Rockbox boot loader");
printf("Version %s", rbversion);
/* Enter USB mode without USB thread */
if(usb_detect() == USB_INSERTED)
{
const char msg[] = "Bootloader USB mode";
reset_screen();
lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
(LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
lcd_update();
ide_power_enable(true);
storage_enable(false);
sleep(HZ/20);
usb_enable(true);
while (usb_detect() == USB_INSERTED)
{
storage_spin(); /* Prevent the drive from spinning down */
sleep(HZ);
}
usb_enable(false);
reset_screen();
lcd_update();
}
sleep(50);
printf("ATA");
rc = storage_init();
if(rc)
{
reset_screen();
error(EATA, rc, true);
}
printf("filesystem");
filesystem_init();
printf("mount");
rc = disk_mount_all();
if (rc<=0)
{
error(EDISK,rc, true);
}
printf("Loading firmware");
loadbuffer = (unsigned char*) 0x00900000;
buffer_size = (unsigned char*)0x01900000 - loadbuffer;
rc = load_firmware(loadbuffer, BOOTFILE, buffer_size);
if(rc <= EFILE_EMPTY)
error(EBOOTFILE, rc, true);
kernel_entry = (void*) loadbuffer;
rc = kernel_entry();
/* Should not get here! */
return rc;
}
static int ata_power_up(void)
{
ata_set_active();
if (ata_powered) return 0;
ide_power_enable(true);
long spinup_start = current_tick;
if (ceata)
{
PWRCON(0) &= ~(1 << 9);
SDCI_RESET = 0xa5;
sleep(HZ / 100);
*((uint32_t volatile*)0x3cf00380) = 0;
*((uint32_t volatile*)0x3cf0010c) = 0xff;
SDCI_CTRL = SDCI_CTRL_SDCIEN | SDCI_CTRL_CLK_SEL_SDCLK
| SDCI_CTRL_BIT_8 | SDCI_CTRL_BIT_14;
SDCI_CDIV = SDCI_CDIV_CLKDIV(260);
*((uint32_t volatile*)0x3cf00200) = 0xb000f;
SDCI_IRQ_MASK = SDCI_IRQ_MASK_MASK_DAT_DONE_INT | SDCI_IRQ_MASK_MASK_IOCARD_IRQ_INT;
PASS_RC(mmc_init(), 2, 0);
SDCI_CDIV = SDCI_CDIV_CLKDIV(4);
sleep(HZ / 100);
PASS_RC(ceata_init(8), 2, 1);
PASS_RC(ata_identify(ata_identify_data), 2, 2);
dma_mode = 0x44;
}
else
{
PWRCON(0) &= ~(1 << 5);
ATA_CFG = BIT(0);
sleep(HZ / 100);
ATA_CFG = 0;
sleep(HZ / 100);
ATA_SWRST = BIT(0);
sleep(HZ / 100);
ATA_SWRST = 0;
sleep(HZ / 10);
ATA_CONTROL = BIT(0);
sleep(HZ / 5);
ATA_PIO_TIME = 0x191f7;
ATA_PIO_LHR = 0;
if (!ata_swap) ATA_CFG = BIT(6);
while (!(ATA_PIO_READY & BIT(1))) yield();
PASS_RC(ata_identify(ata_identify_data), 2, 0);
uint32_t piotime = 0x11f3;
uint32_t mdmatime = 0x1c175;
uint32_t udmatime = 0x5071152;
uint32_t param = 0;
ata_dma_flags = 0;
ata_lba48 = ata_identify_data[83] & BIT(10) ? true : false;
if (ata_identify_data[53] & BIT(1))
{
if (ata_identify_data[64] & BIT(1)) piotime = 0x2072;
else if (ata_identify_data[64] & BIT(0)) piotime = 0x7083;
}
if (ata_identify_data[63] & BIT(2))
{
mdmatime = 0x5072;
param = 0x22;
}
else if (ata_identify_data[63] & BIT(1))
{
mdmatime = 0x7083;
param = 0x21;
}
if (ata_identify_data[63] & BITRANGE(0, 2))
{
ata_dma_flags = BIT(3) | BIT(10);
param |= 0x20;
}
if (ata_identify_data[53] & BIT(2))
{
if (ata_identify_data[88] & BIT(4))
{
udmatime = 0x2010a52;
param = 0x44;
}
else if (ata_identify_data[88] & BIT(3))
{
udmatime = 0x2020a52;
param = 0x43;
}
else if (ata_identify_data[88] & BIT(2))
{
udmatime = 0x3030a52;
param = 0x42;
}
else if (ata_identify_data[88] & BIT(1))
{
udmatime = 0x3050a52;
param = 0x41;
}
if (ata_identify_data[88] & BITRANGE(0, 4))
{
ata_dma_flags = BIT(2) | BIT(3) | BIT(9) | BIT(10);
param |= 0x40;
}
}
ata_dma = param ? true : false;
dma_mode = param;
PASS_RC(ata_set_feature(0xef, param), 2, 1);
if (ata_identify_data[82] & BIT(5)) PASS_RC(ata_set_feature(0x02, 0), 2, 2);
if (ata_identify_data[82] & BIT(6)) PASS_RC(ata_set_feature(0x55, 0), 2, 3);
ATA_PIO_TIME = piotime;
ATA_MDMA_TIME = mdmatime;
ATA_UDMA_TIME = udmatime;
}
spinup_time = current_tick - spinup_start;
if (ata_lba48)
ata_total_sectors = ata_identify_data[100]
| (((uint64_t)ata_identify_data[101]) << 16)
| (((uint64_t)ata_identify_data[102]) << 32)
| (((uint64_t)ata_identify_data[103]) << 48);
else ata_total_sectors = ata_identify_data[60] | (((uint32_t)ata_identify_data[61]) << 16);
ata_total_sectors >>= 3;
ata_powered = true;
ata_set_active();
return 0;
}
