kbdupgrade.c

Go to the documentation of this file.

/*
 * File Name  : kbdpower.c
 *
 * Description: Keyboard Firmware upgrader
 */

/*
 * This file is part of kbdupgrade.
 *
 * kbdupgrade 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.
 *
 * kbdupgrade is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */
 
//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <termios.h>

// local include files, between " "
#include "proto.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

#define ION_SERIO_FLAGS          CS8
#define ION_SERIO_SPEED          B115200

#define ACTION_FIRMWARE   1
#define ACTION_BOOTLOADER 2
#define ACTION_GASGAUGE   3
#define ACTION_READTYPE   4
#define ACTION_WRITETYPE  5

#define DR1000            0

#define VPRINTF(...) { if (verbose) printf(__VA_ARGS__); }

static char *device_types[] = {
    "DR1000",
    "DR1000S",
    "DR1000SW",
    "DR800",
    "DR800S",
    "DR800SG",
    "DR800SW",
    NULL
};


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static int action = ACTION_FIRMWARE;
static int force_update = 0;
static int only_check = 0;
static int gg_req_version = 0;
static int verbose = 1;
char *filename;
uint8_t devicetype;
static int new_devicetype;


//============================================================================
// Local Function Definitions
//============================================================================

static void usage();
static int check_firmware(char *filename, uint16_t *version);
static void parse_args(int argc, char **argv);


//============================================================================
// Functions Implementation
//============================================================================

int device_type_from_name(char *name)
{
    int i = 0; 
    while (device_types[i]) {
        if (strcasecmp(name, device_types[i]) == 0)
        {
            return i;
        }
        i++;
    }
    return 0xFF;
}

void handle_gasgauge()
{
    // No suppoprt for GasGauge on DR800 series yet    
    if(devicetype != DR1000)
    {
        fatal("No support for GasGauge updates on DR800 series devices.");   
    }
    // check battery is at least 25% and/or charging
    if (!micro_check_battery_charge(25))
    {
        fatalnum(2, "Battery too low or not charging");
    }
    if (!force_update)
    {
        uint16_t gg_ver_fw, gg_ver_hw;
        if (gasgauge_get_versions(&gg_ver_fw, &gg_ver_hw))
        {
            fatal("Can't get gas gauge firmware version");
        }
        if (gg_ver_fw!=gg_req_version)
        {
            fatal("Invalid gas gauge firmware: got %04d, need %04d",
                    gg_ver_fw, gg_req_version);
        }
        usleep(1000000);
    }
    gasgauge_flash(filename);
}

void handle_firmware()
{
    uint16_t bver, aver, fver;
    // check firware exists
    if (!check_firmware(filename, &fver))
    {
        fatal("Can't open firmware file %s", filename);
    } 
    // only use this on DR1000 to initialize communication with micro
    if (devicetype == DR1000)
    {
        micro_enter_mode(MODE_BOOT);
    }
    // check version numbers
    micro_get_versions(&bver, &aver);
    VPRINTF("Bootloader v%d.%d, app v%d.%d.\n",
            bver>>8,bver&0xFF,aver>>8,aver&0xFF);
    if (only_check)
        return;
    if ((!force_update) && 
        (((action != ACTION_BOOTLOADER) && fver<=aver && aver!=0xFFFF) ||
         ((action == ACTION_BOOTLOADER) && fver<=bver && bver!=0xFFFF)))
    {
        // firmware file is older than version on micro
        warning("Firmware '%s' is v%d.%d, not upgrading.",
                filename, fver>>8, fver&0xFF);
    } 
    else 
    {
        // erase and program
        if (devicetype == DR1000)
        {           
            // DR1000 Series
            if (action == ACTION_BOOTLOADER)
            {
                fatal("DR1000 doesn't support bootloader upgrades");
            }
            else
            {
                micro_erase(MODE_APP, DR1000_APPL_ADDR_MIN, DR1000_APPL_ADDR_MAX);
                dr1000_micro_program_application(filename);
            }
        }
        else
        {            
            // DR800 Series
            if (action == ACTION_BOOTLOADER)
            {
                micro_erase(MODE_BOOT, DR800_BOOT_ADDR_MIN, DR800_BOOT_ADDR_MAX);
                dr800_micro_program_bootloader(filename);
            }
            else
            {
                micro_erase(MODE_APP, DR800_APPL_ADDR_MIN, DR800_APPL_ADDR_MAX);
                dr800_micro_program_application(filename);
            }
        }
    }
}

