/*
 * Copyright (C) 2018 Knowles Electronics
 *
 * 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 <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <getopt.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <limits.h>
#include <unistd.h>
#include <linux/mfd/adnc/iaxxx-debug-intf.h>

#define LOG_TAG "ia_dump_registers"

#include <log/log.h>

#define DEBUG_DEV                   "/dev/debug0"
#define GETOPT_HELP_CHAR            (CHAR_MIN - 2)
#define REG_ADDR                    "Register Address"
#define REG_VAL                     "Register Value"
#define SRB_REG                     "SRB Registers"
#define ARB_REG                     "ARB Registers"
#define REG_OUT_FILE                "/data/data/reg_dump.txt"
#define CIRC_OUT_FILE_CM4           "/data/data/circular_buf_cm4.bin"
#define CIRC_OUT_FILE_DMX           "/data/data/circular_buf_dmx.bin"
#define CIRC_OUT_FILE_HMD           "/data/data/circular_buf_hmd.bin"

//#define ENABLE_DEBUG_PRINTS

static struct option const long_options[] = {
    {"stdout", no_argument, NULL, 'o'},
    {"regdump", no_argument, NULL, 'r'},
    {"circbuf", no_argument, NULL, 'c'},
    {"help", no_argument, NULL, GETOPT_HELP_CHAR},
    {NULL, 0, NULL, 0}
};

void usage(void)
{
    fputs("\
    USAGE -\n\
    -------\n\
    1) dump_debug_info -c\n\
    2) dump_debug_info -r\n\
    3) dump_debug_info -l <module id> <log level>\n\
    4) dump_debug_info -l <module id>\n\
    5) dump_debug_info -m <processor id> <mode>\n\
    6) dump_debug_info -m <processor id>\n\
    7) dump_debug_info -t <tunnel id>\n\
    8) dump_debug_info -n <channel id>\n\
    9) dump_debug_info -s <stream id>\n\
    \n\
    In the first form, it dumps the circular buffer logging for Rome, the output is\n\
    dumped to the file /data/data/circular_buf_(cm4/dmx/hmd).bin\n\
    In the second form, it dumps all the SRB and ARB registers, the output is\n\
    dumped to the file /data/data/reg_dump.txt\n\
    In the third form, it sets the log level to a particular module id\n\
    In the fourth form, it gets the log level for the requested modele id\n\
    In the fifth form, it sets the mode to a particular processor id\n\
    In the sixth form, it gets the mode for the requested processor id\n\
    In the seventh form, it gets the tunnel information for the requested tunnel id [0, 31]\n\
    In the eighth form, it gets the channel information for the requested channel id [0, 31]\n\
    In the ninth form, it gets the stream information for the requested stream id [0, 15]\n\
    ", stdout);

    fputs("\
    Options -\n\
    ---------\n\
    -c      Dump the circular buffer\n\
    -r      Dump all SRB and ARB registers\n\
    -o      Dump to stdout (Works only with -r option)\n\
    -l      Set/Get the log level for a particular module\n\
    -m      Set/Get the mode for a particular processor id\n\
    -t      Dump the tunnel information for a particular tunnel id [0, 31]\n\
    -n      Dump the channel information for a particular channel id [0, 31]\n\
    -s      Dump the stream information for a particular stream id [0, 15]\n\
\n\
    Module ids -\n\
    -----------\n\
    enum iaxxx_debug_module_ids {\n\
        IAXXX_DBG_MODULE_ID_ASSERT_LOG = 0,\n\
        IAXXX_DBG_MODULE_ID_ACCDETMGR_LOG = 1,\n\
        IAXXX_DBG_MODULE_ID_BATTERYMGR_LOG = 2,\n\
        IAXXX_DBG_MODULE_ID_BLUETOOTHMGR_LOG = 3,\n\
        IAXXX_DBG_MODULE_ID_BUTTONMGR_LOG = 4,\n\
        IAXXX_DBG_MODULE_ID_CODECMGR_LOG = 5,\n\
        IAXXX_DBG_MODULE_ID_CTRLMGR_LOG = 6,\n\
        IAXXX_DBG_MODULE_ID_DMAMGR_LOG = 7,\n\
        IAXXX_DBG_MODULE_ID_EVTMGR_LOG = 8,\n\
        IAXXX_DBG_MODULE_ID_FLASHMGR_LOG = 9,\n\
        IAXXX_DBG_MODULE_ID_LEDMGR_LOG = 10,\n\
        IAXXX_DBG_MODULE_ID_POWERMGR_LOG = 11,\n\
        IAXXX_DBG_MODULE_ID_STREAMMGR_LOG = 12,\n\
        IAXXX_DBG_MODULE_ID_SENSORMGR_LOG = 13,\n\
        IAXXX_DBG_MODULE_ID_TUNNELMGR_LOG = 14,\n\
        IAXXX_DBG_MODULE_ID_USBMGR_LOG = 15,\n\
        IAXXX_DBG_MODULE_ID_PLUGINMGR_LOG = 16,\n\
        IAXXX_DBG_MODULE_ID_PLUGINVM_LOG = 17,\n\
        IAXXX_DBG_MODULE_ID_PACKAGEUTILS_LOG = 18,\n\
        IAXXX_DBG_MODULE_ID_ENDPOINT_LOG = 19,\n\
        IAXXX_DBG_MODULE_ID_PUTMSG_LOG = 20,\n\
        IAXXX_DBG_MODULE_ID_CONTROLLER_LOG = 21,\n\
        IAXXX_DBG_MODULE_ID_MIPSPROFILER_LOG = 22,\n\
        IAXXX_DBG_MODULE_ID_DEBUGMONITOR_LOG = 23,\n\
        IAXXX_DBG_MODULE_ID_SSPDRV_LOG = 24,\n\
        IAXXX_DBG_MODULE_ID_AFDRV_LOG = 25,\n\
        IAXXX_DBG_MODULE_ID_SPIDRV_LOG = 26,\n\
        IAXXX_DBG_MODULE_ID_I2CDRV_LOG = 27,\n\
        IAXXX_DBG_MODULE_ID_A400DRV_LOG = 28,\n\
        IAXXX_DBG_MODULE_ID_ADAU1361DRV_LOG = 29,\n\
        IAXXX_DBG_MODULE_ID_MAX98090DRV_LOG = 30,\n\
        IAXXX_DBG_MODULE_ID_BQ27425DRV_LOG = 31,\n\
        IAXXX_DBG_MODULE_ID_USBDRV_LOG = 32,\n\
        IAXXX_DBG_MODULE_ID_CSR8811_LOG = 33,\n\
        IAXXX_DBG_MODULE_ID_CYW20707DRV_LOG = 34,\n\
        IAXXX_DBG_MODULE_ID_BUTTONDRV_LOG = 35,\n\
        IAXXX_DBG_MODULE_ID_LEDDRV_LOG = 36,\n\
        IAXXX_DBG_MODULE_ID_TIMERDRV_LOG = 37,\n\
        IAXXX_DBG_MODULE_ID_UARTDRV_LOG = 38,\n\
        IAXXX_DBG_MODULE_ID_FLASHDRV_LOG = 39,\n\
        IAXXX_DBG_MODULE_ID_DMADRV_LOG = 40,\n\
        IAXXX_DBG_MODULE_ID_GPIODRV_LOG = 41,\n\
        IAXXX_DBG_MODULE_ID_MACDRV_LOG = 42,\n\
        IAXXX_DBG_MODULE_ID_STMRDRV_LOG = 43,\n\
        IAXXX_DBG_MODULE_ID_STMRPTDRV_LOG = 44,\n\
        IAXXX_DBG_MODULE_ID_SLIMBUSDRV_LOG = 45,\n\
        IAXXX_DBG_MODULE_ID_SSENSORDRV_LOG = 46,\n\
        IAXXX_DBG_MODULE_ID_STRMDRV_LOG = 47,\n\
        IAXXX_DBG_MODULE_ID_CPUSTRMDRV_LOG = 48,\n\
        IAXXX_DBG_MODULE_ID_CLKTREEUTILS_LOG = 49,\n\
        IAXXX_DBG_MODULE_ID_SCRIPTMGR_LOG = 50,\n\
    };\n\
\n\
    Log Levels -\n\
    ------------\n\
    enum iaxxx_fw_debug_log_level {\n\
        IAXXX_DBG_LOG_LVL_OFF = 0,\n\
        IAXXX_DBG_LOG_LVL_CUSTOM = 1,\n\
        IAXXX_DBG_LOG_LVL_FATAL = 2,\n\
        IAXXX_DBG_LOG_LVL_ERROR = 3,\n\
        IAXXX_DBG_LOG_LVL_WARN = 4,\n\
        IAXXX_DBG_LOG_LVL_INFO = 5,\n\
        IAXXX_DBG_LOG_LVL_DEBUG = 6,\n\
        IAXXX_DBG_LOG_LVL_TRACE = 7,\n\
    };\n\
\n\
    Modes -\n\
    -------\n\
    enum iaxxx_fw_debug_log_mode {\n\
        IAXXX_FROM_MEMORY = 0,\n\
        IAXXX_FROM_ENDPOINT = 1,\n\
    };\n\
\n\
    Processor ids -\n\
    ---------------\n\
    enum iaxxx_proc_id_e {\n\
        IAXXX_NO_PROC = 0,\n\
        IAXXX_BOSS_ID = 1,\n\
        IAXXX_SSP_ID = 2,\n\
        IAXXX_CM4_ID = 3,\n\
        IAXXX_HMD_ID = 4,\n\
        IAXXX_DMX_ID = 5,\n\
    };\n\
    ", stdout);

    exit(EXIT_FAILURE);
}

void log_lvl(int fd, int module_id, int log_level) {
    int err = 0;
    struct iaxxx_log_level_info log_level_info;

    log_level_info.module_id = module_id;

    if (log_level == -1) {
        // We need to get the log level for the module id
        log_level_info.log_level = 0;
        err = ioctl(fd, IAXXX_GET_DBG_LOG_LEVEL,
                    (unsigned long) &log_level_info);
        if (err == -1) {
            ALOGE("%s: ERROR: IAXXX_GET_DBG_LOG_LEVEL failed %d(%s)", __func__,
                                                    errno, strerror(errno));
            return;
        }

        ALOGD("%s: Module level %d Log level %u", __func__, module_id,
                                                log_level_info.log_level);
    } else {
        // We need to set the Log level for the module id
        log_level_info.log_level = log_level;
        err = ioctl(fd, IAXXX_SET_DBG_LOG_LEVEL,
                    (unsigned long) &log_level_info);
        if (err == -1) {
            ALOGE("%s: ERROR: IAXXX_SET_DBG_LOG_LEVEL failed %d(%s)", __func__,
                                                       errno, strerror(errno));
            return;
        }
    }
}

void pmode(int fd, int proc_id, int mode) {
    int err = 0;
    struct iaxxx_log_mode_info log_mode_info;

    log_mode_info.proc_id = proc_id;

    if (mode == -1) {
        // We need to get the mode for the processor id
        log_mode_info.mode = 0;
        err = ioctl(fd, IAXXX_GET_DBG_LOG_MODE,
                    (unsigned long) &log_mode_info);
        if (err == -1) {
            ALOGE("%s: ERROR: IAXXX_GET_DBG_LOG_MODE failed %d(%s)", __func__,
                                                        errno, strerror(errno));
            return;
        }

        ALOGD("%s: Processor ID %d Mode %u", __func__, proc_id,
                                            log_mode_info.mode);
    } else {
        // We need to set the mode for the processor id
        log_mode_info.mode = mode;
        err = ioctl(fd, IAXXX_SET_DBG_LOG_MODE,
                    (unsigned long) &log_mode_info);
        if (err == -1) {
            ALOGE("%s: ERROR: IAXXX_SET_DBG_LOG_MODE failed %d(%s)", __func__,
                                                        errno, strerror(errno));
            return;
        }
    }
}

void dump_all_regs(const struct iaxxx_registers_dump *info, bool use_stdout)
{
    uint32_t addr;
    int i, j;
    FILE *out_fp = NULL;
    const struct iaxxx_srb_info *srb_info = &info->srb_info;
    const struct iaxxx_arb_info *arb_info = &info->arb_info;

    if (use_stdout) {
        out_fp = stdout;
    } else {
        out_fp = fopen(REG_OUT_FILE, "w");
        if (NULL == out_fp) {
            ALOGE("Couldn't open the file %s for writing", REG_OUT_FILE);
            return;
        }
    }

    /* SRB */
