proto.c

Go to the documentation of this file.

/*
 * File Name  : proto.c
 */

/*
 * 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 <sys/types.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>

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


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


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

static int serial_fd;
int read_timeout = 100;


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


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

static int serial_write(uint8_t c);
static int serial_readTimeout(uint8_t *c, int timeout);
static uint8_t serial_read(uint8_t *c);
static uint8_t serial_readEncoded(uint8_t *c);
static void encode_send_byte(uint8_t c);


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

void fatalnum(int num, char *message, ...)
{
   char buffer[512];
   va_list ap;
   va_start(ap, message);
   vsprintf(buffer, message, ap);
    fprintf(stderr, "Error: %s\n", buffer);
   va_end(ap);
    exit(num);
}


void fatal(char *message, ...)
{
   char buffer[512];
   va_list ap;
   va_start(ap, message);
   vsprintf(buffer, message, ap);
    fprintf(stderr, "Error: %s\n", buffer);
   va_end(ap);
    exit(1);
}

void warning(char *message, ...)
{
   char buffer[512];
   va_list ap;
   va_start(ap, message);
   vsprintf(buffer, message, ap);
    fprintf(stderr, "Warning: %s\n", buffer);
   va_end(ap);
}

/**
 * Send a packet to the microcontroller
 *
 */
void ionkbd_send_packet(uint8_t cmd, uint8_t length, uint8_t *data)
{
    uint8_t i, crc = cmd + length;
    serial_write(IONKBD_START);
    encode_send_byte(cmd);
    encode_send_byte(length);
    for (i=0;i<length;i++)
    {
        crc += data[i];
        encode_send_byte(data[i]);
    }
    encode_send_byte(crc);
}

/**
 * Wait for a response from the microcontroller
 *
 */
int ionkbd_get_response(uint8_t *command, uint8_t *length, uint8_t *data)
{
    uint8_t cmd, len, crc, mycrc, c = 0;
    uint8_t i = 0;
    while(c != IONKBD_START)
    {
        if (serial_read(&c)) return 1;
    }
    if (serial_readEncoded(&cmd)) return 1;
    if (serial_readEncoded(&len)) return 1;
    mycrc = cmd+len;
    while (i<len)
    {
        if (serial_readEncoded(&data[i])) return 1;
        mycrc += data[i++];
    }
    if (serial_readEncoded(&crc)) return 1;
    if (crc != mycrc) 
    {
        fatal("Response packet CRC failed");
    }
    *command = cmd;
    *length = len;
    return 0;
}

/**
 * Send a request to the microcontroller and wait for a response
 *
 */
int ionkbd_send_request(
        uint8_t cmd, 
        uint8_t length, 
        uint8_t *data, 
        uint8_t *rcmd,
        uint8_t *rlen,
        uint8_t *rdata)
{
    ionkbd_send_packet(cmd, length, data);
    return ionkbd_get_response(rcmd, rlen, rdata);
}

/**
 * Erase a sector
 *
 */
int sector_erase(int mode, uint16_t addr)
{
    uint8_t data[2], rcmd, rlen, rdata[16];
    data[0] = addr>>8;
    data[1] = addr&0xFF;
    uint8_t req = (mode == MODE_BOOT) ? IONKBD_REQ_ERASE_FLASH_BOOT : 
                                        IONKBD_REQ_ERASE_FLASH;
    if (ionkbd_send_request(req, 2, data, &rcmd, &rlen, rdata))
    {
        warning("Micro failed to respond to erase request (0x%02X)", req);
        return 1;
    }
    if (rcmd!=IONKBD_RESP_ERASE) 
    {
        warning("Invalid erase response");
        return 1;
    }
    if (!rdata[0]) 
    {
        warning("Flash erase failed");
        return 1;
    }
    return 0;
}

/**
 * Erase the entire flash space
 *
 */
void micro_erase(int mode, uint16_t start, uint16_t end)
{
    uint32_t pos = start;
    uint8_t tries;
    while (pos < end)
    {
        printf("Erasing sector @ 0x%04X\r", pos);
        tries = 0;
        while ((sector_erase(mode, pos)) && (tries<3))
        {
            tries++;
            warning("Erase attempt %d failed", tries);
        }
        if (tries==3)
        { 
            fatal("Error erasing sector 0x%04X", pos);
        }
        pos += 512;
    }
    printf("\nErasing done\n");
}

