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