#ifdef ENABLE_DEBUG_PRINTS
    ALOGD("%s", SRB_REG);
    ALOGD("%s\t%s", REG_ADDR, REG_VAL);
#endif
    fprintf(out_fp, "%s\n", SRB_REG);
    fprintf(out_fp, "%s\t%s\n", REG_ADDR, REG_VAL);

    addr = srb_info->reg_start_addr;
    for (i = 0; i < srb_info->reg_num; ++i) {
        uint32_t val = srb_info->reg_vals[i];

#ifdef ENABLE_DEBUG_PRINTS
        ALOGD("0x%X\t\t\t0x%08X", addr, val);
#endif
        fprintf(out_fp, "0x%X\t\t\t0x%08X\n", addr, val);

        addr += sizeof(uint32_t);
    }

    /* ARB */
    addr = arb_info->reg_start_addr;
    /* Dump all the ARB start address and the size at the beginning
     * before dumping all the ARB information
     */
    for (i = 0, j = 0; i < arb_info->reg_num; i += 2, j++) {
        uint32_t arb_phy_addr = arb_info->reg_vals[i];
        uint32_t arb_sz = arb_info->reg_vals[i + 1];

#ifdef ENABLE_DEBUG_PRINTS
        ALOGD("0x%X\t\t\t0x%08X", addr, arb_phy_addr);
        ALOGD("0x%X\t\t\t0x%08X", (addr + 4), arb_sz);
#endif
        fprintf(out_fp, "0x%X\t\t\t0x%08X\n", addr, arb_phy_addr);
        fprintf(out_fp, "0x%X\t\t\t0x%08X\n", (addr + sizeof(uint32_t)), arb_sz);
        addr += (sizeof(uint32_t) * 2);
    }

    addr = arb_info->reg_start_addr;
    for (i = 0, j = 0; i < arb_info->reg_num; i += 2, j++) {
        const struct iaxxx_arb_block *block = &arb_info->blocks[j];
        uint32_t k;
        uint32_t temp_arb_addr;
#ifdef ENABLE_DEBUG_PRINTS
        uint32_t arb_phy_addr = arb_info->reg_vals[i];
        uint32_t arb_sz = arb_info->reg_vals[i + 1];

        ALOGD("0x%X \t\t arb phy addr 0x%08X arb size 0x%08X", addr, arb_phy_addr, arb_sz);
        ALOGD("%s %d", ARB_REG, j);
        ALOGD("%s\t%s", REG_ADDR, REG_VAL);
#endif
        addr += (sizeof(uint32_t) * 2);

        fprintf(out_fp, "%s %d\n", ARB_REG, j);
        fprintf(out_fp, "%s\t%s\n", REG_ADDR, REG_VAL);

        if (0 == block->reg_start_addr || 0 == block->reg_num) {
            ALOGD("------------- NA -------------");
            fprintf(out_fp, "------------- NA -------------\n");
            continue;
        }

        temp_arb_addr = block->reg_start_addr;
        for (k = 0; k < block->reg_num; k++) {
            uint32_t temp_val = block->reg_vals[k];
#ifdef ENABLE_DEBUG_PRINTS
            ALOGD("0x%X\t\t\t0x%08X", temp_arb_addr, temp_val);
#endif
            fprintf(out_fp, "0x%X\t\t\t0x%08X\n", temp_arb_addr, temp_val);

            temp_arb_addr += sizeof(uint32_t);
        }
    }

    fflush(out_fp);
    if (!use_stdout)
        fclose(out_fp);
}

