rockbox/bootloader/mpio_hd200.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id:$
 *
 * Copyright (C) 2010 Marcin Bukat
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include "inttypes.h"
#include "string.h"
#include "cpu.h"
#include "system.h"
#include "lcd.h"
#include "kernel.h"
#include "thread.h"
#include "storage.h"
#include "usb.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 "powermgmt.h"
#include "file.h"

#include "common.h"

#include <stdarg.h>

/* Maximum allowed firmware image size. 10MB is more than enough */
#define MAX_LOADSIZE (10*1024*1024)

#define DRAM_START 0x31000000

#define BOOTMENU_TIMEOUT (10*HZ)
#define BOOTMENU_OPTIONS 3

/* From common.c */
extern int line;
static const char *bootmenu_options[] = {
    "Boot rockbox",
    "Boot MPIO firmware",
    "Shutdown"
};

enum option_t {
    rockbox,
    mpio_firmware,
    shutdown
};

int usb_screen(void)
{
   return 0;
}

char version[] = APPSVERSION;

bool _charger_inserted(void)
{
    return (GPIO1_READ & (1<<14)) ? false : true;
}

bool _battery_full(void)
{
    return (GPIO_READ & (1<<30)) ? true : false;
}

/* Reset the cookie for the crt0 crash check */
inline void __reset_cookie(void)
{
    asm(" move.l #0,%d0");
    asm(" move.l %d0,0x10017ffc");
}

void start_rockbox(void)
{
    adc_close();
    asm(" move.w #0x2700,%sr");
    __reset_cookie();
    asm(" move.l %0,%%d0" :: "i"(DRAM_START));
    asm(" movec.l %d0,%vbr");
    asm(" move.l %0,%%sp" :: "m"(*(int *)DRAM_START));
    asm(" move.l %0,%%a0" :: "m"(*(int *)(DRAM_START+4)));
    asm(" jmp (%a0)");
}

void start_mpio_firmware(void)
{
    asm(" move.w #0x2700,%sr");
    __reset_cookie();
    asm(" movec.l %d0,%vbr");
    asm(" move.l 0,%sp");
    asm(" jmp 8");
}

void __reset(void)
{
    asm(" move.w #0x2700,%sr");
    __reset_cookie();
    asm(" movec.l %d0,%vbr");
    asm(" move.l (0), %sp");
    asm(" movea.l (4),%a0");
    asm(" jmp (%a0)");
}

void __shutdown(void)
{
    /* We need to gracefully spin down the disk to prevent clicks. */
    if (ide_powered())
    {
        /* Make sure ATA has been initialized. */
        storage_init();
        
        /* And put the disk into sleep immediately. */
        storage_sleepnow();
    }

    /* Backlight OFF */
    _backlight_off();
    __reset_cookie();

    if (_charger_inserted())
    {
        /* reset instead of power_off() */
        __reset();
    }
    else
    {
        power_off();
    }
}

/* Print the battery voltage (and a warning message). */
void check_battery(void)
{

    int battery_voltage, batt_int, batt_frac;
    
    battery_voltage = battery_adc_voltage();
    batt_int = battery_voltage / 1000;
    batt_frac = (battery_voltage % 1000) / 10;

    printf("Battery: %d.%02dV", batt_int, batt_frac);

    if (battery_voltage <= 3500) 
    {
        printf("WARNING! BATTERY LOW!!");
        sleep(HZ*2);
    }

}


void lcd_putstring_centered(const char *string)
{
    int w,h;
    font_getstringsize(string, &w, &h, FONT_SYSFIXED);
    lcd_putsxy((LCD_WIDTH-w)/2, (LCD_HEIGHT-h)/2, string);
}

