/*
 * Copyright (C) 2015 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/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/kdev_t.h>
#include <linux/tty.h>
#include <linux/vt_kern.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/semaphore.h>
#include <linux/vmalloc.h>
#include <linux/atomic.h>
#ifdef CONFIG_OF
#include <linux/of_device.h>
#endif
#include <linux/compat.h>
#include <linux/tty_flip.h>
#include <linux/kthread.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/version.h>

#include <marlin_platform.h>
#include "tty.h"
#include "lpm.h"
#include "rfkill.h"
#include "dump.h"
#include "woble.h"
#include "alignment/sitm.h"

static unsigned int log_level = MTTY_LOG_LEVEL_NONE;

#define BT_VER(fmt, ...)						\
	do {										\
		if (log_level == MTTY_LOG_LEVEL_VER)	\
			pr_err(fmt, ##__VA_ARGS__);			\
	} while (0)


static struct semaphore sem_id;

struct rx_data {
	unsigned int channel;
	struct mbuf_t *head;
	struct mbuf_t *tail;
	unsigned int num;
	struct list_head entry;
};

struct mtty_device {
	struct mtty_init_data   *pdata;
	struct tty_port *port;
	struct tty_struct   *tty;
	struct tty_driver   *driver;

	/* mtty state */
	atomic_t state;
	/*spinlock_t    rw_lock;*/
	struct mutex    rw_mutex;
	struct list_head rx_head;
	/*struct tasklet_struct rx_task;*/
	struct work_struct bt_rx_work;
	struct workqueue_struct *bt_rx_workqueue;
};

static struct mtty_device *mtty_dev;
static unsigned int que_task = 1;
static int que_sche = 1;

static bool is_dumped;
static bool is_user_debug;
bt_host_data_dump *data_dump;

static ssize_t dumpmem_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	if (buf[0] == 2) {
		pr_info("Set is_user_debug true!\n");
		is_user_debug = true;
		return 0;
	}

	if (is_dumped == false) {
		pr_info("mtty BT start dump cp mem !\n");
		//mdbg_assert_interface("BT command timeout assert !!!");
		bt_host_data_printf();
		if (data_dump != NULL) {
			data_dump = NULL;
			vfree(data_dump);
		}
	} else {
		pr_info("mtty BT has dumped cp mem, pls restart phone!\n");
	}
	is_dumped = true;

	return 0;
}

static DEVICE_ATTR_WO(dumpmem);

static ssize_t chipid_show(struct device *dev,
	   struct device_attribute *attr, char *buf)
{
	int i = 0, id;
	const char *id_str = NULL;

	id = wcn_get_chip_type();
	id_str = wcn_get_chip_name();
	pr_info("%s: chipid: %d, chipid_str: %s", __func__, id, id_str);

	i = scnprintf(buf, PAGE_SIZE, "%d/", id);
	pr_info("%s: buf: %s, i = %d", __func__, buf, i);
	strcat(buf, id_str);
	i += scnprintf(buf + i, PAGE_SIZE - i, buf + i);
	pr_info("%s: buf: %s, i = %d", __func__, buf, i);
	return i;
}

static DEVICE_ATTR_RO(chipid);

static ssize_t ant_num_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	int num = 2;

	num = marlin_get_ant_num();
	pr_err("%s: %d", __func__, num);

	return sprintf(buf, "%d", num);
}

static DEVICE_ATTR_RO(ant_num);

static struct attribute *bluetooth_attrs[] = {
	&dev_attr_dumpmem.attr,
	&dev_attr_chipid.attr,
	&dev_attr_ant_num.attr,
	NULL,
};

static struct attribute_group bluetooth_group = {
	.name = NULL,
	.attrs = bluetooth_attrs,
};

static void hex_dump(unsigned char *bin, size_t binsz)
{
	char *str, hex_str[] = "0123456789ABCDEF";
	size_t i;

	str = (char *)vmalloc(binsz * 3);
	if (!str) {
		return;
	}

	for (i = 0; i < binsz; i++) {
		str[(i * 3) + 0] = hex_str[(bin[i] >> 4) & 0x0F];
		str[(i * 3) + 1] = hex_str[(bin[i]) & 0x0F];
		str[(i * 3) + 2] = ' ';
	}
	str[(binsz * 3) - 1] = 0x00;
	pr_info("%s\n", str);
	vfree(str);
}

