/**
 * Copyright (c) 2014 Redpine Signals Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#include <linux/firmware.h>
#include "rsi_usb.h"

/**
 * rsi_copy_to_card() - This function includes the actual funtionality of
 *                      copying the TA firmware to the card.Basically this
 *                      function includes opening the TA file,reading the TA
 *                      file and writing their values in blocks of data.
 * @common: Pointer to the driver private structure.
 * @fw: Pointer to the firmware value to be written.
 * @len: length of firmware file.
 * @num_blocks: Number of blocks to be written to the card.
 *
 * Return: 0 on success and -1 on failure.
 */
static int rsi_copy_to_card(struct rsi_common *common,
                            const u8 *fw,
                            u32 len,
                            u32 num_blocks)
{
        struct rsi_hw *adapter = common->priv;
        struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
        u32 indx, ii;
        u32 block_size = dev->tx_blk_size;
        u32 lsb_address;
        u32 base_address;

        base_address = TA_LOAD_ADDRESS;

        for (indx = 0, ii = 0; ii < num_blocks; ii++, indx += block_size) {
                lsb_address = base_address;
                if (rsi_usb_write_register_multiple(adapter,
                                                    lsb_address,
                                                    (u8 *)(fw + indx),
                                                    block_size)) {
                        rsi_dbg(ERR_ZONE,
                                "%s: Unable to load %s blk\n", __func__,
                                FIRMWARE_RSI9113);
                        return -EIO;
                }
                rsi_dbg(INIT_ZONE, "%s: loading block: %d\n", __func__, ii);
                base_address += block_size;
        }

        if (len % block_size) {
                lsb_address = base_address;
                if (rsi_usb_write_register_multiple(adapter,
                                                    lsb_address,
                                                    (u8 *)(fw + indx),
                                                    len % block_size)) {
                        rsi_dbg(ERR_ZONE,
                                "%s: Unable to load %s blk\n", __func__,
                                FIRMWARE_RSI9113);
                        return -EIO;
                }
        }
        rsi_dbg(INIT_ZONE,
                "%s: Succesfully loaded %s instructions\n", __func__,
                FIRMWARE_RSI9113);

        rsi_dbg(INIT_ZONE, "%s: loaded firmware\n", __func__);
        return 0;
}

/**
 * rsi_usb_rx_thread() - This is a kernel thread to receive the packets from
 *                       the USB device.
 * @common: Pointer to the driver private structure.
 *
 * Return: None.
 */
void rsi_usb_rx_thread(struct rsi_common *common)
{
        struct rsi_hw *adapter = common->priv;
        struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
        int status;

        do {
                rsi_wait_event(&dev->rx_thread.event, EVENT_WAIT_FOREVER);

                if (atomic_read(&dev->rx_thread.thread_done))
                        goto out;

                mutex_lock(&common->tx_rxlock);
                status = rsi_read_pkt(common, 0);
                if (status) {
                        rsi_dbg(ERR_ZONE, "%s: Failed To read data", __func__);
                        mutex_unlock(&common->tx_rxlock);
                        return;
                }
                mutex_unlock(&common->tx_rxlock);
                rsi_reset_event(&dev->rx_thread.event);
                if (adapter->rx_urb_submit(adapter)) {
                        rsi_dbg(ERR_ZONE,
                                "%s: Failed in urb submission", __func__);
                        return;
                }
        } while (1);

out:
        rsi_dbg(INFO_ZONE, "%s: Terminated thread\n", __func__);
        complete_and_exit(&dev->rx_thread.completion, 0);
}


/**
 * rsi_load_ta_instructions() - This function includes the actual funtionality
 *                              of loading the TA firmware.This function also
 *                              includes opening the TA file,reading the TA
 *                              file and writing their value in blocks of data.
 * @common: Pointer to the driver private structure.
 *
 * Return: status: 0 on success, -1 on failure.
 */
static int rsi_load_ta_instructions(struct rsi_common *common)
{
        struct rsi_hw *adapter = common->priv;
        struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
        const struct firmware *fw_entry = NULL;
        u32 block_size = dev->tx_blk_size;
        const u8 *fw;
        u32 num_blocks, len;
        int status = 0;

        status = request_firmware(&fw_entry, FIRMWARE_RSI9113, adapter->device);
        if (status < 0) {
                rsi_dbg(ERR_ZONE, "%s Firmware file %s not found\n",
                        __func__, FIRMWARE_RSI9113);
                return status;
        }

        /* Copy firmware into DMA-accessible memory */
        fw = kmemdup(fw_entry->data, fw_entry->size, GFP_KERNEL);
        if (!fw) {
                status = -ENOMEM;
                goto out;
        }
        len = fw_entry->size;

        if (len % 4)
                len += (4 - (len % 4));

        num_blocks = (len / block_size);

        rsi_dbg(INIT_ZONE, "%s: Instruction size:%d\n", __func__, len);
        rsi_dbg(INIT_ZONE, "%s: num blocks: %d\n", __func__, num_blocks);

        status = rsi_copy_to_card(common, fw, len, num_blocks);
        kfree(fw);

out:
        release_firmware(fw_entry);
        return status;
}

/**
 * rsi_device_init() - This Function Initializes The HAL.
 * @common: Pointer to the driver private structure.
 *
 * Return: 0 on success, -1 on failure.
 */
int rsi_usb_device_init(struct rsi_common *common)
{
        if (rsi_load_ta_instructions(common))
                return -EIO;

        return 0;
                }