/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <fcntl.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdbool.h>
#include <time.h>
#include <errno.h>

#include "stm32_bl.h"
#include "stm32f4_crc.h"
#include "i2c.h"
#include "spi.h"
#include "uart.h"

enum USE_INTERFACE {
    USE_SPI,
    USE_I2C,
    USE_UART,
};

static inline size_t pad(ssize_t length)
{
    return (length + 3) & ~3;
}

static inline size_t tot_len(ssize_t length)
{
    // [TYPE:1] [LENGTH:3] [DATA] [PAD:0-3] [CRC:4]
    return sizeof(uint32_t) + pad(length) + sizeof(uint32_t);
}

ssize_t write_byte(int fd, uint8_t byte)
{
    ssize_t ret;

    do {
        ret = write(fd, &byte, 1);
    } while (ret == 0 || (ret == -1 && errno == EINTR));

    return ret;
}

int main(int argc, char *argv[])
{
    uint8_t addr = 0x39;
    char device[] = "/dev/spidev7.0";
    int gpio_nreset = 59;
    char gpio_dev[30];
    struct stat buf;
    uint8_t *buffer;
    uint32_t crc;
    i2c_handle_t i2c_handle;
    spi_handle_t spi_handle;
    uart_handle_t uart_handle;
    handle_t *handle;
    char options[] = "d:e:w:a:t:r:l:g:csiu";
    char *dev = device;
    int opt;
    uint32_t address = 0x08000000;
    char *write_filename = NULL;
    char *read_filename = NULL;
    int sector = -1;
    int do_crc = 0;
    uint8_t type = 0x11;
    ssize_t length = 0;
    uint8_t ret;
    int use_iface = USE_SPI;
    int fd;
    int gpio;
    FILE *file;
    int val;
    struct timespec ts;

    if (argc == 1) {
        printf("Usage: %s\n", argv[0]);
        printf("  -s (use spi. default)\n");
        printf("  -i (use i2c)\n");
        printf("  -u (use uart)\n");
        printf("  -g <gpio> (reset gpio. default: %d)\n", gpio_nreset);
        printf("  -d <device> (device. default: %s)\n", device);
        printf("  -e <sector> (sector to erase)\n");
        printf("  -w <filename> (filename to write to flash)\n");
        printf("  -r <filename> (filename to read from flash)\n");
        printf("  -l <length> (length to read/write)\n");
        printf("  -a <address> (address to write filename to. default: 0x%08x)\n",
               address);
        printf("  -c (add type, length, file contents, and CRC)\n");
        printf("  -t <type> (type value for -c option. default: %d)\n", type);
        return 0;
    }

    while ((opt = getopt(argc, argv, options)) != -1) {
        switch (opt) {
        case 'd':
            dev = optarg;
            break;
        case 'e':
            sector = strtol(optarg, NULL, 0);
            break;
        case 'w':
            write_filename = optarg;
            break;
        case 'r':
            read_filename = optarg;
            break;
        case 'l':
            length = strtol(optarg, NULL, 0);
            break;
        case 'a':
            address = strtol(optarg, NULL, 0);
            break;
        case 'c':
            do_crc = 1;
            break;
        case 't':
            type = strtol(optarg, NULL, 0);
            break;
        case 's':
            use_iface = USE_SPI;
            break;
        case 'i':
            use_iface = USE_I2C;
            break;
        case 'u':
            use_iface = USE_UART;
            break;
        case 'g':
            gpio_nreset = strtol(optarg, NULL, 0);
            break;
        }
    }

    if (use_iface == USE_UART)
        fd = open(dev, O_RDWR | O_NOCTTY | O_NDELAY);
    else
        fd = open(dev, O_RDWR);
    if (fd < 0) {
        perror("Error opening dev");
        return -1;
    }

    snprintf(gpio_dev, sizeof(gpio_dev), "/sys/class/gpio/gpio%d/value", gpio_nreset);
    gpio = open(gpio_dev, O_WRONLY);
    if (gpio < 0) {
        perror("Error opening nreset gpio");
    } else {
        if (write_byte(gpio, '1') < 0)
            perror("Failed to set gpio to 1");
        close(gpio);
        ts.tv_sec = 0;
        ts.tv_nsec = 200000000;
        nanosleep(&ts, NULL);
    }

    if (use_iface == USE_SPI) {
        handle = &spi_handle.handle;
        spi_handle.fd = fd;

        val = spi_init(handle);
    } else if (use_iface == USE_UART) {
        handle = &uart_handle.handle;
        uart_handle.fd = fd;

        val = uart_init(handle);
    } else {
        handle = &i2c_handle.handle;
        i2c_handle.fd = fd;
        i2c_handle.addr = addr;

        val = i2c_init(handle);
    }

    if (val < 0) {
        printf("Init failed\n");
        return val;
    }

    if (sector >= 0) {
        printf("Erasing sector %d\n", sector);
        ret = erase_sector(handle, sector);
        if (ret == CMD_ACK)
            printf("Erase succeeded\n");
        else
            printf("Erase failed\n");
    }

    if (write_filename != NULL) {
        file = fopen(write_filename, "r");
        if (!file) {
            perror("Error opening input file");
            return -1;
        }

        if (fstat(fileno(file), &buf) < 0) {
            perror("error stating file");
            return -1;
        }

        /*
         * For CRC: (when writing to eedata/shared)
         *   [TYPE:1] [LENGTH:3] [DATA] [PAD:0-3] [CRC:4]
         * Otherwise:
         *   [DATA]
         */
        buffer = calloc(tot_len(buf.st_size), 1);
        if (length == 0 || length > buf.st_size)
            length = buf.st_size;

        if (fread(&buffer[sizeof(uint32_t)], 1, length, file) < (size_t)length) {
            perror("Error reading input file");
            free(buffer);
            fclose(file);
            return -1;
        }

        printf("Writing %zd bytes from %s to 0x%08x\n", length,
               write_filename, address);

        if (do_crc) {
            /* Populate TYPE, LENGTH, and CRC */
            buffer[0] = type;
            buffer[1] = (length >> 16) & 0xFF;
            buffer[2] = (length >>  8) & 0xFF;
            buffer[3] = (length      ) & 0xFF;
            crc = ~stm32f4_crc32(buffer, sizeof(uint32_t) + length);

            memcpy(&buffer[sizeof(uint32_t) + pad(length)],
                   &crc, sizeof(uint32_t));

            ret = write_memory(handle, address,
                               tot_len(length), buffer);
        } else {
            /* Skip over space reserved for TYPE and LENGTH */
            ret = write_memory(handle, address,
                               length, &buffer[sizeof(uint32_t)]);
        }

        if (ret == CMD_ACK)
            printf("Write succeeded\n");
        else
            printf("Write failed\n");

        free(buffer);
        fclose(file);
    }

    if (read_filename != NULL) {
        file = fopen(read_filename, "w");
        if (!file) {
            perror("Error opening output file");
            return -1;
        }

        if (length > 0) {
            /* If passed in a length, just read that many bytes */
            buffer = calloc(length, 1);

            ret = read_memory(handle, address, length, buffer);
            if (ret == CMD_ACK) {
                if (fwrite(buffer, 1, length, file) < (size_t)length)
                    perror("Failed to write all read bytes to file");

                printf("Read %zd bytes from %s @ 0x%08x\n",
                       length, read_filename, address);
            } else {
                printf("Read failed\n");
            }
            free(buffer);
        } else if (do_crc) {
            /* otherwise if crc specified, read type, length, data, and crc */
            uint8_t tmp_buf[sizeof(uint32_t)];
            ret = read_memory(handle, address, sizeof(uint32_t), tmp_buf);
            if (ret == CMD_ACK) {
                type = tmp_buf[0];
                length = ((tmp_buf[1] << 16) & 0x00FF0000) |
                         ((tmp_buf[2] <<  8) & 0x0000FF00) |
                         ((tmp_buf[3]      ) & 0x000000FF);

                if (type != 0xFF) {
                    buffer = calloc(tot_len(length), 1);
                    ret = read_memory(handle, address,
                                      tot_len(length), buffer);
                    if (ret == CMD_ACK) {
                        crc = stm32f4_crc32(buffer, tot_len(length));
                        if (fwrite(buffer, 1, tot_len(length), file) < tot_len(length))
                            perror("Failed to write all read bytes to file");

                        printf("Read %zd bytes from %s @ 0x%08x (type %02x, crc %s)\n",
                               length, read_filename, address, type,
                               crc == STM32F4_CRC_RESIDUE ? "good" : "bad");
                    } else {
                        printf("Read of payload failed\n");
                    }
                    free(buffer);
                } else {
                    printf("Read invalid type: 0xFF\n");
                }
            } else {
                printf("Read of header failed\n");
            }
        } else {
            printf("No length or crc specified for read\n");
        }
        fclose(file);
    }

    gpio = open(gpio_dev, O_WRONLY);
    if (gpio < 0) {
        perror("Error opening nreset gpio");
    } else {
        if (write_byte(gpio, '0') < 0)
            perror("Failed to set gpio to 0");
        close(gpio);
    }

    close(fd);

    return 0;
}