static void hex_dump_block(unsigned char *bin, size_t binsz)
{
#define HEX_DUMP_BLOCK_SIZE 20
	int loop = binsz / HEX_DUMP_BLOCK_SIZE;
	int tail = binsz % HEX_DUMP_BLOCK_SIZE;
	int i;

	if (!loop) {
		hex_dump(bin, binsz);
		return;
	}

	for (i = 0; i < loop; i++) {
		hex_dump(bin + i * HEX_DUMP_BLOCK_SIZE, HEX_DUMP_BLOCK_SIZE);
	}

	if (tail)
		hex_dump(bin + i * HEX_DUMP_BLOCK_SIZE, tail);
}

/* static void mtty_rx_task(unsigned long data) */
static void mtty_rx_work_queue(struct work_struct *work)
{
	int i, ret = 0;
	/*struct mtty_device *mtty = (struct mtty_device *)data;*/
	struct mtty_device *mtty;
	struct rx_data *rx = NULL;

	que_task = que_task + 1;
	if (que_task > 65530)
		que_task = 0;
	pr_info("mtty que_task= %d\n", que_task);
	que_sche = que_sche - 1;

	mtty = container_of(work, struct mtty_device, bt_rx_work);
	if (unlikely(!mtty)) {
		pr_err("mtty_rx_task mtty is NULL\n");
		return;
	}

	if (atomic_read(&mtty->state) == MTTY_STATE_OPEN) {
		do {
			mutex_lock(&mtty->rw_mutex);
			if (list_empty_careful(&mtty->rx_head)) {
				pr_err("mtty over load queue done\n");
				mutex_unlock(&mtty->rw_mutex);
				break;
			}
			rx = list_first_entry_or_null(&mtty->rx_head,
				struct rx_data, entry);
			if (!rx) {
				pr_err("mtty over load queue abort\n");
				mutex_unlock(&mtty->rw_mutex);
				break;
			}
			list_del(&rx->entry);
			mutex_unlock(&mtty->rw_mutex);

			pr_err("mtty over load working at channel: %d, len: %d\n",
					rx->channel, rx->head->len);
			for (i = 0; i < rx->head->len; i++) {
				ret = tty_insert_flip_char(mtty->port,
						*(rx->head->buf+i), TTY_NORMAL);
				if (ret != 1) {
					i--;
					continue;
				} else {
					tty_flip_buffer_push(mtty->port);
				}
			}
			pr_err("mtty over load cut channel: %d\n", rx->channel);
			kfree(rx->head->buf);
			kfree(rx);

		} while (1);
	} else {
		pr_info("mtty status isn't open, status:%d\n", atomic_read(&mtty->state));
	}
}

static int mtty_rx_cb(int chn, struct mbuf_t *head, struct mbuf_t *tail, int num)
{
	int ret = 0, block_size;
	struct rx_data *rx;
#ifndef WOBLE_FUN
	bt_wakeup_host();
#endif
	block_size = ((head->buf[2] & 0x7F) << 9) + (head->buf[1] << 1) + (head->buf[0] >> 7);

	if (log_level == MTTY_LOG_LEVEL_VER) {
		BT_VER("%s dump head: %d, channel: %d, num: %d\n", __func__, BT_SDIO_HEAD_LEN, chn, num);
		hex_dump_block((unsigned char *)head->buf, BT_SDIO_HEAD_LEN);
		BT_VER("%s dump block %d\n", __func__, block_size);
		hex_dump_block((unsigned char *)head->buf + BT_SDIO_HEAD_LEN, block_size);
	}
	if (is_user_debug) {
		bt_host_data_save((unsigned char *)head->buf + BT_SDIO_HEAD_LEN, block_size, BT_DATA_IN);
	}

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

	if (atomic_read(&mtty_dev->state) == MTTY_STATE_CLOSE) {
		pr_err("%s mtty bt is closed abnormally\n", __func__);
		sprdwcn_bus_push_list(chn, head, tail, num);
		return -1;
	}

	if (mtty_dev != NULL) {
		if (!work_pending(&mtty_dev->bt_rx_work)) {
			BT_VER("%s tty_insert_flip_string", __func__);
			ret = tty_insert_flip_string(mtty_dev->port,
				(unsigned char *)head->buf + BT_SDIO_HEAD_LEN,
				block_size);   // -BT_SDIO_HEAD_LEN
			BT_VER("%s ret: %d, len: %d\n", __func__, ret, block_size);
			if (ret)
				tty_flip_buffer_push(mtty_dev->port);
			if (ret == (block_size)) {
				BT_VER("%s send success", __func__);
				sprdwcn_bus_push_list(chn, head, tail, num);
				return 0;
			}
		}

		rx = kmalloc(sizeof(struct rx_data), GFP_KERNEL);
		if (rx == NULL) {
			pr_err("%s rx == NULL\n", __func__);
			sprdwcn_bus_push_list(chn, head, tail, num);
			return -ENOMEM;
		}

		rx->head = head;
		rx->tail = tail;
		rx->channel = chn;
		rx->num = num;
		rx->head->len = (block_size) - ret;
		rx->head->buf = kmalloc(rx->head->len, GFP_KERNEL);
		if (rx->head->buf == NULL) {
			pr_err("mtty low memory!\n");
			kfree(rx);
			sprdwcn_bus_push_list(chn, head, tail, num);
			return -ENOMEM;
		}

		memcpy(rx->head->buf, (unsigned char *)head->buf + BT_SDIO_HEAD_LEN + ret, rx->head->len);
		sprdwcn_bus_push_list(chn, head, tail, num);
		mutex_lock(&mtty_dev->rw_mutex);
		pr_err("mtty over load push %d -> %d, channel: %d len: %d\n",
			block_size, ret, rx->channel, rx->head->len);
		list_add_tail(&rx->entry, &mtty_dev->rx_head);
		mutex_unlock(&mtty_dev->rw_mutex);
		if (!work_pending(&mtty_dev->bt_rx_work)) {
			pr_err("work_pending\n");
			queue_work(mtty_dev->bt_rx_workqueue,
				&mtty_dev->bt_rx_work);
		}
		return 0;
	}
	pr_err("mtty_rx_cb mtty_dev is NULL!!!\n");

	return -1;
}

