/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 <string.h>
#include <errno.h>
#include <os/mynewt.h>

#if MYNEWT_VAL(ADP5061_CLI)

#include <console/console.h>
#include <shell/shell.h>
#include <adp5061/adp5061.h>
#include <parse/parse.h>
#include <stdio.h>
#include "adp5061_priv.h"

static struct adp5061_dev *adp5061_dev;

/*
 * Struct for field name description.
 * Used for argument validation and field decoding
 */
struct reg_field
{
    /* Name of field */
    const char *fld_name;
    /* Position of field in register (LSB position) */
    int fld_pos;
    /* Mask of bit field to set or extract */
    uint32_t fld_mask;
    /* Function that will convert register value to descriptive string */
    const char *(*fld_decode_value)(const struct reg_field *field,
            uint32_t reg_val, char *buf);
    /* Argument passed to function above */
    const void *fld_arg;
};

/**
* ADP5061 Register structure
*/
struct adp5061_reg {
    /* Address of the register */
    uint8_t addr;
    /* Name of the register */
    const char *name;
    /* Array of bit fields */
    const struct reg_field *fields;
};


/* Change ix value to string from table.
 * Table is NULL terminated. Access outside of range will result in
 * returning ??? string
 */
static const char *val_decode_from_table(const char *const tab[], int ix)
{
    while (ix && tab[ix]) {
        ix--;
        tab++;
    }
    if (tab[0]) {
        return tab[0];
    } else {
        return "???";
    }
}

/* Decode bit field using table with mapped values */
static const char *reg_decode_from_table(const struct reg_field *field,
                                         uint32_t reg_val, char *buf)
{
    uint32_t val = (reg_val & field->fld_mask) >> field->fld_pos;
    const char * const *table = field->fld_arg;

    return val_decode_from_table(table, val);
}

static const char *const ilim_desc[] = {
        "100 mA",
        "150 mA",
        "200 mA",
        "250 mA",
        "300 mA",
        "400 mA",
        "500 mA",
        "600 mA",
        "700 mA",
        "800 mA",
        "900 mA",
        "1000 mA",
        "1200 mA",
        "1500 mA",
        "1800 mA",
        "2100 mA",
};

/* Fields for VINx register */
static const struct reg_field adp_reg_vinx_fields[] = {
        { "ILIM",   0,  0xF, reg_decode_from_table, ilim_desc },
        { NULL }
};

static const char *
vtrm_decode(const struct reg_field *field, uint32_t reg_val, char *buf)
{
    int v;
    reg_val = (reg_val & field->fld_mask) >> field->fld_pos;

    if (reg_val < 15) {
        strcpy(buf, "???");
        return buf;
    }
    if (reg_val >= 51) {
        reg_val = 51;
    }
    v = 380 + (reg_val - 15) * 2;
    sprintf(buf, "%d.%02d V", v / 100, v % 100);

    return buf;
}

static const char *const chg_vlim_desc[] = {
        "3.2 V",
        "3.4 V",
        "3.7 V",
        "3.8 V",
};

/* Fields for Termination settings register */
static const struct reg_field adp_reg_term_fields[] = {
        { "VTRM",       2,  0xFC, vtrm_decode, NULL },
        { "CHG_VLIM",   0,  0x03, reg_decode_from_table, chg_vlim_desc },
        { NULL }
};

static const char *
ichg_decode(const struct reg_field *field, uint32_t reg_val, char *buf)
{
    int a;
    reg_val = (reg_val & field->fld_mask) >> field->fld_pos;

    if (reg_val > 22) {
        reg_val = 24;
    }
    a = 50 * (reg_val + 1);
    sprintf(buf, "%02d mA", a);

    return buf;
}

static const char *
write_only_field(const struct reg_field *field, uint32_t reg_val, char *buf)
{
    (void)field;
    (void)reg_val;

    strcpy(buf, "??? write only");
    return buf;
}

static const char *const itrk_dead_desc[] = {
        "5 mA",
        "10 mA",
        "20 mA",
        "80 mA",
};

/* Fields for Charging current register */
static const struct reg_field adp_reg_chrg_curr_fields[] = {
        { "ICHG",       2,  0x7C, ichg_decode, NULL },
        { "ITRK_DEAD",  0,  0x03, reg_decode_from_table, itrk_dead_desc },
        { NULL }
};