/*
 * Register Information -
 * All circular buffers start address and size is stored in ARB10
 * ARB10 - physical address in SRB is 0x580001bc
 *      Start Address location      Size location
 * CM4    ARB10 + 0                    ARB10 + 4
 * HMD    ARB10 + 8                    ARB10 + C
 * DMX    ARB10 + 10                   ARB10 + 14
 */
void dump_circ_buf(const struct iaxxx_circ_buffer_info *circ_buffer_info)
{
    uint32_t i = 0, j = 0;
    const char *out_file_names[IAXXX_MAX_CIRC_BUFS] = {CIRC_OUT_FILE_CM4, CIRC_OUT_FILE_HMD, CIRC_OUT_FILE_DMX};

    if (circ_buffer_info->buf_num > IAXXX_MAX_CIRC_BUFS) {
        ALOGE("Too large buf_num: %d", circ_buffer_info->buf_num);
        return;
    }

    for (i = 0, j = 0; j < circ_buffer_info->buf_num; i += 2, j++) {
        const struct iaxxx_circ_buffer *buf = &circ_buffer_info->bufs[j];
        FILE *fp = NULL;
        uint32_t k = 0;

        // Get the physical address and size for each of the circular buffers
        if (0 == buf->reg_start_addr || 0 == buf->reg_num) {
            ALOGE("Couldn't find physical address and size");
            ALOGE("phy_addr 0x%X size 0x%X", buf->reg_start_addr, buf->reg_num);
            continue;
        }

        fp = fopen(out_file_names[j], "wb");
        if (NULL == fp) {
            ALOGE("Couldn't open the file for writing");
            continue;
        }

        for (k = 0; k < buf->reg_num; k++)
            fwrite(buf->reg_vals + k, sizeof(uint32_t), 1, fp);

        fflush(fp);
        fclose(fp);
    }
}

