/** @file moal_debug.c
  *
  * @brief This file contains functions for debug proc file.
  *
  * Copyright (C) 2008-2009, Marvell International Ltd.
  *
  * This software file (the "File") is distributed by Marvell International
  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
  * (the "License").  You may use, redistribute and/or modify this File in
  * accordance with the terms and conditions of the License, a copy of which
  * is available by writing to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  *
  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  * this warranty disclaimer.
  *
  */

/********************************************************
Change log:
    11/03/2008: initial version
********************************************************/

#include	"moal_main.h"

/********************************************************
		Local Variables
********************************************************/
#ifdef CONFIG_PROC_FS
/** MLAN debug info */
static mlan_debug_info info;

/** Get info item size */
#define item_size(n) (sizeof(info.n))
/** Get info item address */
#define item_addr(n) ((t_u32) &(info.n))

/** Get moal_private member size */
#define item_priv_size(n) (sizeof ((moal_private *)0)->n)
/** Get moal_private member address */
#define item_priv_addr(n) ((t_u32) &((moal_private *)0)->n)

/** Get moal_handle member size */
#define item_handle_size(n) (sizeof ((moal_handle *)0)->n)
/** Get moal_handle member address */
#define item_handle_addr(n) ((t_u32) &((moal_handle *)0)->n)

/** Debug data */
struct debug_data
{
    /** Name */
    char name[32];
    /** Size */
    t_u32 size;
    /** Address */
    t_u32 addr;
};

/** Private debug data */
struct debug_data_priv
{
    /** moal_private handle */
    moal_private *priv;
    /** Debug items */
    struct debug_data *items;
    /** numbre of item */
    int num_of_items;
};

static struct debug_data items[] = {
    {"int_counter", item_size(int_counter), item_addr(int_counter)},
    {"wmm_ac_vo", item_size(packets_out[WMM_AC_VO]),
     item_addr(packets_out[WMM_AC_VO])},
    {"wmm_ac_vi", item_size(packets_out[WMM_AC_VI]),
     item_addr(packets_out[WMM_AC_VI])},
    {"wmm_ac_be", item_size(packets_out[WMM_AC_BE]),
     item_addr(packets_out[WMM_AC_BE])},
    {"wmm_ac_bk", item_size(packets_out[WMM_AC_BK]),
     item_addr(packets_out[WMM_AC_BK])},
    {"max_tx_buf_size", item_size(max_tx_buf_size), item_addr(max_tx_buf_size)},
    {"tx_buf_size", item_size(tx_buf_size), item_addr(tx_buf_size)},
    {"ps_mode", item_size(ps_mode), item_addr(ps_mode)},
    {"ps_state", item_size(ps_state), item_addr(ps_state)},
    {"is_deep_sleep", item_size(is_deep_sleep), item_addr(is_deep_sleep)},
    {"wakeup_dev_req", item_size(pm_wakeup_card_req),
     item_addr(pm_wakeup_card_req)},
    {"wakeup_tries", item_size(pm_wakeup_fw_try), item_addr(pm_wakeup_fw_try)},
    {"hs_configured", item_size(is_hs_configured), item_addr(is_hs_configured)},
    {"hs_activated", item_size(hs_activated), item_addr(hs_activated)},
    {"num_tx_timeout", item_size(num_tx_timeout), item_addr(num_tx_timeout)},
    {"num_cmd_timeout", item_size(num_cmd_timeout), item_addr(num_cmd_timeout)},
    {"timeout_cmd_id", item_size(timeout_cmd_id), item_addr(timeout_cmd_id)},
    {"timeout_cmd_act", item_size(timeout_cmd_act), item_addr(timeout_cmd_act)},
    {"last_cmd_id", item_size(last_cmd_id), item_addr(last_cmd_id)},
    {"last_cmd_act", item_size(last_cmd_act), item_addr(last_cmd_act)},
    {"last_cmd_index", item_size(last_cmd_index), item_addr(last_cmd_index)},
    {"last_cmd_resp_id", item_size(last_cmd_resp_id),
     item_addr(last_cmd_resp_id)},
    {"last_cmd_resp_index", item_size(last_cmd_resp_index),
     item_addr(last_cmd_resp_index)},
    {"last_event", item_size(last_event), item_addr(last_event)},
    {"last_event_index", item_size(last_event_index),
     item_addr(last_event_index)},
    {"num_cmd_h2c_fail", item_size(num_cmd_host_to_card_failure),
     item_addr(num_cmd_host_to_card_failure)},
    {"num_cmd_sleep_cfm_fail",
     item_size(num_cmd_sleep_cfm_host_to_card_failure),
     item_addr(num_cmd_sleep_cfm_host_to_card_failure)},
    {"num_tx_h2c_fail", item_size(num_tx_host_to_card_failure),
     item_addr(num_tx_host_to_card_failure)},
    {"num_evt_deauth", item_size(num_event_deauth),
     item_addr(num_event_deauth)},
    {"num_evt_disassoc", item_size(num_event_disassoc),
     item_addr(num_event_disassoc)},
    {"num_evt_link_lost", item_size(num_event_link_lost),
     item_addr(num_event_link_lost)},
    {"num_cmd_deauth", item_size(num_cmd_deauth), item_addr(num_cmd_deauth)},
    {"num_cmd_assoc_ok", item_size(num_cmd_assoc_success),
     item_addr(num_cmd_assoc_success)},
    {"num_cmd_assoc_fail", item_size(num_cmd_assoc_failure),
     item_addr(num_cmd_assoc_failure)},
    {"cmd_sent", item_size(cmd_sent), item_addr(cmd_sent)},
    {"data_sent", item_size(data_sent), item_addr(data_sent)},
    {"mp_rd_bitmap", item_size(mp_rd_bitmap), item_addr(mp_rd_bitmap)},
    {"curr_rd_port", item_size(curr_rd_port), item_addr(curr_rd_port)},
    {"mp_wr_bitmap", item_size(mp_wr_bitmap), item_addr(mp_wr_bitmap)},
    {"curr_wr_port", item_size(curr_wr_port), item_addr(curr_wr_port)},
    {"cmd_resp_received", item_size(cmd_resp_received),
     item_addr(cmd_resp_received)},
    {"event_received", item_size(event_received), item_addr(event_received)},