static const char *const dis_rch_desc[] = {
        "recharge enabled",
        "recharge disabled",
};

static const char *const vrch_desc[] = {
        "80 mV",
        "160 mV",
        "200 mV",
        "260 mV",
};

static const char *const vtrk_dead_desc[] = {
        "2.0 V",
        "2.5 V",
        "2.6 V",
        "2.9 V",
};

static const char *const vweak_desc[] = {
        "2.7 V",
        "2.8 V",
        "2.9 V",
        "3.0 V",
        "3.1 V",
        "3.2 V",
        "3.3 V",
        "3.4 V",
};

/* Fields for Voltage thresholds register */
static const struct reg_field adp_reg_vol_thre_fields[] = {
        { "DIS_RCH",    7,  0x80, reg_decode_from_table, dis_rch_desc },
        { "VRCH",       5,  0x60, reg_decode_from_table, vrch_desc },
        { "VTRK_DEAD",  3,  0x18, reg_decode_from_table, vtrk_dead_desc },
        { "VWAEK",      0,  0x07, reg_decode_from_table, vweak_desc },
        { NULL }
};

const char *const en_tend_desc[] = {
        "Charge complete timer disabled",
        "Charge complete timer enabled",
};

const char *const en_ch_timer_desc[] = {
        "Trickle/fast timer disabled",
        "Trickle/fast timer enabled",
};

const char *const chg_tmr_period_desc[] = {
        "30 sec trickle timer and 300 minute fast charge timer",
        "60 sec trickle timer and 600 minute fast charge timer",
};

const char *const en_wd_desc[] = {
        "Watchdog timer is disabled evn when BAT_SNS exceeds Vdead",
        "Watchdog timer safety timer is enabled",
};

const char *const wd_period_desc[] = {
        "32 sec watchdog timer and 40 min safety timer",
        "64 sec watchdog timer and 40 min safety timer",
};

/* Fields for Timer settings register */
static const struct reg_field adp_reg_timer_fields[] = {
        { "EN_TEND",        5,  0x20, reg_decode_from_table, en_tend_desc },
        { "EN_CH_TIMER",    4,  0x10, reg_decode_from_table, en_ch_timer_desc },
        { "CHG_TMR_PERIOD", 3,  0x08, reg_decode_from_table, chg_tmr_period_desc },
        { "EN_WD",          2,  0x04, reg_decode_from_table, en_wd_desc },
        { "WD_PERIOD",      1,  0x02, reg_decode_from_table, wd_period_desc },
        { "RESET_WD",       0,  0x01, write_only_field, NULL },
        { NULL }
};

const char *const dis_ic1_desc[] = {
        "Normal operation",
        "Charger disabled, Vvin must be Viso_b < Vvin < 5.5 V",
};

const char *const en_bmon_desc[] = {
        "when Vvin < Vvin_ok battery monitor is disabled",
        "the battery monitor is enabled even when VINx is below Vvin_ok",
};

const char *const en_thr_desc[] = {
        "when Vvin < Vvin_ok the THR current source is disabled",
        "THR current source is enabled even when VINx is below Vvin_ok",
};

const char *const dis_ldo_desc[] = {
        "LDO is enabled",
        "LDO is off",
};

const char *const en_eoc_desc[] = {
        "end of charge not allowed",
        "end of charge allowed",
};

const char *const en_chg_desc[] = {
        "battery charging is disabled",
        "battery charging is enabled",
};

/* Fields for Functional settings 1 register */
static const struct reg_field adp_reg_func1_fields[] = {
        { "DIS_IC1",        6,  0x40, reg_decode_from_table, dis_ic1_desc },
        { "EN_BMON",        5,  0x20, reg_decode_from_table, en_bmon_desc },
        { "EN_THR",         4,  0x10, reg_decode_from_table, en_thr_desc },
        { "DIS_LDO",        3,  0x08, reg_decode_from_table, dis_ldo_desc },
        { "EN_EOC",         2,  0x04, reg_decode_from_table, en_eoc_desc },
        { "EN_CHG",         0,  0x01, reg_decode_from_table, en_chg_desc },
        { NULL }
};

static const char *const en_jeita_desc[] = {
        "JEITA compliance of the Li-Ion temperature battery charging specification is disabled",
        "JEITA compliance enabled",
};

static const char *const jeita_select_desc[] = {
        "JEITA 1 is selected",
        "JEITA 2 is selected",
};