static int dump_tunnel(int fd, int tunnel_id)
{
    int ret;
    struct iaxxx_tunnel_info_dump dump = {
        .id = tunnel_id
    };

    if ((ret = ioctl(fd, IAXXX_IOCTL_GET_TUNNEL_INFO_DUMP, &dump)) != 0) {
        ALOGE("Failed to ioctl %s IAXXX_IOCTL_GET_TUNNEL_INFO_DUMP, ret=%d", DEBUG_DEV, ret);
        ret = errno;
        return ret;
    }

    fprintf(stdout, "header.en=0x%08x\n"
                    "header.st=0x%08x\n"
                    "header.out_buf_size=%u\n"
                    "header.out_buf_addr=0x%08x\n"
                    "header.out_buf_head=%u\n"
                    "header.out_buf_tail=%u\n"
                    "header.out_buf_threshold=%u\n"
                    "tunnel%u.nframe_drops=%u\n"
                    "tunnel%u.nsent_to_host=%u\n"
                    "tunnel%u.nsent=%u\n"
                    "tunnel%u.nrecvd=%u\n"
                    "tunnel%u.ctrl=%u\n"
                    "tunnel%u.format=%u\n",
                    dump.en,
                    dump.st,
                    dump.out_buf_size,
                    dump.out_buf_addr,
                    dump.out_buf_head,
                    dump.out_buf_tail,
                    dump.out_buf_threshold,
                    dump.id, dump.nframe_drops,
                    dump.id, dump.nsent_to_host,
                    dump.id, dump.nsent,
                    dump.id, dump.nrecvd,
                    dump.id, dump.ctrl,
                    dump.id, dump.format);

    return ret;
}