static int mtty_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 mtty_open(struct tty_struct *tty, struct file *filp)
{
	struct mtty_device *mtty = NULL;
	struct tty_driver *driver = NULL;
	data_dump = (bt_host_data_dump *)vmalloc(sizeof(bt_host_data_dump));
	memset(data_dump, 0, sizeof(bt_host_data_dump));
	if (tty == NULL) {
		pr_err("mtty open input tty is NULL!\n");
		return -ENOMEM;
	}
	driver = tty->driver;
	mtty = (struct mtty_device *)driver->driver_state;

	if (mtty == NULL) {
		pr_err("mtty open input mtty NULL!\n");
		return -ENOMEM;
	}

	mtty->tty = tty;
	tty->driver_data = (void *)mtty;

	atomic_set(&mtty->state, MTTY_STATE_OPEN);
	que_task = 0;
	que_sche = 0;
	sitm_ini();
	pr_info("mtty_open device success!\n");
	return 0;
}

static void mtty_close(struct tty_struct *tty, struct file *filp)
{
	struct mtty_device *mtty = NULL;

	if (tty == NULL) {
		pr_err("mtty close input tty is NULL!\n");
		return;
	}
	mtty = (struct mtty_device *) tty->driver_data;
	if (mtty == NULL) {
		pr_err("mtty close s tty is NULL!\n");
		return;
	}

	atomic_set(&mtty->state, MTTY_STATE_CLOSE);
	sitm_cleanup();

	if (data_dump != NULL) {
		vfree(data_dump);
		data_dump = NULL;
	}
	pr_info("mtty_close device success !\n");
}

static int mtty_write(struct tty_struct *tty,
		const unsigned char *buf, int count)
{
	int num = 1, ret;
	struct mbuf_t *tx_head = NULL, *tx_tail = NULL;
	unsigned char *block = NULL;

	BT_VER("%s +++\n", __func__);

	if (is_user_debug) {
		bt_host_data_save(buf, count, BT_DATA_OUT);
	}
	if (log_level == MTTY_LOG_LEVEL_VER) {
		BT_VER("%s dump size: %d\n", __func__, count);
		hex_dump_block((unsigned char *)buf, count);
	}

	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);
		kfree(block);
		block = NULL;
		return -ENOMEM;
	}
	tx_head->buf = block;
	tx_head->len = count;
	tx_head->next = NULL;

	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;
	}

	BT_VER("%s ---\n", __func__);
	return count;
}

static  int sdio_data_transmit(uint8_t *data, size_t count)
{
	return mtty_write(NULL, data, count);
}

static int mtty_write_plus(struct tty_struct *tty,
		  const unsigned char *buf, int count)
{
	return sitm_write(buf, count, sdio_data_transmit);
}

static void mtty_flush_chars(struct tty_struct *tty)
{
}

static int mtty_write_room(struct tty_struct *tty)
{
	return INT_MAX;
}

static const struct tty_operations mtty_ops = {
	.open  = mtty_open,
	.close = mtty_close,
	.write = mtty_write_plus,
	.flush_chars = mtty_flush_chars,
	.write_room  = mtty_write_room,
};