void handle_devicetype()
{
    int mode = micro_get_mode();
    VPRINTF("Micro in %s mode\n", mode==MODE_APP ? "app" : "boot");

    if (action == ACTION_READTYPE)
    {
        int devtype = micro_read_devicetype(mode);
        VPRINTF("Device type: ");
        printf("%s (%d)\n", 
                devtype == 0xFF ? "Unknown" : device_types[devtype], devtype);
    }
    else
    {
        VPRINTF("Writing devicetype %d\n", new_devicetype);
        micro_write_devicetype(mode, new_devicetype);
    }
}

int main(int argc, char **argv)
{
    char *portname;

    // check arguments
    parse_args(argc, argv);
    if (((action == ACTION_GASGAUGE || action == ACTION_FIRMWARE || action == ACTION_BOOTLOADER) && 
            ((argc-optind)!=2)) ||
        (((action == ACTION_WRITETYPE || action == ACTION_READTYPE) && 
          ((argc-optind)!=1))))
    {
        usage();
    }
    portname = argv[optind];
    filename = argv[optind+1];
    // open device
    port_open(portname, ION_SERIO_FLAGS, ION_SERIO_SPEED);
    // Check DeviceType
    micro_get_devicetype(&devicetype);
    if(devicetype==0)
    {    
        VPRINTF("Device type is DR1000 Series\n");
    }
    else
    {    
        VPRINTF("Device type is DR800 Series\n");
    }
    // do upgrades
    if (action == ACTION_GASGAUGE)
    {
        handle_gasgauge();
    }
    else if (action == ACTION_FIRMWARE || action == ACTION_BOOTLOADER)
    {
        handle_firmware();
    }
    else if (action == ACTION_WRITETYPE || action == ACTION_READTYPE)
    {
        handle_devicetype();
    }
    else
    {
       fatal("Unknown action: %d\n",action);
    }

    return 0;
}


//============================================================================
// Local Functions Implementation
//============================================================================

static void usage()
{
    printf("kbdupgrade - keyboard microcontroller firmware upgrader\n");
    printf(" usage: kbdupgrade <options> <serial port> <firmware file>\n");
    printf(" options:\n");
    printf("  -b       Upgrade bootloader instead of application\n");
    printf("  -c       Only do version check\n");
    printf("  -f       Ignore version check and force upgrade\n");
    printf("  -g       Upgrade gas gauge, instead of micro\n");
    printf("  -q       Don't print as much\n");
    printf("  -r XXXX  Required gas gauge firmware version\n");
    printf("  -s XXXX  Set device type (XXXX = DR[800|1000][SWG])\n");
    printf("  -t       Get device type\n");
    printf("  -h       This text\n");
    exit(1);
}


static int check_firmware(char *filename, uint16_t *version)
{
    FILE *f = fopen(filename, "rb");
    if (f)
    {
        fread(version, 2, 1, f);
        fclose(f);
        return 1;
    }
    return 0;
}


static void parse_args(int argc, char **argv)
{
    int c;

    while (( c = getopt(argc, argv, "bcfghr:s:tq")) != -1)
    {
        switch (c)
        {
            case 'b':
                action = ACTION_BOOTLOADER;
                break;
            
            case 'g':
                action = ACTION_GASGAUGE;
                break;

            case 's':
                action = ACTION_WRITETYPE;
                new_devicetype = device_type_from_name(optarg);
                break;

            case 't':
                action = ACTION_READTYPE;
                break;

            case 'c':
                only_check = 1;
                break;

            case 'f':
                force_update = 1;
                break;
            
            case 'q':
                verbose = 0;
                break;

            case 'r':
                gg_req_version = atoi(optarg);
                printf("Required gas gauge version: %04d\n", gg_req_version);
                break;

            case 'h':
            default:
                usage();
                break;
        }
    }
}