static const char *const en_chg_vlim_desc[] = {
        "Charging voltage limit disabled",
        "Voltage limit activated. Charging when V drops below Vchg_vlim",
};

static const char *const ideal_diode_desc[] = {
        "Ideal diode operates always when Viso_s < Viso_b",
        "Ideal diode operates when Viso_s < Viso_b and Vbat_sns > Vweak",
        "Ideal diode is disabled",
        "Ideal diode is disabled",
};

static const char *const vsystem_desc[] = {
        "4.3 V",
        "4.4 V",
        "4.5 V",
        "4.6 V",
        "4.7 V",
        "4.8 V",
        "4.9 V",
        "5.0 V",
};

/* Fields for Functional settings 2 register */
static const struct reg_field adp_reg_func2_fields[] = {
        { "EN_JEITA",       7,  0x80, reg_decode_from_table, en_jeita_desc },
        { "JEITA_SELECT",   6,  0x40, reg_decode_from_table, jeita_select_desc },
        { "EN_CHG_VLIM",    5,  0x20, reg_decode_from_table, en_chg_vlim_desc },
        { "IDEAL_DIODE",    3,  0x08, reg_decode_from_table, ideal_diode_desc },
        { "VSYSTEM",        0,  0x07, reg_decode_from_table, vsystem_desc },
        { NULL }
};

static const char *const en_therm_lim_int_desc[] = {
        "Isothermal charging interrupt is disabled",
        "Isothermal charging interrupt is enabled",
};

static const char *const en_wd_int_desc[] = {
        "Watchdog alarm interrupt is disabled",
        "Watchdog alarm interrupt is enabled",
};

static const char *const en_tsd_int_desc[] = {
        "Overtemperature interrupt is disabled",
        "Overtemperature interrupt is enabled",
};

static const char *const en_thr_int_desc[] = {
        "THR temperature thresholds interrupt is disabled",
        "THR temperature thresholds interrupt is enabled",
};

static const char *const en_bat_int_desc[] = {
        "Battery voltage thresholds interrupt is disabled",
        "Battery voltage thresholds interrupt is enabled",
};

static const char *const en_chg_int_desc[] = {
        "Charger mode change interrupt is disabled",
        "Charger mode change interrupt is enabled",
};

static const char *const en_vin_int_desc[] = {
        "VINx pin voltage thresholds interrupt is disabled",
        "VINx pin voltage thresholds interrupt is enabled",
};

/* Fields for Interrupt enable register */
static const struct reg_field adp_reg_int_en_fields[] = {
        { "EN_THERM_LIM_INT", 6,  0x40, reg_decode_from_table, en_therm_lim_int_desc },
        { "EN_WD_INT",        5,  0x20, reg_decode_from_table, en_wd_int_desc },
        { "EN_TSD_INT",       4,  0x10, reg_decode_from_table, en_tsd_int_desc },
        { "EN_THR_INT",       3,  0x08, reg_decode_from_table, en_thr_int_desc },
        { "EN_BAT_INT",       2,  0x04, reg_decode_from_table, en_bat_int_desc },
        { "EN_CHG_INT",       1,  0x02, reg_decode_from_table, en_chg_int_desc },
        { "EN_VIN_INT",       0,  0x01, reg_decode_from_table, en_vin_int_desc },
        { NULL }
};

const char *const vin_ov_desc[] = {
        "VINx pin does not exceed Vvin_ov",
        "VINx pin exceeds Vvin_ov",
};

const char *const vin_ok_desc[] = {
        "VINx pin does not exceed Vvin_ok",
        "VINx pin exceeds Vvin_ok",
};

const char *const vin_ilim_desc[] = {
        "Current is not limited",
        "Current on VINx pin is limited by the high voltage blocking FET and charger is not running at full Ichg",
};

const char *const therm_lim_desc[] = {
        "Current is not limited by temperature",
        "Current on limited by die temperature",
};

const char *const chdone_desc[] = {
        "End of charge not reached",
        "End of charge reached (bit latches)",
};

const char *const charger_status_desc[] = {
        "charger off",
        "trickle charge",
        "fast charge (constant current mode)",
        "fast charge (constant voltage mode)",
        "charge complete",
        "LDO mode",
        "trickle or fast charge timer expired",
        "battery detection",
};

