/*
 * Copyright (C) 2018 Spreadtrum Communications Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/atomic.h>
#include <linux/compat.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kdev_t.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/semaphore.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/types.h>
#include <linux/vmalloc.h>
#include <linux/vt_kern.h>
#include <linux/workqueue.h>

#include "include/debug.h"
#include "include/hci.h"
#include "include/sdio.h"

static struct semaphore sem_id;
static struct bt_data_interface_cb_t* bt_data_if_cb;
static int need_indicate_cp2_woble = 0;

int resume_transfer_upper(const unsigned char* buf, int count);

int set_need_indicate_cp2_woble(int set)
{
    pr_err("%s %d\n", __func__, set);
    need_indicate_cp2_woble = set;
    return 0;
}

static int marlin_sdio_tx_cb(int chn, struct mbuf_t* head, struct mbuf_t* tail, int num)
{
    int i;
    struct mbuf_t* pos = NULL;
    BT_VER("%s channel: %d, head: %p, tail: %p num: %d\n", __func__, chn, head, tail, num);

    pos = head;

    for (i = 0; i < num; i++, pos = pos->next) {
        kfree(pos->buf);
        pos->buf = NULL;
    }

    if ((sprdwcn_bus_list_free(chn, head, tail, num)) == 0) {
        BT_VER("%s sprdwcn_bus_list_free() success\n", __func__);
        up(&sem_id);
    } else {
        pr_err("%s sprdwcn_bus_list_free() fail\n", __func__);
    }

    return 0;
}

static int marlin_sdio_rx_cb(int chn, struct mbuf_t* head, struct mbuf_t* tail, int num)
{
    int block_size;

    block_size = ((head->buf[2] & 0x7F) << 9) + (head->buf[1] << 1) + (head->buf[0] >> 7);
    BT_VER("%s +++\n", __func__);

    if (bt_data_if_cb == NULL) {
        return -1;
    }

    BT_VERDUMP((unsigned char*)head->buf + BT_SDIO_HEAD_LEN, block_size);

    bt_data_if_cb->recv((unsigned char*)head->buf + BT_SDIO_HEAD_LEN, block_size);
    sprdwcn_bus_push_list(chn, head, tail, num);
    BT_VER("%s ---\n", __func__);

    return 0;
}

int marlin_sdio_write(const unsigned char* buf, int count)
{
    int num = 1, ret;
    struct mbuf_t *tx_head = NULL, *tx_tail = NULL;
    unsigned char* block = NULL;
    const unsigned char* tmp_buf = buf + 1;
    unsigned short op = 0;
    int i = 0;

    STREAM_TO_UINT16(op, tmp_buf);

    if (buf[0] == 0x1) {
        BT_DEBUG("%s +++ op 0x%04X\n", __func__, op);
    }

    block = kmalloc(count + BT_SDIO_HEAD_LEN, GFP_KERNEL);

    if (!block) {
        pr_err("%s kmalloc failed\n", __func__);
        return -ENOMEM;
    }

    memset(block, 0, count + BT_SDIO_HEAD_LEN);
    memcpy(block + BT_SDIO_HEAD_LEN, buf, count);

    down(&sem_id);
    ret = sprdwcn_bus_list_alloc(BT_TX_CHANNEL, &tx_head, &tx_tail, &num);

    if (ret) {
        pr_err("%s sprdwcn_bus_list_alloc failed: %d\n", __func__, ret);
        up(&sem_id);
        return -ENOMEM;
    }

    tx_head->buf = block;
    tx_head->len = count;
    tx_head->next = NULL;
    if (op == 0xfd09 || op == 0xfd0a || op == 0xfd0d) {
        unsigned char tmp[10] = { 0 };
        BT_VER("%s\n", __func__);
        for (i = 0; i < count; i++) {
            tmp[i % 10] = buf[i];
            if (i % 10 == 9) {
                BT_VER("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9]);
                memset(tmp, 0, 10);
            }
        }
        if (i % 10 < 9) {
            BT_VER("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9]);
        }
        BT_VER("end %d \n", i);
    }
    BT_VERDUMP(block, count);

    ret = sprdwcn_bus_push_list(BT_TX_CHANNEL, tx_head, tx_tail, num);

    if (ret) {
        pr_err("%s sprdwcn_bus_push_list failed: %d\n", __func__, ret);
        kfree(tx_head->buf);
        tx_head->buf = NULL;
        sprdwcn_bus_list_free(BT_TX_CHANNEL, tx_head, tx_tail, num);
        return -EBUSY;
    }

    if (buf[0] == 0x1) {
        BT_DEBUG("%s ---\n", __func__);
    }

    /*
        if (op == 0xfd09)
        {
            unsigned char woble_enable = buf[4];
            unsigned char sleep_mod = buf[5];

            if (woble_enable == 1 && sleep_mod == 1 || woble_enable == 0) //WOBLE_MOD_ENABLE, WOBLE_SLEEP_MOD_COULD_NOT_KNOW
            {
                set_need_indicate_cp2_woble(0);
                pr_err("%s woble_enable %d sleep_mod %d\n", __func__, woble_enable, sleep_mod);
            }

        }
    */
    return count;
}