static struct tty_port *mtty_port_init(void)
{
	struct tty_port *port = NULL;

	port = kzalloc(sizeof(struct tty_port), GFP_KERNEL);
	if (port == NULL)
		return NULL;
	tty_port_init(port);

	return port;
}

static int mtty_tty_driver_init(struct mtty_device *device)
{
	struct tty_driver *driver;
	int ret = 0;

	device->port = mtty_port_init();
	if (!device->port)
		return -ENOMEM;

	driver = alloc_tty_driver(MTTY_DEV_MAX_NR * 2);
	if (!driver)
		return -ENOMEM;

	/*
	* Initialize the tty_driver structure
	* Entries in mtty_driver that are NOT initialized:
	* proc_entry, set_termios, flush_buffer, set_ldisc, write_proc
	*/
	driver->owner = THIS_MODULE;
	driver->driver_name = device->pdata->name;
	driver->name = device->pdata->name;
	driver->major = 0;
	driver->type = TTY_DRIVER_TYPE_SYSTEM;
	driver->subtype = SYSTEM_TYPE_TTY;
	driver->init_termios = tty_std_termios;
	driver->driver_state = (void *)device;
	device->driver = driver;
	device->driver->flags = TTY_DRIVER_REAL_RAW;
	/* initialize the tty driver */
	tty_set_operations(driver, &mtty_ops);
	tty_port_link_device(device->port, driver, 0);
	ret = tty_register_driver(driver);
	if (ret) {
		put_tty_driver(driver);
		tty_port_destroy(device->port);
		return ret;
	}
	return ret;
}

static void mtty_tty_driver_exit(struct mtty_device *device)
{
	struct tty_driver *driver = device->driver;

	tty_unregister_driver(driver);
	put_tty_driver(driver);
	tty_port_destroy(device->port);
}

__attribute__((unused))
static int mtty_parse_dt(struct mtty_init_data **init, struct device *dev)
{
#ifdef CONFIG_OF
	struct device_node *np = dev->of_node;
	struct mtty_init_data *pdata = NULL;
	int ret;

	pdata = kzalloc(sizeof(struct mtty_init_data), GFP_KERNEL);
	if (!pdata)
	return -ENOMEM;

	ret = of_property_read_string(np,
		"sprd,name",
		(const char **)&pdata->name);
	if (ret)
	goto error;
	*init = pdata;

	return 0;
error:
	kfree(pdata);
	*init = NULL;
	return ret;
#else
	return -ENODEV;
#endif
}

static inline void mtty_destroy_pdata(struct mtty_init_data **init)
{
#if (defined CONFIG_OF) && !(defined OTT_UWE)
	struct mtty_init_data *pdata = *init;

	kfree(pdata);

	*init = NULL;
#else
	return;
#endif
}

#ifdef WOBLE_FUN
__attribute__((unused)) static int bt_tx_powerchange(int channel, int is_resume)
{
	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) {
			hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_NOT_RESUME);
			hci_set_ap_start_sleep();
		}
		if (is_resume) {
			hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_RESUME);
		}
	}

	return 0;
}
#endif

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 = mtty_rx_cb,
};

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 = mtty_tx_cb,
#ifdef WOBLE_FUN
	.power_notify = bt_tx_powerchange,
#endif
};