    {"ioctl_pending", item_handle_size(ioctl_pending),
     item_handle_addr(ioctl_pending)},
    {"tx_pending", item_handle_size(tx_pending), item_handle_addr(tx_pending)},
    {"rx_pending", item_handle_size(rx_pending), item_handle_addr(rx_pending)},
    {"malloc_count", item_handle_size(malloc_count),
     item_handle_addr(malloc_count)},
    {"lock_count", item_handle_size(lock_count), item_handle_addr(lock_count)},
};

/** Private debug data */
static struct debug_data_priv items_priv;

/********************************************************
		Global Variables
********************************************************/

/********************************************************
		Local Functions
********************************************************/
/**
 *  @brief Proc read function
 *
 *  @param page	   Pointer to buffer
 *  @param s       Read data starting position
 *  @param off     Offset
 *  @param cnt     Counter
 *  @param eof     End of file flag
 *  @param data    Output data
 *
 *  @return 	   Number of output data
 */
static int
woal_debug_read(char *page, char **s, off_t off, int cnt, int *eof, void *data)
{
    int val = 0;
    int i;
    char *p = page;
    struct debug_data *d = ((struct debug_data_priv *) data)->items;
    moal_private *priv = ((struct debug_data_priv *) data)->priv;

    if (MODULE_GET == 0)
        return MLAN_STATUS_FAILURE;

    /* Get debug information */
    if (woal_get_debug_info(priv, MOAL_PROC_WAIT, &info)) {
        *eof = 1;
        goto exit;
    }
    for (i = 0; i < ((struct debug_data_priv *) data)->num_of_items; i++) {
        if (d[i].size == 1)
            val = *((t_u8 *) d[i].addr);
        else if (d[i].size == 2)
            val = *((t_u16 *) d[i].addr);
        else if (d[i].size == 4)
            val = *((t_u32 *) d[i].addr);
        else {
            int j;
            p += sprintf(p, "%s=", d[i].name);
            for (j = 0; j < d[i].size; j += 2) {
                val = *(t_u16 *) (d[i].addr + j);
                p += sprintf(p, "0x%x ", val);
            }
            p += sprintf(p, "\n");
            continue;
        }
        if (strstr(d[i].name, "id"))
            p += sprintf(p, "%s=0x%x\n", d[i].name, val);
        else
            p += sprintf(p, "%s=%d\n", d[i].name, val);
    }
    if (info.tx_tbl_num) {
        p += sprintf(p, "Tx BA stream table:\n");
        for (i = 0; i < info.tx_tbl_num; i++) {
            p += sprintf(p, "tid = %d, ra = %02x:%02x:%02x:%02x:%02x:%02x\n",
                         (int) info.tx_tbl[i].tid, info.tx_tbl[i].ra[0],
                         info.tx_tbl[i].ra[1], info.tx_tbl[i].ra[2],
                         info.tx_tbl[i].ra[3], info.tx_tbl[i].ra[4],
                         info.tx_tbl[i].ra[5]);
        }
    }
    if (info.rx_tbl_num) {
        p += sprintf(p, "Rx reorder table:\n");
        for (i = 0; i < info.rx_tbl_num; i++) {
            int j;

            p += sprintf(p,
                         "tid = %d, ta =  %02x:%02x:%02x:%02x:%02x:%02x, start_win = %d, "
                         "win_size = %d, buffer: ", (int) info.rx_tbl[i].tid,
                         info.rx_tbl[i].ta[0], info.rx_tbl[i].ta[1],
                         info.rx_tbl[i].ta[2], info.rx_tbl[i].ta[3],
                         info.rx_tbl[i].ta[4], info.rx_tbl[i].ta[5],
                         (int) info.rx_tbl[i].start_win,
                         (int) info.rx_tbl[i].win_size);
            for (j = 0; j < info.rx_tbl[i].win_size; j++) {
                if (info.rx_tbl[i].buffer[j] == MTRUE)
                    p += sprintf(p, "1 ");
                else
                    p += sprintf(p, "0 ");
            }
            p += sprintf(p, "\n");
        }
    }
  exit:
    MODULE_PUT;
    return p - page;
}