// 04 05 04 00 00 02 13
void hci_add_device_to_wakeup_list_rtk(void);
void hci_disconnect(void);
unsigned char resume_rxmsg[7] = { 0x04, 0x05, 0x04, 0, 0x10, 0x0, 0x13 }; //
// unsigned char connect_event[22]={0x04,0x3e,0x13,0x01,0x00,0x10,0x00,0x00,0x00,0x20,0xec,0x8e,0xde,0xf3,0x0c,0x24,0x00,0x00,0x00,0xc8,0x00,0x00  };
extern unsigned char dis_flag;
int i = 0;
// int  event_nu=10;
int list_time = 0x11;
extern int early_flag;
// extern  int uni_sus_flag ;
// extern  int uni_resu_flag;
extern int dis_cmd_flag;
extern unsigned char red_bt_flag; //区分蓝牙，红外待机标志；0x11:红外 0x22: bt
//extern int  firs_dis_flag;
static int bt_tx_powerchange(int channel, int is_resume)
{

    pr_err("%s channel %d is_resume %d need_indicate_cp2_woble %d", __func__, channel, is_resume, need_indicate_cp2_woble);

    if (strcmp(WOBLE_TYPE, "disable")) {
        unsigned long power_state = marlin_get_power_state();
        pr_info("%s is_resume =%d", __func__, is_resume);
        if (test_bit(MARLIN_BLUETOOTH, &power_state)) {
            if (!is_resume) {

#ifdef UNISOC_AMLOGIC_SUSPEND
                if (dis_cmd_flag == 0x11) {
                    dis_cmd_flag = 0x22;
                    early_flag = 0x22;
                    hci_disconnect();
                    pr_err("suspen_disconnect1\n");
                }
#else
                hci_disconnect();
                pr_err("suspen_disconnect2\n");
#endif
                //pr_err("pause_start\n");
                #if 0
                hci_cleanup_wakeup_list();
                hci_add_device_to_wakeup_list_rtk();
                hci_add_device_to_wakeup_list();
                #endif
                if (0x22 == red_bt_flag)  //BT effect
                {       
                    hci_cleanup_wakeup_list();
                    hci_add_device_to_wakeup_list_rtk();
                    hci_add_device_to_wakeup_list();  
                    hci_set_scan_parameters();
                    hci_set_scan_enable(1);
                    //pr_err("gy_0x__22");
                } else {  //red
                    hci_cleanup_wakeup_list();
                    hci_set_scan_enable(0);
                }
                hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_NOT_RESUME);
                hci_set_ap_start_sleep();
            } else {
                /*
                unsigned char payload[4] = {0};
                // int block_size = 4;
                payload[0] = 0x04;
                payload[1] = 0x10;
                payload[2] = 0x01;
                payload[3] = 0x00;
                */
#ifdef UNISOC_AMLOGIC_SUSPEND
                hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_RESUME);
                hci_set_scan_enable(0);
                // pr_err("resume_null1...\n");  //
#else
                hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_RESUME);
                hci_set_scan_enable(0);
                if ( 0x22 == red_bt_flag)
                {
                    resume_transfer_upper(resume_rxmsg, 7);
                }
                pr_err("resume_null2...\n"); //
#endif
                // bt_data_if_cb->recv(payload, block_size);
            }
        }
        /*
        if (!need_indicate_cp2_woble)
        {
            return 0;
        }

        if (BT_TX_CHANNEL != channel)
        {
            return -1;
        }

        if (!is_resume)
        {
            hci_woble_enable();
        }
        */
    }

    return 0;
}

static struct mchn_ops_t bt_rx_ops = {
    .channel = BT_RX_CHANNEL,
    .hif_type = HW_TYPE_SDIO,
    .inout = BT_RX_INOUT,
    .pool_size = BT_RX_POOL_SIZE,
    .pop_link = marlin_sdio_rx_cb,
};

static struct mchn_ops_t bt_tx_ops = {
    .channel = BT_TX_CHANNEL,
    .hif_type = HW_TYPE_SDIO,
    .inout = BT_TX_INOUT,
    .pool_size = BT_TX_POOL_SIZE,
    .pop_link = marlin_sdio_tx_cb,
    .power_notify = bt_tx_powerchange,
};

int marlin_sdio_init(struct bt_data_interface_cb_t* cb)
{
    int ret = 0;
    pr_err("%s\n", __func__);
    ret = sprdwcn_bus_chn_init(&bt_rx_ops);

    if (ret) {
        pr_err("%s sprdwcn_bus_chn_init err chn %d\n", __func__, bt_rx_ops.channel);
    }

    ret = sprdwcn_bus_chn_init(&bt_tx_ops);

    if (ret) {
        pr_err("%s sprdwcn_bus_chn_init err chn %d\n", __func__, bt_tx_ops.channel);
    }

    bt_data_if_cb = cb;
    sema_init(&sem_id, BT_TX_POOL_SIZE - 1);
    return 0;
}

void marlin_sdio_cleanup(void)
{
    sprdwcn_bus_chn_deinit(&bt_rx_ops);
    sprdwcn_bus_chn_deinit(&bt_tx_ops);
}

static struct bt_data_interface_t marlin_sdio_interface = {
    .size = sizeof(struct bt_data_interface_t),
    .init = marlin_sdio_init,
    .cleanup = marlin_sdio_cleanup,
    .write = marlin_sdio_write
};

struct bt_data_interface_t* get_marlin_sdio_interface(void)
{
    return &marlin_sdio_interface;
}