void bootmenu(void)
{
    int rc;
    enum option_t i;
    enum option_t option = rockbox;
    int button;
    const char select[] = "->";
    long start_tick = current_tick;

    /* backbone of menu */
    /* run the loader */
    printf("Rockbox boot loader");
    printf("Ver: %s", version);

    check_battery();

    printf("");
    printf("=========================");

    line += BOOTMENU_OPTIONS+2; /* skip lines */

    printf("=========================");
    printf("");
    printf(" [FF] [PREV] to move ");
    printf(" [PLAY] to confirm ");

    /* content of menu and keys handling */
    while (TIME_BEFORE(current_tick,start_tick + BOOTMENU_TIMEOUT))
    {
        /* Draw the menu. */
        line = 6; /* move below header */

        for (i=0;i<BOOTMENU_OPTIONS;i++)
        {
            if (i != option)
                printf("   %s",bootmenu_options[i]);
            else
                printf("%s %s",select,bootmenu_options[i]);
        }

        line = 15;

        printf("Time left: %ds",(BOOTMENU_TIMEOUT - 
                                 (current_tick - start_tick))/HZ);

        lcd_update();

        button = button_get_w_tmo(HZ);

        switch (button)
        {
            case BUTTON_PREV:
                if (option > rockbox)
                    option--;
                else
                    option = shutdown;
                break;

            case BUTTON_NEXT:
                if (option < shutdown)
                    option++;
                else
                    option = rockbox;
                break;

            case BUTTON_PLAY:
            case (BUTTON_PLAY|BUTTON_REC):
                reset_screen();

                switch (option)
                {
                    case rockbox:
                        rc = storage_init();
                        if(rc)
                        {
                            printf("ATA error: %d", rc);
                            sleep(HZ*5);
                            __shutdown();
                        }

                        disk_init();

                        rc = disk_mount_all();
                        if (rc<=0)
                        {
                            printf("No partition found");
                            sleep(HZ*5);
                            __shutdown();
                        }

                        printf("Loading firmware");
                        rc = load_firmware((unsigned char *)DRAM_START, 
                                           BOOTFILE, MAX_LOADSIZE);
                        printf("Result: %s", strerror(rc));

                        if (rc < EOK)
                        {
                            printf("Error!");
                            printf("Can't load " BOOTFILE ": ");
                            printf(strerror(rc));
                            sleep(HZ*5);
                            __shutdown();
                        }
                        else
                        {
                            start_rockbox();
                        }

                        break;

                    case mpio_firmware:
                        start_mpio_firmware();
                        break;

                    default:
                        __shutdown();
                        break;
                }
        }
}
/* timeout */
__shutdown();
}

void main(void)
{
    /* messages */
    const char usb_connect_msg[] = "Bootloader USB mode";
    const char charging_msg[] = "Charging...";
    const char complete_msg[] = "Charging complete";
    const char hold_msg[] = "Hold switch on";
    const char shutdown_msg[] = "Shutting down...";

    /* helper variables for messages */
    bool blink_toggle = false;
    const char *msg;

    bool on_button = false;
    int button;

    /* We want to read the buttons as early as possible, before the user
       releases the ON button */

    or_l( ((1<<24)|(1<<4)), &GPIO1_FUNCTION); /* main Hold & Play */
    and_l( ~((1<<24)|(1<<4)), &GPIO1_ENABLE); /* HiZ */
    
    if (GPIO1_READ & (1<<24))
        on_button = true;

    power_init();

    system_init();
    kernel_init();

    set_cpu_frequency(CPUFREQ_NORMAL);
    coldfire_set_pllcr_audio_bits(DEFAULT_PLLCR_AUDIO_BITS);

    enable_irq();
    lcd_init();

    backlight_init();
    font_init();
    lcd_setfont(FONT_SYSFIXED);

    adc_init();
    button_init();
    usb_init();

    /* handle charging */
    if( _charger_inserted())
    {
        or_l((1<<15),&GPIO_OUT);

        cpu_idle_mode(true);

        while( _charger_inserted() && 
               usb_detect() != USB_INSERTED &&
               !on_button)
        {
            button = button_get_w_tmo(HZ);

            switch(button)
            {
            case BUTTON_ON:
                on_button = true;
                reset_screen();
                break;

            case BUTTON_NONE: /* Timeout */

                if(!_battery_full())
                {
                    /* To be replaced with a nice animation */
                    blink_toggle = !blink_toggle;
                    msg = charging_msg;
                }
                else
                {
                    blink_toggle = true;
                    msg = complete_msg;
                }

                reset_screen();
                if(blink_toggle)
                    lcd_putstring_centered(msg);

                check_battery();
                break;
            }

        }
        cpu_idle_mode(false);
    }

    /* handle USB in bootloader */
    if (usb_detect() == USB_INSERTED)
    {
        ide_power_enable(true);
        sleep(HZ/20);
        usb_enable(true);
        cpu_idle_mode(true);

        while (usb_detect() == USB_INSERTED)
        {
            line = 0;

            reset_screen();

            if(blink_toggle)
            {
                 lcd_putstring_centered(usb_connect_msg);
            }

            check_battery();
            blink_toggle = !blink_toggle;

            storage_spin(); /* Prevent the drive from spinning down */
            sleep(HZ);
        }

        cpu_idle_mode(false);
        usb_enable(false);

        sleep(HZ);
        reset_screen();
        lcd_update();
    }

    /* handle ON button press */
    if (on_button)
    {
        if (button_hold() &&
            !_charger_inserted() &&
            usb_detect() != USB_INSERTED)
        {
            lcd_putstring_centered(hold_msg);
            lcd_update();
            sleep(HZ*3);
            __shutdown();
        }
        
    }
    else
    {
        lcd_putstring_centered(shutdown_msg);
        lcd_update();
        sleep(HZ*3);
        __shutdown();
    }

    
    bootmenu();
}

/* These functions are present in the firmware library, but we reimplement
   them here because the originals do a lot more than we want */
void screen_dump(void)
{
}