static int dump_channel(int fd, int channel_id)
{
    int ret;
    struct iaxxx_channel_info_dump dump = {
        .id = channel_id
    };

    if ((ret = ioctl(fd, IAXXX_IOCTL_GET_CHANNEL_INFO_DUMP, &dump)) != 0) {
        ALOGE("Failed to ioctl %s IAXXX_IOCTL_GET_CHANNEL_INFO_DUMP, ret=%d", DEBUG_DEV, ret);
        ret = errno;
        return ret;
    }

    fprintf(stdout, "header.st=0x%08x\n"
                    "header.direction=%u\n"
                    "header.gain=%u\n"
                    "channel%u.nsent=%u\n"
                    "channel%u.nrecvd=%u\n"
                    "channel%u.endpoint_state=%u\n"
                    "channel%u.intr_cnt=%u\n"
                    "channel%u.drop_cnt=%u\n"
                    "channel%u.gain_ctrl=%u\n"
                    "channel%u.gain_status=%u\n"
                    "channel%u.""%s""=%u\n",
                    dump.st,
                    dump.direction,
                    dump.gain,
                    dump.id, dump.nsent,
                    dump.id, dump.nrecvd,
                    dump.id, dump.endpoint_state,
                    dump.id, dump.intr_cnt,
                    dump.id, dump.drop_cnt,
                    dump.id, dump.gain_ctrl,
                    dump.id, dump.gain_status,
                    dump.id, (dump.id >= 0 && dump.id < 16)
                                ? "out_fmt" : "in_connect", dump.in_connect);

    return ret;
}