/* Fields for Charger status 1 register */
static const struct reg_field adp_reg_chg_sts1_fields[] = {
        { "VIN_OV",           7,  0x80, reg_decode_from_table, vin_ov_desc },
        { "VIN_OK",           6,  0x40, reg_decode_from_table, vin_ok_desc },
        { "VIN_ILIM",         5,  0x20, reg_decode_from_table, vin_ilim_desc },
        { "THERM_LIM",        4,  0x10, reg_decode_from_table, therm_lim_desc },
        { "CHDONE",           3,  0x08, reg_decode_from_table, chdone_desc },
        { "CHARGER_STATUS",   0,  0x07, reg_decode_from_table, charger_status_desc },
        { NULL }
};

static const char *const thr_status_desc[] = {
        "THR pin off",
        "battery cold",
        "battery cold",
        "battery warm",
        "battery hot",
        "???",
        "???",
        "thermistor OK",
};

static const char *const rch_lim_info_desc[] = {
        "Vbat_sns > Vrch",
        "Vbat_sns < Vrch",
};

static const char *const battery_status_desc[] = {
        "battery monitor off",
        "no battery",
        "Vbat_sns < Vtrk",
        "Vtrk <= Vbat_sns < Vweak",
        "Vbat_sns >= Vweak",
        NULL
};

/* Fields for Charger status 1 register */
static const struct reg_field adp_reg_chg_sts2_fields[] = {
        { "THR_STATUS",       5,  0xE0, reg_decode_from_table, thr_status_desc },
        { "RCH_LIM_INFO",     3,  0x08, reg_decode_from_table, rch_lim_info_desc },
        { "BATTERY_STATUS",   0,  0x07, reg_decode_from_table, battery_status_desc },
        { NULL }
};

static const char *const bat_shr_desc[] = {
        "No short",
        "Battery short detected",
};

static const char *const tsd_130c_desc[] = {
        "No overtemperature (lower)",
        "Overtemperature (lower) fault",
};

static const char *const tsd_140c_desc[] = {
        "No overtemperature",
        "Overtemperature fault",
};

/* Fields for Fault register */
static const struct reg_field adp_reg_fault_fields[] = {
        { "BAT_SHR",          3,  0x08, reg_decode_from_table, bat_shr_desc },
        { "TSD_130C",         1,  0x02, reg_decode_from_table, tsd_130c_desc },
        { "TSD_140C",         0,  0x01, reg_decode_from_table, tsd_140c_desc },
        { NULL }
};

static const char *const tbat_shr_desc[] = {
        "1 sec.",
        "2 sec.",
        "4 sec.",
        "10 sec.",
        "30 sec.",
        "60 sec.",
        "120 sec.",
        "180 sec.",
};

static const char *const vbat_shr_desc[] = {
        "2.0 V",
        "2.1 V",
        "2.2 V",
        "2.3 V",
        "2.4 V",
        "2.5 V",
        "2.6 V",
        "2.7 V",
};

/* Fields for Battery short register */
static const struct reg_field adp_reg_bat_shrt_fields[] = {
        { "TBAT_SHR",         5,  0xE0, reg_decode_from_table, tbat_shr_desc },
        { "VBAT_SHR",         0,  0x07, reg_decode_from_table, vbat_shr_desc },
        { NULL }
};

static const char *const iend_desc[] = {
        "12.5 mA",
        "32.5 mA",
        "52.5 mA",
        "72.5 mA",
        "92.5 mA",
        "117.5 mA",
        "142.5 mA",
        "170.0 mA",
};

static const char *const c_20_eoc_desc[] = {
        "0",
        "1",
};

static const char *const c_10_eoc_desc[] = {
        "0",
        "1",
};

static const char *const c_5_eoc_desc[] = {
        "0",
        "1",
};

static const char *const sys_en_set_desc[] = {
        "SYS_EN is activated when LDO is active and system voltage is available",
        "SYS_EN is activated by ISO_Bx, the battery charging mode",
        "SYS_EN is activated and the isolation FET is disabled when the battery drops below Vweak",
        "SYS_EN is activated in LDO mode when the charger is disabled. SYS_EN is activate in the charging mode when Viso_b > Vweak",
};