static int  mtty_probe(struct platform_device *pdev)
{
	struct mtty_init_data *pdata = (struct mtty_init_data *)
								pdev->dev.platform_data;
	struct mtty_device *mtty;
	int rval = 0;

#ifdef OTT_UWE
	static struct mtty_init_data mtty_driver_data = {
		.name = "ttyBT",
	};

	pdata = &mtty_driver_data;
#else
	if (pdev->dev.of_node && !pdata) {
		rval = mtty_parse_dt(&pdata, &pdev->dev);
		if (rval) {
			pr_err("failed to parse mtty device tree, ret=%d\n",
					rval);
			return rval;
		}
	}
#endif

	mtty = kzalloc(sizeof(struct mtty_device), GFP_KERNEL);
	if (mtty == NULL) {
		mtty_destroy_pdata(&pdata);
		pr_err("mtty Failed to allocate device!\n");
		return -ENOMEM;
	}

	mtty->pdata = pdata;
	rval = mtty_tty_driver_init(mtty);
	if (rval) {
		mtty_tty_driver_exit(mtty);
		kfree(mtty->port);
		kfree(mtty);
		mtty_destroy_pdata(&pdata);
		pr_err("regitster notifier failed (%d)\n", rval);
		return rval;
	}

	pr_info("mtty_probe init device addr: 0x%p\n", mtty);
	platform_set_drvdata(pdev, mtty);

	/*spin_lock_init(&mtty->rw_lock);*/
	atomic_set(&mtty->state, MTTY_STATE_CLOSE);
	mutex_init(&mtty->rw_mutex);
	INIT_LIST_HEAD(&mtty->rx_head);
	/*tasklet_init(&mtty->rx_task, mtty_rx_task, (unsigned long)mtty);*/
	mtty->bt_rx_workqueue =
		create_singlethread_workqueue("SPRDBT_RX_QUEUE");
	if (!mtty->bt_rx_workqueue) {
		pr_err("%s SPRDBT_RX_QUEUE create failed", __func__);
		return -ENOMEM;
	}
	INIT_WORK(&mtty->bt_rx_work, mtty_rx_work_queue);

	mtty_dev = mtty;

//#ifdef KERNEL_VERSION_414
	if (sysfs_create_group(&pdev->dev.kobj,
			&bluetooth_group)) {
		pr_err("%s failed to create bluetooth tty attributes.\n", __func__);
	}
//#endif

	rfkill_bluetooth_init(pdev);
	bluesleep_init();
	woble_init();
	sprdwcn_bus_chn_init(&bt_rx_ops);
	sprdwcn_bus_chn_init(&bt_tx_ops);
	sema_init(&sem_id, BT_TX_POOL_SIZE - 1);

	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, *tmp_buf = (unsigned char *)buf + 1;
	unsigned short op = 0;

	STREAM_TO_UINT16(op, tmp_buf);

	if (buf[0] == 0x1) {
		pr_info("%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;
	}

	if (log_level == MTTY_LOG_LEVEL_VER) {
		pr_info("%s dump size: %d\n", __func__, count);
		hex_dump_block((unsigned char *)buf, count);
	}

	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);
		kfree(block);
		block = NULL;
		return -ENOMEM;
	}

	tx_head->buf = block;
	tx_head->len = count;
	tx_head->next = NULL;

	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;
	}

	BT_VER("%s ---\n", __func__);

	return count;
}

#ifdef WOBLE_FUN
__attribute__((unused)) static void  mtty_shutdown(struct platform_device *pdev)
{
	unsigned long int power_state = marlin_get_power_state();
	pr_info("%s ---\n", __func__);
	if (test_bit(MARLIN_BLUETOOTH, &power_state)) {
		pr_info("set bluetooth into sleep mode\n");
		hci_set_ap_sleep_mode(1, 0);
		hci_set_ap_start_sleep();
	}
	return;
}
#endif

static int  mtty_remove(struct platform_device *pdev)
{
	struct mtty_device *mtty = platform_get_drvdata(pdev);

	mtty_tty_driver_exit(mtty);
	sprdwcn_bus_chn_deinit(&bt_rx_ops);
	sprdwcn_bus_chn_deinit(&bt_tx_ops);
	kfree(mtty->port);
	mtty_destroy_pdata(&mtty->pdata);
	flush_workqueue(mtty->bt_rx_workqueue);
	destroy_workqueue(mtty->bt_rx_workqueue);
	/*tasklet_kill(&mtty->rx_task);*/
	kfree(mtty);
	platform_set_drvdata(pdev, NULL);
//#ifdef KERNEL_VERSION_414
	sysfs_remove_group(&pdev->dev.kobj, &bluetooth_group);
//#endif
	bluesleep_exit();

	return 0;
}

static const struct of_device_id mtty_match_table[] = {
	{ .compatible = "sprd,mtty", },
	{ },
};

static struct platform_driver mtty_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = "mtty",
		.of_match_table = mtty_match_table,
	},
	.probe = mtty_probe,
	.remove = mtty_remove,
#ifdef WOBLE_FUN
	.shutdown = mtty_shutdown,
#endif
};

#ifdef OTT_UWE
static struct platform_device *mtty_pdev;
static int __init mtty_pdev_init(void)
{
	int ret;
	ret = platform_driver_register(&mtty_driver);
	if (!ret) {
		mtty_pdev = platform_device_alloc("mtty", -1);
		if (platform_device_add(mtty_pdev) != 0)
			pr_err("register platform device unisoc mtty failed\n");
	}

	return ret;
}

static void __exit mtty_pdev_exit(void)
{
	platform_driver_unregister(&mtty_driver);
	platform_device_del(mtty_pdev);
}

module_init(mtty_pdev_init);
module_exit(mtty_pdev_exit);
#else
module_platform_driver(mtty_driver);
#endif

MODULE_AUTHOR("Unisoc wcn bt");
MODULE_DESCRIPTION("Unisoc marlin tty driver");
MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);