static int dump_stream(int fd, int stream_id)
{
    int ret;
    struct iaxxx_stream_info_dump dump = {
        .id = stream_id
    };

    if ((ret = ioctl(fd, IAXXX_IOCTL_GET_STREAM_INFO_DUMP, &dump)) != 0) {
        ALOGE("Failed to ioctl %s IAXXX_IOCTL_GET_STREAM_INFO_DUMP, ret=%d", DEBUG_DEV, ret);
        ret = errno;
        return ret;
    }

    fprintf(stdout, "header.en=0x%08x\n"
                    "header.st=0x%08x\n"
                    "stream%u.af_error_afs_fifo_overflow_cnt=%u\n"
                    "stream%u.af_error_afs_fifo_underflow_cnt=%u\n"
                    "stream%u.af_error_tus_fifo_overflow_cnt=%u\n"
                    "stream%u.af_error_tus_fifo_underflow_cnt=%u\n"
                    "stream%u.af_error_tus_fifo_coherency_cnt=%u\n"
                    "stream%u.af_error_deadline_cnt=%u\n"
                    "stream%u.af_error_phy_cnt=%u\n"
                    "stream%u.af_error_timeout_cnt=%u\n"
                    "stream%u.af_error_access_cnt=%u\n"
                    "stream%u.ctrl=%u\n"
                    "stream%u.status=%u\n"
                    "stream%u.format=%u\n"
                    "stream%u.port=%u\n"
                    "stream%u.channel=%u\n"
                    "stream%u.sync=%u\n",
                    dump.en,
                    dump.st,
                    dump.id, dump.af_error_afs_fifo_overflow_cnt,
                    dump.id, dump.af_error_afs_fifo_underflow_cnt,
                    dump.id, dump.af_error_tus_fifo_overflow_cnt,
                    dump.id, dump.af_error_tus_fifo_underflow_cnt,
                    dump.id, dump.af_error_tus_fifo_coherency_cnt,
                    dump.id, dump.af_error_deadline_cnt,
                    dump.id, dump.af_error_phy_cnt,
                    dump.id, dump.af_error_timeout_cnt,
                    dump.id, dump.af_error_access_cnt,
                    dump.id, dump.ctrl,
                    dump.id, dump.status,
                    dump.id, dump.format,
                    dump.id, dump.port,
                    dump.id, dump.channel,
                    dump.id, dump.sync);

    return ret;
}