/* Fields for IEND register */
static const struct reg_field adp_reg_iend_fields[] = {
        { "IEND",             5,  0xE0, reg_decode_from_table, iend_desc },
        { "C_20_EOC",         4,  0x10, reg_decode_from_table, c_20_eoc_desc },
        { "C_10_EOC",         3,  0x08, reg_decode_from_table, c_10_eoc_desc },
        { "C_5_EOC",          2,  0x04, reg_decode_from_table, c_5_eoc_desc },
        { "SYS_EN_SET",       0,  0x03, reg_decode_from_table, sys_en_set_desc },
        { NULL }
};

/**
* Definition of all Register names
*/
static const struct adp5061_reg adp5061_device_regs[] = {
    {.addr = REG_PART_ID,           .name = "PART_ID"               },
    {.addr = REG_SILICON_REV,       .name = "SILICON_REV"           },
    {.addr = REG_VIN_PIN_SETTINGS,  .name = "VINx_PIN_SETTINGS",
            .fields = adp_reg_vinx_fields                           },
    {.addr = REG_TERM_SETTINGS,     .name = "TERMINATION_SETTINGS",
            .fields = adp_reg_term_fields                           },
    {.addr = REG_CHARGING_CURRENT,  .name = "CHARGING_CURRENT",
            .fields = adp_reg_chrg_curr_fields                      },
    {.addr = REG_VOLTAGE_THRES,     .name = "VOLTAGE_THRESHOLD",
            .fields = adp_reg_vol_thre_fields                       },
    {.addr = REG_TIMER_SETTINGS,    .name = "TIMER_SETTINGS",
            .fields = adp_reg_timer_fields                          },
    {.addr = REG_FUNC_SETTINGS_1,   .name = "FUNCTIONAL_SETTINGS_1",
            .fields = adp_reg_func1_fields                          },
    {.addr = REG_FUNC_SETTINGS_2,   .name = "FUNCTIONAL_SETTINGS_2",
            .fields = adp_reg_func2_fields                          },
    {.addr = REG_INT_EN,            .name = "INTERRUPT_EN",
            .fields = adp_reg_int_en_fields                         },
    {.addr = REG_INT_ACTIVE,        .name = "INTERRUPT_ACTIVE"      },
    {.addr = REG_CHARGER_STATUS_1,  .name = "CHARGER_STATUS_1",
            .fields = adp_reg_chg_sts1_fields                       },
    {.addr = REG_CHARGER_STATUS_2,  .name = "CHARGER_STATUS_2",
            .fields = adp_reg_chg_sts2_fields                       },
    {.addr = REG_FAULT_REGISTER,    .name = "FAULT_REGISTER",
            .fields = adp_reg_fault_fields                          },
    {.addr = REG_BATT_SHORT,        .name = "BATTERY_SHORT",
            .fields = adp_reg_bat_shrt_fields                       },
    {.addr = REG_IEND,              .name = "IEND",
            .fields = adp_reg_iend_fields                           },

};
#define NUM_DEVICE_REGS (sizeof(adp5061_device_regs)\
                        /sizeof(adp5061_device_regs[0]))

static int adp5061_shell_cmd(int argc, char **argv);

static const struct shell_cmd adp5061_shell_cmd_struct = {
    .sc_cmd = "adp5061",
    .sc_cmd_func = adp5061_shell_cmd
};

