bootloader/gigabeat-s.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 by Greg White
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "config.h"
  22 #include "system.h"
  23 #include <stdio.h>
  24 #include "kernel.h"
  25 #include "string.h"
  26 #include "adc.h"
  27 #include "powermgmt.h"
  28 #include "storage.h"
  29 #include "dir.h"
  30 #include "disk.h"
  31 #include "common.h"
  32 #include "backlight.h"
  33 #include "usb.h"
  34 #include "button.h"
  35 #include "font.h"
  36 #include "lcd.h"
  37 #include "usb-target.h"
  38
  39 #define TAR_CHUNK 512
  40 #define TAR_HEADER_SIZE 157
  41
  42 const char version[] = APPSVERSION;
  43 /* Where files sent via MTP are stored */
  44 static const char basedir[] = "/Content/0b00/00/";
  45 /* Can use memory after vector table up to 0x01f00000 */
  46 static char * const tarbuf = (char *)0x00000040;
  47 static const size_t tarbuf_size = 0x01f00000 - 0x00000040;
  48 /* Firmware data */
  49 static void * const load_buf = 0x00000000;
  50 static const size_t load_buf_size = 0x20000000 - 0x100000;
  51 static const void * const start_addr = 0x00000000;
  52
  53 static void show_splash(int timeout, const char *msg)
  54 {
  55     backlight_on();
  56     reset_screen();
  57     lcd_putsxy( (LCD_WIDTH - (SYSFONT_WIDTH * strlen(msg))) / 2,
  58                 (LCD_HEIGHT - SYSFONT_HEIGHT) / 2, msg);
  59     lcd_update();
  60
  61     sleep(timeout);
  62 }
  63
  64 static bool pause_if_button_pressed(bool pre_usb)
  65 {
  66     while (1)
  67     {
  68         int button = button_read_device();
  69
  70         if (pre_usb && !usb_plugged())
  71             return false;
  72
  73         /* Exit if no button or only the menu (settings reset) button */
  74         switch (button)
  75         {
  76         case BUTTON_MENU:
  77         case BUTTON_NONE:
  78             return true;
  79         }
  80
  81         sleep(HZ/5);
  82
  83         /* If the disk powers off, the firmware will lock at startup */
  84         storage_spin();
  85     }
  86 }
  87
  88 /* TODO: Handle charging while connected */
  89 static void handle_usb(void)
  90 {
  91     int button;
  92
  93     /* Check if plugged and pause to look at messages. If the cable was pulled
  94      * while waiting, proceed as if it never was plugged. */
  95     if (!usb_plugged() || !pause_if_button_pressed(true))
  96         return;
  97
  98     /** Enter USB mode **/
  99
 100     /* We need full button and backlight handling now */
 101     backlight_init();
 102     button_init();
 103
 104     /* Start the USB driver */
 105     usb_init();
 106     usb_start_monitoring();
 107
 108     /* Wait for threads to connect or cable is pulled */
 109     show_splash(HZ/2, "Waiting for USB");
 110
 111     while (1)
 112     {
 113         button = button_get_w_tmo(HZ/2);
 114
 115         if (button == SYS_USB_CONNECTED)
 116             break; /* Hit */
 117
 118         if (!usb_plugged())
 119             break; /* Cable pulled */
 120     }
 121
 122     if (button == SYS_USB_CONNECTED)
 123     {
 124         /* Got the message - wait for disconnect */
 125         show_splash(0, "Bootloader USB mode");
 126
 127         usb_acknowledge(SYS_USB_CONNECTED_ACK);
 128
 129         while (1)
 130         {
 131             button = button_get(true);
 132             if (button == SYS_USB_DISCONNECTED)
 133             {
 134                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 135                 break;
 136             }
 137         }
 138     }
 139
 140     /* Put drivers initialized for USB connection into a known state */
 141     backlight_on();
 142     usb_close();
 143     button_close();
 144     backlight_close();
 145
 146     /* Sleep a little to let the backlight ramp up */
 147     sleep(HZ*5/4);
 148
 149     reset_screen();
 150 }
 151
 152 static void untar(int tar_fd)
 153 {
 154     char header[TAR_HEADER_SIZE];
 155     char *ptr;
 156     char path[102];
 157     int fd, i;
 158     int ret;
 159     size_t size = filesize(tar_fd);
 160
 161     if (size > tarbuf_size)
 162     {
 163         printf("tar file too large"); /* Paranoid but proper */
 164         return;
 165     }
 166
 167     ret = read(tar_fd, tarbuf, filesize(tar_fd));
 168     if (ret < 0)
 169     {
 170         printf("couldn't read tar file (%d)", ret);
 171         return;
 172     }
 173     ptr = tarbuf;
 174
 175     while (1)
 176     {
 177         memcpy(header, ptr, TAR_HEADER_SIZE);
 178
 179         if (*header == '\0')  /* Check for EOF */
 180             break;
 181
 182         /* Parse the size field */
 183         size = 0;
 184         for (i = 124 ; i < 124 + 11 ; i++) {
 185             size = (8 * size) + header[i] - '0';
 186         }
 187
 188         /* Skip rest of header */
 189         ptr += TAR_CHUNK;
 190
 191         /* Make the path absolute */
 192         strcpy(path, "/");
 193         strcat(path, header);
 194
 195         if (header[156] == '0')  /* file */
 196         {
 197             int wc;
 198
 199             fd = creat(path, 0666);
 200             if (fd < 0)
 201             {
 202                 printf("failed to create file (%d)", fd);
 203             }
 204             else
 205             {
 206                 wc = write(fd, ptr, size);
 207                 if (wc < 0)
 208                 {
 209                     printf("write failed (%d)", wc);
 210                     break;
 211                 }
 212                 close(fd);
 213             }
 214             ptr += (size + TAR_CHUNK-1) & (~(TAR_CHUNK-1));
 215         }
 216         else if (header[156] == '5')  /* directory */
 217         {
 218             int ret;
 219
 220             /* Remove the trailing slash */
 221             if (path[strlen(path) - 1] == '/')
 222                 path[strlen(path) - 1] = '\0';
 223
 224             /* Create the dir */
 225             ret = mkdir(path);
 226             if (ret < 0 && ret != -4)
 227             {
 228                 printf("failed to create dir (%d)", ret);
 229             }
 230         }
 231     }
 232 }
 233
 234 /* Look for a tar file or rockbox binary in the MTP directory */
 235 static void handle_untar(void)
 236 {
 237     char buf[MAX_PATH];
 238     char tarstring[6];
 239     char model[5];
 240     struct dirent_uncached* entry;
 241     DIR_UNCACHED* dir;
 242     int fd;
 243     int rc;
 244
 245     dir = opendir_uncached(basedir);
 246
 247     while ((entry = readdir_uncached(dir)))
 248     {
 249         if (*entry->d_name == '.')
 250             continue;
 251
 252         snprintf(buf, sizeof(buf), "%s%s", basedir, entry->d_name);
 253         fd = open(buf, O_RDONLY);
 254
 255         if (fd < 0)
 256             continue;
 257
 258         /* Check whether the file is a rockbox binary. */
 259         lseek(fd, 4, SEEK_SET);
 260         rc = read(fd, model, 4);
 261         if (rc == 4)
 262         {
 263             model[4] = 0;
 264             if (strcmp(model, "gigs") == 0)
 265             {
 266                 printf("Found rockbox binary. Moving...");
 267                 close(fd);
 268                 remove( BOOTDIR "/" BOOTFILE);
 269                 int ret = rename(buf, BOOTDIR "/" BOOTFILE);
 270                 printf("returned %d", ret);
 271                 sleep(HZ);
 272                 break;
 273             }
 274         }
 275
 276         /* Check whether the file is a tar file. */
 277         lseek(fd, 257, SEEK_SET);
 278         rc = read(fd, tarstring, 5);
 279         if (rc == 5)
 280         {
 281             tarstring[5] = 0;
 282             if (strcmp(tarstring, "ustar") == 0)
 283             {
 284                 printf("Found tar file. Unarchiving...");
 285                 lseek(fd, 0, SEEK_SET);
 286                 untar(fd);
 287                 close(fd);
 288                 printf("Removing tar file");
 289                 remove(buf);
 290                 break;
 291             }
 292         }
 293
 294         close(fd);
 295     }
 296 }
 297
 298 /* Try to load the firmware and run it */
 299 static void __attribute__((noreturn)) handle_firmware_load(void)
 300 {
 301     int rc = load_firmware(load_buf, BOOTFILE,
 302                            load_buf_size);
 303
 304     if(rc < 0)
 305         error(EBOOTFILE, rc);
 306
 307     /* Pause to look at messages */
 308     pause_if_button_pressed(false);
 309
 310     /* Put drivers into a known state */
 311     button_close_device();
 312     storage_close();
 313     system_prepare_fw_start();
 314
 315     if (rc == EOK)
 316     {
 317         cpucache_invalidate();
 318         asm volatile ("bx %0": : "r"(start_addr));
 319     }
 320
 321     /* Halt */
 322     while (1)
 323         core_idle();
 324 }
 325
 326 static void check_battery(void)
 327 {
 328     int batt = battery_adc_voltage();
 329     printf("Battery: %d.%03d V", batt / 1000, batt % 1000);
 330     /* TODO: warn on low battery or shut down */
 331 }
 332
 333 void main(void)
 334 {
 335     int rc;
 336
 337     /* Flush and invalidate all caches (because vectors were written) */
 338     cpucache_invalidate();
 339
 340     system_init();
 341     kernel_init();
 342
 343     enable_interrupt(IRQ_FIQ_STATUS);
 344
 345     lcd_init_device();
 346     lcd_clear_display();
 347
 348     printf("Gigabeat S Rockbox Bootloader");
 349     printf("Version %s", version);
 350
 351     /* Initialize KPP so we can poll the button states */
 352     button_init_device();
 353
 354     adc_init();
 355
 356     check_battery();
 357
 358     rc = storage_init();
 359     if(rc)
 360     {
 361         reset_screen();
 362         error(EATA, rc);
 363     }
 364
 365     disk_init();
 366
 367     rc = disk_mount_all();
 368     if (rc<=0)
 369     {
 370         error(EDISK,rc);
 371     }
 372
 373     printf("Init complete");
 374
 375     /* Do USB first since a tar or binary could be added to the MTP directory
 376      * at the time and we can untar or move after unplugging. */
 377     handle_usb();
 378     handle_untar();
 379     handle_firmware_load(); /* No return */
 380 }