int main(int argc, char *argv[])
{
    int fd = 0, ret = 0;
    int c;
    bool dump_all_registers = false;
    bool dump_circ_buffer = false;
    bool dump_tunnel_info = false;
    bool dump_channel_info = false;
    bool dump_stream_info = false;
    bool log_mode = false;
    bool use_stdout = false;
    bool proc_mode = false;
    // Log level set will require 2 arguments while get needs one
    const int log_lvl_req_arg_get = 1;
    const int log_lvl_req_arg_set = 2;
    // Mode level set will required 2 arguments while set needs one
    const int mode_req_arg_get = 1;
    const int mode_req_arg_set = 2;
    int module_id = 0, log_level = -1;
    int proc_id = 0, mode = -1;
    int tunnel_id = -1, channel_id = -1, stream_id = -1;

    if (argc <= 1) {
        usage();
        return 0;
    }

    while ((c = getopt_long(argc, argv, "rcot:n:s:l:m:", long_options, NULL)) != -1) {
        switch (c) {
        case 'r':
            dump_all_registers = true;
            break;
        case 'c':
            dump_circ_buffer = true;
            break;
        case 'o':
            use_stdout = true;
            break;
        case 't':
            dump_tunnel_info = true;
            tunnel_id = atoi(optarg);
            break;
        case 'n':
            dump_channel_info = true;
            channel_id = atoi(optarg);
            break;
        case 's':
            dump_stream_info = true;
            stream_id = atoi(optarg);
            break;
        case 'l':
            log_mode = true;
            // reset optind by 1
            --optind;
            if ((optind + log_lvl_req_arg_get) != argc &&
                (optind + log_lvl_req_arg_set) != argc) {
                usage();
            }

            module_id = strtol(argv[optind], NULL, 0);

            if ((optind + log_lvl_req_arg_set) == argc) {
                // Move to the next before fetching the value
                optind++;
                log_level = strtol(argv[optind], NULL, 0);
                optind++;
            }
            break;
        case 'm':
            proc_mode = true;
            // reset optind by 1
            --optind;
            if ((optind + mode_req_arg_get) != argc &&
                (optind + mode_req_arg_set) != argc) {
                usage();
            }

            proc_id = strtol(argv[optind], NULL, 0);

            if ((optind + mode_req_arg_set) == argc) {
                // Move to the next before fetching the value
                optind++;
                mode = strtol(argv[optind], NULL, 0);
                optind++;
            }
            break;
        default:
            // Do nothing
            break;
        }
    }

    fd = open(DEBUG_DEV, O_RDONLY);
    if (-1 == fd) {
        fprintf(stderr, "Failed to open %s", DEBUG_DEV);
        ret = errno;
        goto exit;
    }

    if(log_mode == true) {
        log_lvl(fd, module_id, log_level);
    }

    if (proc_mode == true) {
        pmode(fd, proc_id, mode);
    }


    if (dump_all_registers || dump_circ_buffer) {
        static struct iaxxx_registers_dump dump;

        if ((ret = ioctl(fd, IAXXX_IOCTL_GET_REGISTERS_DUMP, &dump)) != 0) {
            fprintf(stderr, "Failed to ioctl %s IAXXX_IOCTL_GET_REGISTERS_DUMP, ret=%d", DEBUG_DEV, ret);
            ret = errno;
        } else {
            if (dump_all_registers)
                dump_all_regs(&dump, use_stdout);

            if (dump_circ_buffer)
                dump_circ_buf(&dump.circ_buffer_info);
        }
    }

    if (dump_tunnel_info) {
        if (tunnel_id >= 0 && tunnel_id < IAXXX_TUNNEL_MAX) {
            ret = dump_tunnel(fd, tunnel_id);
            if (ret) {
                fprintf(stderr, "Failed to dump_tunnel(), ret=%d", ret);
            }
        } else {
            fprintf(stderr, "Invalid tunnel_id %d\n", tunnel_id);
        }
    }

    if (dump_channel_info) {
        if (channel_id >= 0 && channel_id < IAXXX_CHANNEL_MAX) {
            ret = dump_channel(fd, channel_id);
            if (ret) {
                fprintf(stderr, "Failed to dump_channel(), ret=%d", ret);
            }
        } else {
            fprintf(stderr, "Invalid channel_id %d\n", channel_id);
        }
    }

    if (dump_stream_info) {
        if (stream_id >= 0 && stream_id < IAXXX_STREAM_MAX) {
            ret = dump_stream(fd, stream_id);
            if (ret) {
                fprintf(stderr, "Failed to dump_stream(), ret=%d", ret);
            }
        } else {
            fprintf(stderr, "Invalid stream_id %d\n", stream_id);
        }
    }

exit:
    if (-1 != fd)
        close(fd);

    return ret;
}