static int
adp5061_shell_err_too_many_args(const char *cmd_name)
{
    console_printf("Error: too many arguments for command \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
adp5061_shell_err_unknown_arg(const char *cmd_name)
{
    console_printf("Error: unknown argument \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
adp5061_shell_err_invalid_arg(const char *cmd_name)
{
    console_printf("Error: invalid argument \"%s\"\n",
                   cmd_name);
    return SYS_EINVAL;
}

static int
adp5061_shell_err_missing_arg(const char *cmd_name)
{
    console_printf("Error: missing %s\n", cmd_name);
    return SYS_EINVAL;
}

static int
adp5061_shell_help(void)
{
    console_printf("%s cmd\n", adp5061_shell_cmd_struct.sc_cmd);
    console_printf("cmd:\n");
    console_printf("\thelp\n");
    console_printf("\tdump [decode]\n");
    console_printf("\tread reg\n");
    console_printf("\twrite reg\n");
    console_printf("\tdisable\n");
    console_printf("\tenable\n");
    console_printf("\tstatus\n");

    return 0;
}

static const char *
field_bin_value(const struct reg_field *field, uint8_t val, char *buf)
{
    uint32_t mask = field->fld_mask >> field->fld_pos;
    int bits = 0;
    val = (val & field->fld_mask) >> field->fld_pos;
    for (bits = 0; mask; bits++) {
        mask >>= 1;
    }
    mask = field->fld_mask >> field->fld_pos;
    buf[bits] = '\0';
    while (mask) {
        buf[--bits] = '0' + (val & 1);
        mask >>= 1;
        val >>= 1;
    }
    return buf;
}

static int
adp5061_shell_cmd_dump(int argc, char **argv)
{
    uint8_t val;
    int i;
    int decode = 0;
    const struct reg_field *field;
    char binary[9];
    char buf[20];
    const struct adp5061_reg *reg;


    if (argc > 3) {
        return adp5061_shell_err_too_many_args(argv[1]);
    } else if (argc == 3) {
        if (strcmp(argv[2], "decode") == 0) {
            decode = 1;
        } else {
            return adp5061_shell_err_unknown_arg(argv[2]);
        }
    }

    console_printf("========== Device Regs ==========\n");
    console_printf("==========   ADP5061   ==========\n");
    console_printf("=================================\n\n");
    for (i = 0; i < NUM_DEVICE_REGS; ++i) {
        reg = &adp5061_device_regs[i];
        if (adp5061_get_reg(adp5061_dev,
                reg->addr, &val)) {
            console_printf("%21s [0x%02x] = READ ERROR \n",
                    reg->name, reg->addr);
        } else {
            console_printf("%21s [0x%02x] = 0x%02x \n",
                    reg->name,
                    reg->addr, val);
            if (decode && reg->fields)
            {
                for (field = reg->fields; field->fld_name; ++field)
                {
                    console_printf("%28s = %s %s\n", field->fld_name,
                                   field_bin_value(field, val, binary),
                                   field->fld_decode_value(field, val, buf));
                }
            }
        }
    }

    return 0;
}

static int
adp5061_shell_read_reg(int argc, char **argv)
{
    uint8_t reg_val;
    uint8_t reg_ix;
    int i;
    int status;

    if (argc < 3) {
        return adp5061_shell_err_missing_arg("register name of address");
    }
    if (argc > 3) {
        return adp5061_shell_err_too_many_args(argv[1]);
    }

    reg_ix = (uint8_t)parse_ull_bounds(argv[2], REG_PART_ID, REG_IEND,
            &status);

    for (i = 0; i < NUM_DEVICE_REGS; ++i) {
        if ((status == 0 && adp5061_device_regs[i].addr == reg_ix) ||
            (strcmp(adp5061_device_regs[i].name, argv[2]) == 0)) {
            if (adp5061_get_reg(adp5061_dev,
                    adp5061_device_regs[i].addr, &reg_val)) {
                console_printf("%21s [0x%02x] = READ ERROR \n",
                        adp5061_device_regs[i].name,
                        adp5061_device_regs[i].addr);
            } else {
                console_printf("%21s [0x%02x] = 0x%02x \n",
                        adp5061_device_regs[i].name,
                        adp5061_device_regs[i].addr, reg_val);
            }
            return 0;
        }
    }
    adp5061_shell_err_invalid_arg(argv[2]);

    return 0;
}

static int
adp5061_shell_write_reg(int argc, char **argv)
{
    uint8_t reg_val;
    uint8_t reg_ix;
    int i;
    int status;
    int rc;

    if (argc < 3) {
        return adp5061_shell_err_missing_arg("register name of address");
    }
    if (argc < 4) {
        return adp5061_shell_err_missing_arg("register value");
    }
    if (argc > 4) {
        return adp5061_shell_err_too_many_args(argv[1]);
    }

    reg_val = (uint8_t)parse_ull_bounds(argv[3], 0, 0xFF, &status);
    if (status) {
        console_printf("Invalid register value\n");
        return status;
    }
    reg_ix = (uint8_t)parse_ull_bounds(argv[2], REG_PART_ID, REG_IEND,
            &status);

    for (i = 0; i < NUM_DEVICE_REGS; ++i) {
        if ((status == 0 && adp5061_device_regs[i].addr == reg_ix) ||
            (strcmp(adp5061_device_regs[i].name, argv[2]) == 0)) {
            rc = adp5061_set_reg(adp5061_dev, adp5061_device_regs[i].addr,
                    reg_val);
            if (rc) {
                console_printf("Write register failed 0x%X\n", rc);
            } else {
                console_printf("Register written\n");
            }
            return 0;
        }
    }
    adp5061_shell_err_invalid_arg(argv[2]);

    return 0;
}

static int
adp5061_shell_enable(int argc, char **argv)
{
    int rc;

    if (argc > 2) {
        return adp5061_shell_err_too_many_args(argv[1]);
    }

    rc = adp5061_charge_enable(adp5061_dev);
    if (rc) {
        console_printf("Charger enable failed 0x%X\n", rc);
    } else {
        console_printf("Charger enabled\n");
    }

    return 0;
}

static int
adp5061_shell_disable(int argc, char **argv)
{
    int rc;

    if (argc > 2) {
        return adp5061_shell_err_too_many_args(argv[1]);
    }

    rc = adp5061_charge_disable(adp5061_dev);
    if (rc) {
        console_printf("Charger disable failed 0x%X\n", rc);
    } else {
        console_printf("Charger disabled\n");
    }

    return 0;
}

static int
adp5061_shell_charger_status(int argc, char **argv)
{
    int rc = 0;
    uint8_t status_1;
    uint8_t status_2;

    if (argc > 2) {
        rc = adp5061_shell_err_too_many_args(argv[1]);
        goto err;
    }

    rc = adp5061_get_reg(adp5061_dev, REG_CHARGER_STATUS_1, &status_1);
    if (rc) {
        console_printf("Read charger status 1 failed %d\n", rc);
        goto err;
    }
    console_printf("CHARGER_STATUS: %s\n",
        charger_status_desc[ADP5061_CHG_STATUS_1_GET(status_1)]);
    console_printf("VIN_OK: %d\n",
            ADP5061_CHG_STATUS_1_VIN_OK_GET(status_1));
    console_printf("VIN_OV: %d\n",
            ADP5061_CHG_STATUS_1_VIN_OV_GET(status_1));
    console_printf("VIN_ILIM: %d\n",
            ADP5061_CHG_STATUS_1_VIN_ILIM_GET(status_1));
    console_printf("THERM_ILIM: %d\n",
            ADP5061_CHG_STATUS_1_THERM_LIM_GET(status_1));
    console_printf("CHDONE: %d\n",
            ADP5061_CHG_STATUS_1_CHDONE_GET(status_1));

    rc = adp5061_get_reg(adp5061_dev, REG_CHARGER_STATUS_2, &status_2);
    if (rc) {
        console_printf("Read charger status 1 failed %d\n", rc);
        goto err;
    }
    console_printf("THR_STATUS: %s\n",
            thr_status_desc[ADP5061_CHG_STATUS_2_THR_GET(status_2)]);
    console_printf("RCH_LIM_INFO: %d\n",
            ADP5061_CHG_STATUS_2_RCH_LIM_GET(status_2));
    console_printf("BATTERY_STATUS: %s\n",
            battery_status_desc[ADP5061_CHG_STATUS_2_BATT_GET(status_2)]);
err:
    return rc;
}

static int
adp5061_shell_cmd(int argc, char **argv)
{
    if (argc == 1) {
        return adp5061_shell_help();
    }

    if (strcmp(argv[1], "help") == 0) {
        return adp5061_shell_help();
    } else if (strcmp(argv[1], "dump") == 0) {
        return adp5061_shell_cmd_dump(argc, argv);
    } else if (strcmp(argv[1], "read") == 0) {
        return adp5061_shell_read_reg(argc, argv);
    } else if (strcmp(argv[1], "write") == 0) {
        return adp5061_shell_write_reg(argc, argv);
    } else if (strcmp(argv[1], "enable") == 0) {
        return adp5061_shell_enable(argc, argv);
    } else if (strcmp(argv[1], "disable") == 0) {
        return adp5061_shell_disable(argc, argv);
    } else if (strcmp(argv[1], "status") == 0) {
        return adp5061_shell_charger_status(argc, argv);
    }

    return adp5061_shell_err_unknown_arg(argv[1]);
}

int
adp5061_shell_init(struct adp5061_dev *dev)
{
    int rc;

    adp5061_dev = dev;
    rc = shell_cmd_register(&adp5061_shell_cmd_struct);
    SYSINIT_PANIC_ASSERT(rc == 0);

    return rc;
}

#endif