/**
 * Program a chunk of flash memory
 *
 */
int chunk_program(int mode, uint16_t addr, uint8_t len, uint8_t *chunk)
{
    uint8_t data[32], rcmd, rlen, rdata[16];
    data[0] = addr>>8;
    data[1] = addr&0xFF;
    uint8_t req = (mode == MODE_BOOT) ? IONKBD_REQ_PROGRAM_FLASH_BOOT : 
                                        IONKBD_REQ_PROGRAM_FLASH;
    memcpy(&data[2], chunk, len);
    if (ionkbd_send_request(req, 2+len, data, &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to flash request (0x%02X)", req);
    }
    if (rcmd!=IONKBD_RESP_FLASH) 
    {
        fatal("Invalid flash response");
    }
    if (!rdata[0]) 
    {
        fatal("Flash write failed at 0x%04X", (rdata[1]<<8)|rdata[2]);
    }
    return 0;
}

int dr1000_micro_program_application(char* filename)
{
    int size, pos=0;
    uint8_t bsize, bdata[16];
    uint16_t baddr; //, i;

    // open file
    FILE *f = fopen(filename, "rb");
    // check file size
   fseek(f, 0, SEEK_END);
   size = ftell(f)-2;
   fseek(f, 2, SEEK_SET);
    // read chunks
    while (pos<size)
    {
        fread(&bsize, 1, 1, f);
        fread(&baddr, 2, 1, f);
        baddr = ((baddr&0xFF)<<8) | (baddr>>8);
        bsize -= 2;
        fread(bdata, bsize, 1, f);
        if ((bsize>0x0E) ||
            (baddr<DR1000_APPL_ADDR_MIN) ||
            (baddr>DR1000_APPL_ADDR_MAX)) 
        {
            fatal("Invalid firmware params: size: 0x%02X, addr: 0x%04X", 
                  bsize, baddr);
            exit(1);
        }
        chunk_program(MODE_APP, baddr, bsize, bdata);
        pos += (bsize+3);
    }
    fclose(f);
    return 0;
}

int dr800_micro_program_application(char* filename)
{
    int size, pos=0;
    uint8_t bdata[16];

    // open file
    FILE *f = fopen(filename, "rb");
    // check file size
    fseek(f, 0, SEEK_END);
    size = ftell(f)-2;
    fseek(f, 0, SEEK_SET);
    // read chunks
    while (pos<size)
    {
        fread(bdata, 16, 1, f);
        printf("Programming address 0x%04X\r", DR800_APPL_ADDR_MIN + pos);
        chunk_program(MODE_APP, DR800_APPL_ADDR_MIN + pos, 16, bdata);
        pos += 16;
    }
    printf("\nProgramming done\n");
    fclose(f);
    return 0;
}

int dr800_micro_program_bootloader(char* filename)
{
    int size, pos=0;
    uint8_t bdata[16];

    // open file
    FILE *f = fopen(filename, "rb");
    // check file size
    fseek(f, 0, SEEK_END);
    size = ftell(f)-2;
    fseek(f, 0, SEEK_SET);
    // read chunks
    while (pos<size)
    {
        fread(bdata, 16, 1, f);
        printf("Programming address 0x%04X\r", DR800_BOOT_ADDR_MIN + pos);
        chunk_program(MODE_BOOT, DR800_BOOT_ADDR_MIN + pos, 16, bdata);
        pos += 16;
    }
    printf("\nProgramming done\n");
    fclose(f);
    return 0;
}

int micro_read_devicetype(int mode)
{
    uint8_t data[4], rcmd, rlen, rdata[16];
    data[0] = DEVICETYPE_ADDR>>8;
    data[1] = DEVICETYPE_ADDR&0xFF;
    data[2] = 1;
    uint8_t req = (mode==MODE_BOOT) ? IONKBD_REQ_READ_FLASH : 
                                      IONKBD_REQ_READ_FLASH_BOOT;
    if (ionkbd_send_request(req, 3, data, &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to flash request");
    }
    if (rcmd!=IONKBD_RESP_READ)
    {
        fatal("Invalid flash response: 0x%02X", rcmd);
    }
    return rdata[0];
}

int micro_write_devicetype(int mode, int devtype)
{
    uint8_t data[3], rcmd, rlen, rdata[16];
    data[0] = DEVICETYPE_ADDR>>8;
    data[1] = DEVICETYPE_ADDR&0xFF;
    data[2] = devtype;
    uint8_t req = (mode==MODE_BOOT) ? IONKBD_REQ_PROGRAM_FLASH : 
                                      IONKBD_REQ_PROGRAM_FLASH_BOOT;
    if (ionkbd_send_request(req, 3, data, &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to flash request");
    }
    if (rcmd!=IONKBD_RESP_FLASH) 
    {
        fatal("Invalid flash response");
    }
    if (!rdata[0]) 
    {
        fatal("Flash write failed at 0x%04X", (rdata[1]<<8)|rdata[2]);
    }
    return 0;
}

int micro_check_battery_charge(uint16_t min_level)
{
    uint8_t rcmd, rlen, rdata[16];
    uint8_t level, charging;
    if (ionkbd_send_request(IONKBD_REQ_GET_BATTERY, 0, NULL, 
                            &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to battery request");
    }
    if (rcmd!=IONKBD_RESP_BATTERY) 
    {
        fatal("Invalid flash response");
    }
    level = rdata[0];
    charging = rdata[1];
    printf("Micro battery at %d%%%s\n", level, charging?", charging":"");
    if (level>=min_level)
    {
        return 1;
    }
    else 
    {
        return ((level>5) && charging);
    }
}

int micro_get_versions(uint16_t *bootloader, uint16_t *application)
{
    uint8_t rcmd, rlen, rdata[16];
    if (ionkbd_send_request(IONKBD_REQ_GET_VERSION, 0, NULL, 
                            &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to version request");
    }
    if (rcmd!=IONKBD_RESP_VERSION) 
    {
        fatal("Invalid version response");
    }
    *bootloader = (rdata[0]<<8)|rdata[1];
    *application = (rdata[2]<<8)|rdata[3];
    return 0;
}

void micro_enter_mode(uint8_t boot)
{
    uint8_t data, rcmd, rlen, rdata[16];
    uint8_t tries = 0;
    int i;

    printf("Entering %s mode.\n", boot ? "app" : "boot");
    while (tries<5)
    {
        for (i=0;i<10;i++)
        {
            serial_write(IONKBD_START);
            usleep(1 * 1000);
        }
        usleep(5 * 1000);
        if (ionkbd_send_request(IONKBD_REQ_GET_STATUS, 0, NULL, 
                                &rcmd, &rlen, rdata))
        {
            warning("Micro failed to respond to status request");
        }
        else
        {
            if (rcmd!=IONKBD_RESP_STATUS) 
            {
                warning("Invalid response from status request: 0x%02X", rcmd);
            }
            else
            {
                if ((rdata[0]&1)==boot)
                {
                    return;
                }
                data = boot;
                if (ionkbd_send_request(IONKBD_REQ_SET_MODE, 1, &data, 
                                        &rcmd, &rlen, rdata))
                {
                    warning("Micro failed to respond to set mode request");
                }
                usleep(1000 * 1000);
            }
        }
        tries++;
    }
    fatal("Failed to enter %s mode.", boot ? "app" : "boot");
}

int micro_get_mode()
{
    uint8_t rcmd, rlen, rdata[16];
    if (ionkbd_send_request(IONKBD_REQ_GET_STATUS, 0, NULL, 
                            &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to status request");
    }
    else
    {
        if (rcmd!=IONKBD_RESP_STATUS) 
        {
            fatal("Invalid response from status request: 0x%02X", rcmd);
        }
        else
        {
            return (rdata[0]&1);
        }
    }
    return MODE_BOOT;
}

void micro_get_devicetype(uint8_t *type)
{
    uint8_t rcmd, rlen, rdata[16];
    if (ionkbd_send_request(IONKBD_REQ_GET_DEVICETYPE, 0, NULL, 
                            &rcmd, &rlen, rdata))
    {
        fatal("Micro failed to respond to devicetype request");
    }
    if (rcmd!=IONKBD_RESP_DEVICETYPE) 
    {
        if (rcmd!=IONKBD_RESP_STATUS)
        {
            fatal("Invalid devicetype response");
        }
        warning("Received status instead of devicetype respons. Assuming DR1000-series");
        rdata[0] = 0;
    }
    *type = rdata[0];
}

int gasgauge_get_versions(uint16_t *firmware, uint16_t *hardware)
{
    uint8_t rcmd, rlen, rdata[16];
    int i;
    *firmware = 0x0;
    *hardware = 0x0;
    for (i=0;i<3;i++)
    {
        if (!ionkbd_send_request(IONKBD_REQ_GET_GG_VERSION, 0, NULL,
                    &rcmd, &rlen, rdata))
        {
            break;
        }
        warning("Retrying gas gauge version request");
    }
    if (i==3)
    {
        warning("Micro failed to respond to gasgauge version request");
        return 1;
    }
    if ((rcmd != IONKBD_RESP_GG_VERSION) || (rlen != 4))
    {
        warning("Invalid response to gasgauge version request: %d (%d)",rcmd, rlen);
        return 1;
    }
    *firmware = (rdata[0]*100)|rdata[1];
    *hardware = (rdata[2]*100)|rdata[3];
    return 0;
}

int gasgauge_do_command_base(uint8_t *data, uint8_t len)
{
    uint8_t rcmd, rlen, rdata[16];
    //int i;
    if (data[0] > GASGAUGE_STOP) 
    {
        warning("Invalid gasgauge command %d\n", data[0]);
        return 1;
    }
    /*
    printf("GG SEND: cmd: %02X len: %2d data:",IONKBD_REQ_FLASH_GASGAUGE, len);
    for (i=0;i<len;i++)
        printf(" %02X",data[i]);
    printf("\n");
    */
    if (ionkbd_send_request(IONKBD_REQ_FLASH_GASGAUGE, len, data,
                            &rcmd, &rlen, rdata))
    {
        warning("Micro failed to respond to gasgauge request %d", data[0]);
        return 1;
    }
    if ((rcmd == IONKBD_RESP_GASGAUGE) && (rlen > 0) &&
        (rdata[0] == data[0]))
    {
        if (rdata[1] == 0)
        {
            warning("Gasgauge request %d failed after %d tries", 
                    data[0], rdata[2]);
            return 1;
        }
        else
        {
            //printf("Gasgauge request %d succeeded after %d tries\n", 
            //        data[0], rdata[2]);
            return 0;
        }
    }
    else
    {
        warning("Invalid respond to gasgauge request %d", data[0]);
        return 1;
    }
    return 0;
}

int gasgauge_do_command(uint8_t command)
{
    return gasgauge_do_command_base(&command, 1);
}

int gasgauge_do_setup_row(uint8_t start, uint8_t *data, uint8_t len)
{
    uint8_t buf[16];
    int i;
    buf[0] = GASGAUGE_SETUP_ROW;
    buf[1] = start;
    for (i=0;i<len;i++)
        buf[2+i] = data[i];
    return gasgauge_do_command_base(buf, 2+len);
}

int gasgauge_do_program_row(uint8_t row)
{
    uint8_t buf[2];
    buf[0] = GASGAUGE_PROGRAM_ROW;
    buf[1] = row;
    return gasgauge_do_command_base(buf, 2);
}

int gasgauge_flash(char *filename)
{
    uint8_t image[1024];
    uint8_t *imgptr;
    int row, i;
    int attempts=0;
    FILE *f;

    read_timeout = 1000;

    printf("Loading gasgauge firmware\n");
    // open file
    f = fopen(filename, "rb");
    if (!f)
    {
        warning("Couldn't open firmware file");
        return 1;
    }
    // check file size
   fseek(f, 0, SEEK_END);
   if (ftell(f)!=1025)
    {
        warning("Invalid firmware size");
        return 1;
    }
   fseek(f, 0, SEEK_SET);
    // read file
    fread(image, 1024, 1, f);
    fclose(f);

    printf("Initialising gasgauge programming\n");
    // Step 1 - Init
    for (i=0;i<3;i++)
    {
        if (!gasgauge_do_command(GASGAUGE_INIT))
            break;
        warning("Retrying gas gauge init");
    }
    if (i==3)
    {
        warning("Failed to initialise gas gauge programming");
        return 1;
    }
    printf("starting\n");
    // Step 2 - Start
    for (i=0;i<3;i++)
    {
        if (!gasgauge_do_command(GASGAUGE_START))
            break;
        warning("Retrying gas gauge start");
    }
    if (i==3)
    {
        warning("Failed to start gas gauge programming");
        return 1;
    }
    printf("saving settings\n");
    // Step 3 - Save Settings
    while (gasgauge_do_command(GASGAUGE_SAVE_SETTINGS))
    {
        warning("Failed to save gasgauge settings, retrying");
    }
    // main program loop
    while (attempts<20)
    {
        imgptr = image;
        printf("Starting flash loop (attempt %d)\n",attempts+1);
        printf("Erasing gasgauge flash\n");
        // Step 4 - Erase
        if (gasgauge_do_command(GASGAUGE_ERASE))
        {
            warning("Failed to erase gasgauge flash, restarting");
            continue;
        }
        // program rows
        for (row=0;row<32;row++) 
        {
            // Step 5 - Setup row
            printf("Setting up row  %2d\n",row);
            for (i=0;i<4;i++)
            {
                gasgauge_do_setup_row(i*8, imgptr, 8);
                imgptr += 8;
            }

            // Step 6 - Program row
            printf("Programming row %2d\n", row);
            if (gasgauge_do_program_row(row))
            {
                warning("Failed programming, restarting");
                break;
            }
        }
        // check if we're done
        if (row==32)
        {
            printf("Restoring settings\n");
            // Step 7 - Restore Settings
            if (!gasgauge_do_command(GASGAUGE_RESTORE_SETTINGS))
            {
                printf("All OK, finishing\n");
                break;
            }
        }
        attempts++;
    }

    if (attempts==20)
    {
        warning("Failed to program gasgauge");
        return 1;
    }

    printf("Stopping\n");
    // Step 8 - Stop
    if (gasgauge_do_command(GASGAUGE_STOP))
    {
        warning("Failed to stop gas gauge programming");
        return 1;
    }
    
    return 0;
}

void port_open(char* name, int flags, int speed)
{
    struct termios t;
    
    if ((serial_fd = open(name, O_RDWR | O_NOCTTY)) < 0) 
    {
        fatal("Can't open device %s", name);
    }

    tcgetattr(serial_fd, &t);

    t.c_cflag = flags | CREAD | HUPCL | CLOCAL;
    t.c_iflag = IGNBRK | IGNPAR;
    t.c_oflag = 0;
    t.c_lflag = 0;
    t.c_cc[VMIN ] = 1;
    t.c_cc[VTIME] = 0;

    cfsetispeed(&t, speed);
    cfsetospeed(&t, speed);
    tcflush(serial_fd, TCIFLUSH);
    tcsetattr(serial_fd, TCSANOW, &t);
}


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

/**
 * Write a character to the serial port
 *
 */
static int serial_write(uint8_t c)
{
    write(serial_fd, &c, 1);
    return 0;
}

/**
 * Wait for a character from the serial port, fail after specified ms
 *
 */
static int serial_readTimeout(uint8_t *c, int timeout)
{
    struct timeval tv;
    fd_set set;
    
    tv.tv_sec = 0;
    tv.tv_usec = timeout * 1000;

    FD_ZERO(&set);
    FD_SET(serial_fd, &set);

    if (!select(serial_fd+1, &set, NULL, NULL, &tv)) return -1;
    if (read(serial_fd, c, 1) != 1) return -1;

    return 0;
}

/**
 * Read a character and fail on timeout
 *
 */
static uint8_t serial_read(uint8_t *c)
{
    if (serial_readTimeout(c, read_timeout)) 
    {
        warning("Timeout waiting for response");
        return 1;
    }
    return 0;
}

/**
 * Read an escaped character from the serial port
 *
 */
static uint8_t serial_readEncoded(uint8_t *c)
{
    if (serial_read(c)) return 1;
    if (*c==IONKBD_ESC)
    {
        if (serial_read(c)) return 1;
        switch (*c)
        {
            case IONKBD_ESC_START:
                *c = IONKBD_START;
                break;
            case IONKBD_ESC_ESC:
                *c = IONKBD_ESC;
                break;
            default:
                return 1;
        }
    }
    return 0;
}

/**
 * Encode a byte and send it to the microcontroller 
 *
 */
static void encode_send_byte(uint8_t c)
{
    if (c==IONKBD_START)
    {
        serial_write(IONKBD_ESC);
        serial_write(IONKBD_ESC_START);
    }
    else if (c==IONKBD_ESC)
    {
        serial_write(IONKBD_ESC);
        serial_write(IONKBD_ESC_ESC);
    }
    else 
    {
        serial_write(c);
    }
}