/**
 *  @brief Proc write function
 *
 *  @param f	   File pointer
 *  @param buf     Pointer to data buffer
 *  @param cnt     Data number to write
 *  @param data    Data to write
 *
 *  @return 	   Number of data
 */
static int
woal_debug_write(struct file *f, const char *buf, unsigned long cnt, void *data)
{
    int r, i;
    char *pdata;
    char *p;
    char *p0;
    char *p1;
    char *p2;
    struct debug_data *d = ((struct debug_data_priv *) data)->items;
    moal_private *priv = ((struct debug_data_priv *) data)->priv;

    if (MODULE_GET == 0)
        return MLAN_STATUS_FAILURE;

    pdata = (char *) kmalloc(cnt, GFP_ATOMIC);
    if (pdata == NULL) {
        MODULE_PUT;
        return 0;
    }

    if (copy_from_user(pdata, buf, cnt)) {
        PRINTM(MERROR, "Copy from user failed\n");
        kfree(pdata);
        MODULE_PUT;
        return 0;
    }

    p0 = pdata;
    for (i = 0; i < ((struct debug_data_priv *) data)->num_of_items; i++) {
        do {
            p = strstr(p0, d[i].name);
            if (p == NULL)
                break;
            p1 = strchr(p, '\n');
            if (p1 == NULL)
                break;
            p0 = p1++;
            p2 = strchr(p, '=');
            if (!p2)
                break;
            p2++;
            r = woal_string_to_number(p2);
            if (d[i].size == 1)
                *((t_u8 *) d[i].addr) = (t_u8) r;
            else if (d[i].size == 2)
                *((t_u16 *) d[i].addr) = (t_u16) r;
            else if (d[i].size == 4)
                *((t_u32 *) d[i].addr) = (t_u32) r;
            break;
        } while (MTRUE);
    }
    kfree(pdata);

    /* Set debug information */
    if (woal_set_debug_info(priv, MOAL_IOCTL_WAIT, &info)) {
        MODULE_PUT;
        return 0;
    }

    MODULE_PUT;
    return cnt;
}

/********************************************************
		Global Functions
********************************************************/
/**
 *  @brief Create debug proc file
 *
 *  @param priv	   A pointer to a moal_private structure
 *
 *  @return 	   None
 */
void
woal_debug_entry(moal_private * priv)
{
    struct proc_dir_entry *r;

    ENTER();

    if (priv->proc_entry == NULL)
        return;

    if (woal_get_debug_info(priv, MOAL_PROC_WAIT, &info)) {
        LEAVE();
        return;
    }
    /* Setup MOAL debug info */
    if (priv->bss_type == MLAN_BSS_TYPE_STA) {
        items_priv.priv = priv;
        items_priv.items = items;
        items_priv.num_of_items = sizeof(items) / sizeof(items[0]);
        items[items_priv.num_of_items - 1].addr += (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 2].addr += (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 3].addr += (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 4].addr += (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 5].addr += (t_u32) (priv->phandle);
    }
    /* Create proc entry */
    r = create_proc_entry("debug", 0644, priv->proc_entry);
    if (r == NULL) {
        LEAVE();
        return;
    }
    /* Populate proc entry handlers */
    if (priv->bss_type == MLAN_BSS_TYPE_STA)
        r->data = &items_priv;
    r->read_proc = woal_debug_read;
    r->write_proc = woal_debug_write;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
    r->owner = THIS_MODULE;
#endif

    LEAVE();
}

/**
 *  @brief Remove proc file
 *
 *  @param priv	 A pointer to a moal_private structure
 *
 *  @return 	 None
 */
void
woal_debug_remove(moal_private * priv)
{
    ENTER();
    if (priv->bss_type == MLAN_BSS_TYPE_STA) {
        /* Reset MOAL debug info */
        items[items_priv.num_of_items - 1].addr -= (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 2].addr -= (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 3].addr -= (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 4].addr -= (t_u32) (priv->phandle);
        items[items_priv.num_of_items - 5].addr -= (t_u32) (priv->phandle);
    }
    /* Remove proc entry */
    remove_proc_entry("debug", priv->proc_entry);

    LEAVE();
}
#endif