/*
|
* 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/atomic.h>
|
#include <linux/console.h>
|
#include <linux/delay.h>
|
#include <linux/init.h>
|
#include <linux/kdev_t.h>
|
#include <linux/kernel.h>
|
#include <linux/module.h>
|
#include <linux/platform_device.h>
|
#include <linux/semaphore.h>
|
#include <linux/slab.h>
|
#include <linux/syscalls.h>
|
#include <linux/tty.h>
|
#include <linux/types.h>
|
#include <linux/vmalloc.h>
|
#include <linux/vt_kern.h>
|
#ifdef CONFIG_OF
|
#include <linux/of_device.h>
|
#endif
|
#include <linux/compat.h>
|
#include <linux/interrupt.h>
|
#include <linux/kthread.h>
|
#include <linux/tty_flip.h>
|
#include <linux/workqueue.h>
|
|
#include "include/debug.h"
|
#include "include/hci.h"
|
#include "include/interface.h"
|
#include "include/lpm.h"
|
#include "include/rfkill.h"
|
#include "include/sdio.h"
|
#include "include/sitm.h"
|
#include "include/tty.h"
|
#include <marlin_platform.h>
|
|
// #define UNISOC_AMLOGIC_SUSPEND
|
#ifdef UNISOC_AMLOGIC_SUSPEND
|
#include <linux/amlogic/pm.h> //add
|
static struct early_suspend bt_early_suspend; //add
|
#endif
|
|
#if 0
|
#define DO_SYSCALL_2(sc, t1, a1, t2, a2) \
|
(((asmlinkage long (*)(t1, t2))sys_call_table[__NR_##sc])(a1, a2));
|
#define USER_SYSCALL_2(sc, t1, a1, t2, a2) \
|
static inline asmlinkage long syscall_##sc(t1 a1, t2 a2) \
|
{ \
|
return DO_SYSCALL_2(sc, t1, a1, t2, a2) \
|
}
|
|
USER_SYSCALL_2(chmod, const char __user *, filename, mode_t, mode);
|
#endif
|
|
#ifndef USE_DTS
|
static void __exit uwe5621_bt_tty_exit(void);
|
#endif
|
static int mtty_remove(struct platform_device* pdev);
|
int closeflag = 0;
|
struct mtty_device* mtty_dev;
|
|
struct bt_data_interface_t* bt_data_interface;
|
static struct bt_data_interface_cb_t bt_data_interface_cb;
|
extern int list_time;
|
extern unsigned char dis_flag;
|
static int mtty_open(struct tty_struct* tty, struct file* filp)
|
{
|
struct mtty_device* mtty = NULL;
|
struct tty_driver* driver = NULL;
|
|
// start_marlin(MARLIN_BLUETOOTH);
|
bluetooth_set_power(0, 0);
|
|
clear_woble_devices();
|
|
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);
|
sitm_init();
|
// pr_info("%s device success! pid %d %d %d sid %d\n", __func__, task_pid_nr(current), current->pid, pid_nr(get_task_pid(current, PIDTYPE_PID)),
|
// pid_nr(get_task_pid(current, PIDTYPE_SID)));
|
closeflag = 0;
|
list_time = 0x11;
|
dis_flag = 0;
|
return 0;
|
}
|
|
static void mtty_close(struct tty_struct* tty, struct file* filp)
|
{
|
closeflag = 1;
|
list_time = 0x11;
|
dis_flag = 0;
|
pr_info("mtty_close device success _close!\n");
|
|
/*
|
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();
|
pr_info("mtty_close device success !\n");
|
|
//stop_marlin(MARLIN_BLUETOOTH);
|
bluetooth_set_power(0, 1);
|
*/
|
}
|
|
static inline int mtty_transfer_upper(const unsigned char* buf, int count)
|
{
|
int ret = tty_insert_flip_string(mtty_dev->port, buf, count);
|
|
if (ret != count) {
|
pr_err("%s err ret %d count %d !!!!!!!!!!!\n", __func__, ret, count);
|
}
|
|
tty_flip_buffer_push(mtty_dev->port);
|
return ret;
|
}
|
// add ..... 04 05 04 00 00 02 13
|
int resume_transfer_upper(const unsigned char* buf, int count)
|
{
|
int ret = tty_insert_flip_string(mtty_dev->port, buf, count);
|
pr_err("test_%s\n", __func__); //
|
if (ret != count) {
|
pr_err("%s err ret %d count %d !!!!!!!!!!!\n", __func__, ret, count);
|
}
|
|
tty_flip_buffer_push(mtty_dev->port);
|
return ret;
|
}
|
|
static int mtty_recv(const unsigned char* buf, int count)
|
{
|
// pr_err("mtty_recv count:%d\n", count);
|
// hex_dump_block(buf, count);
|
// return mtty_transfer_upper(buf, count);
|
return rx_data_recv(buf, count, mtty_transfer_upper);
|
}
|
|
static int sdio_data_transmit(uint8_t* data, size_t count)
|
{
|
return bt_data_interface->write(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);
|
|
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;
|
#ifndef USE_DTS
|
driver->driver_name = "ttyBT";
|
driver->name = "ttyBT";
|
#else
|
driver->driver_name = device->pdata->name;
|
driver->name = device->pdata->name;
|
#endif
|
|
#if 1
|
driver->major = 0;
|
#else
|
driver->major = TTYAUX_MAJOR;
|
driver->minor_start = 2;
|
#endif
|
|
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;
|
}
|
|
// sys_chmod("/dev/ttyBT0", 0777);
|
// syscall_chmod("/dev/ttyBT0", 0777);
|
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);
|
}
|
|
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 USE_DTS)
|
struct mtty_init_data* pdata = *init;
|
|
kfree(pdata);
|
|
*init = NULL;
|
#else
|
return;
|
#endif
|
}
|
|
static ssize_t at_store(struct device* dev,
|
struct device_attribute* attr,
|
const char* buf, size_t count)
|
{
|
pr_info("%s\n", __func__);
|
hci_woble_enable();
|
return count;
|
}
|
|
static ssize_t at_show(struct device* dev,
|
struct device_attribute* attr,
|
char* buf)
|
{
|
pr_info("%s\n", __func__);
|
return 0;
|
}
|
|
static ssize_t woble_set_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t count)
|
{
|
unsigned char* p = (unsigned char*)buf;
|
unsigned char opcode = 0;
|
unsigned short handler = 0;
|
STREAM_TO_UINT8(opcode, p);
|
|
// pr_info("%s, len %lu op: %d\n", __func__, count, opcode);
|
|
switch (opcode) {
|
case WOBLE_KERNEL_OP_CLEAR:
|
clear_woble_devices();
|
break;
|
|
case WOBLE_KERNEL_OP_SET_OWN:
|
set_random_address(p);
|
break;
|
|
case WOBLE_KERNEL_OP_ADD_RMT: {
|
unsigned char type = 0;
|
STREAM_TO_UINT8(type, p);
|
STREAM_TO_UINT16(handler, p);
|
pr_info("%s, get type: %d\n", __func__, type);
|
update_woble_devices(type, handler, p);
|
} break;
|
|
case WOBLE_KERNEL_OP_DEL_RMT: {
|
unsigned char type = 0;
|
STREAM_TO_UINT8(type, p);
|
pr_info("%s, get type: %d\n", __func__, type);
|
del_woble_devices(type, p);
|
} break;
|
|
case WOBLE_KERNEL_OP_ENABLE_BLE_INDICATE: {
|
set_need_indicate_cp2_woble(1);
|
} break;
|
|
case WOBLE_KERNEL_OP_DISABLE_BLE_INDICATE: {
|
set_need_indicate_cp2_woble(0);
|
} break;
|
}
|
|
return count;
|
}
|
|
static ssize_t woble_set_show(struct device* dev,
|
struct device_attribute* attr,
|
char* buf)
|
{
|
pr_info("%s\n", __func__);
|
dump_woble_devices();
|
return 0;
|
}
|
|
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 ssize_t chipid_show(struct device* dev,
|
struct device_attribute* attr,
|
char* buf)
|
{
|
int type = 0;
|
|
type = wcn_get_chip_model();
|
pr_err("%s: %d", __func__, type);
|
|
return sprintf(buf, "%d", type);
|
}
|
|
static ssize_t misc_node_store(struct device* dev,
|
struct device_attribute* attr,
|
const char* buf, size_t count)
|
{
|
unsigned char opcode = 0;
|
const char* tbuf = buf;
|
pr_info("%s\n", __func__);
|
|
if (memcmp("AT+BTLOG=", buf, strlen("AT+BTLOG=")) == 0 && count >= strlen("AT+BTLOG=") + 1) {
|
tbuf += strlen("AT+BTLOG=");
|
STREAM_TO_UINT8(opcode, tbuf);
|
set_log_level(opcode - '0');
|
} else if (memcmp("AT+SLEEP=", buf, strlen("AT+SLEEP=")) == 0 && count >= strlen("AT+SLEEP=") + 1) {
|
unsigned char is_resume = 0;
|
tbuf += strlen("AT+SLEEP=");
|
STREAM_TO_UINT8(is_resume, tbuf);
|
is_resume = is_resume - '0';
|
pr_err("%s AT+SLEEP=%d\n", __func__, is_resume);
|
switch (is_resume) {
|
case 0:
|
hci_set_scan_parameters();
|
hci_set_scan_enable(1);
|
break;
|
case 1:
|
hci_add_device_to_wakeup_list();
|
break;
|
case 2:
|
hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_NOT_RESUME);
|
break;
|
case 3:
|
hci_set_ap_start_sleep();
|
break;
|
case 4:
|
hci_set_ap_sleep_mode(WOBLE_IS_NOT_SHUTDOWN, WOBLE_IS_RESUME);
|
break;
|
default:
|
break;
|
}
|
}
|
return count;
|
}
|
|
static ssize_t misc_node_show(struct device* dev,
|
struct device_attribute* attr,
|
char* buf)
|
{
|
pr_info("%s\n", __func__);
|
|
return 0;
|
}
|
#define ALL_PER 1
|
|
#if ALL_PER
|
#pragma push_macro("VERIFY_OCTAL_PERMISSIONS")
|
#ifdef VERIFY_OCTAL_PERMISSIONS
|
#undef VERIFY_OCTAL_PERMISSIONS
|
#endif
|
|
#define VERIFY_OCTAL_PERMISSIONS(perms) (perms)
|
#endif
|
#if ALL_PER
|
static DEVICE_ATTR(at, 00660, at_show, at_store);
|
static DEVICE_ATTR(woble_set, 00660, woble_set_show, woble_set_store);
|
static DEVICE_ATTR(ant_num, 00664, ant_num_show, 0);
|
static DEVICE_ATTR(chipid, 00664, chipid_show, 0);
|
static DEVICE_ATTR(misc_node, 00660, misc_node_show, misc_node_store);
|
|
#pragma pop_macro("VERIFY_OCTAL_PERMISSIONS")
|
|
#else
|
static DEVICE_ATTR(at, 00660, at_show, at_store);
|
static DEVICE_ATTR(woble_set, 00660, woble_set_show, woble_set_store);
|
static DEVICE_ATTR(ant_num, 00660, ant_num_show, 0);
|
static DEVICE_ATTR(chipid, 00660, chipid_show, 0);
|
static DEVICE_ATTR(misc_node, 00660, misc_node_show, misc_node_store);
|
#endif
|
|
struct attribute* bluetooth_attrs[] = {
|
&dev_attr_at.attr,
|
&dev_attr_woble_set.attr,
|
&dev_attr_ant_num.attr,
|
&dev_attr_chipid.attr,
|
&dev_attr_misc_node.attr,
|
NULL,
|
};
|
|
static struct attribute_group bluetooth_group = {
|
.name = NULL,
|
.attrs = bluetooth_attrs,
|
};
|
|
#ifdef UNISOC_AMLOGIC_SUSPEND
|
extern unsigned char resume_rxmsg[7];
|
int early_flag = 0x11;
|
int dis_cmd_flag = 0x11;
|
extern unsigned char red_bt_flag; //区分蓝牙，红外待机标志；0x11:红外 0x22: bt
|
//int uni_sus_flag =0x11;
|
//int uni_resu_flag= 0x11;
|
//int resume_suspen_flag=0x11;
|
//int firs_dis_flag=0x11;
|
static void bt_earlysuspend(struct early_suspend* h)
|
{
|
dis_cmd_flag = 0x11;
|
early_flag = 0x11;
|
}
|
|
static void bt_lateresume(struct early_suspend* h)
|
{
|
|
if (early_flag == 0x22) {
|
resume_transfer_upper(resume_rxmsg, 7);
|
}
|
early_flag = 0x11;
|
dis_cmd_flag = 0x11;
|
dis_flag =0 ;// 更新狀態
|
pr_err("unisoc_lateresume\n"); //
|
}
|
#endif
|
|
#ifdef CP2_RESET_SUPPORT
|
static void bt_cp2_pre_reset(void) {
|
pr_err("%s: entry!\n", __func__);
|
}
|
|
static void bt_cp2_post_reset(void) {
|
#define RESET_BUFSIZE 5
|
|
int ret = 0;
|
int block_size = RESET_BUFSIZE;
|
unsigned char reset_buf[RESET_BUFSIZE]= {0x04, 0xff, 0x02, 0x57, 0xa5};
|
|
pr_err("%s: reset callback coming\n", __func__);
|
if (mtty_dev != NULL) {
|
// if (!work_pending(&mtty_dev->bt_rx_work)) {
|
if (atomic_read(&mtty_dev->state) == MTTY_STATE_OPEN && (RESET_BUFSIZE > 0)) {
|
pr_err("%s tty_insert_flip_string", __func__);
|
while(ret < block_size){
|
pr_err("%s before tty_insert_flip_string ret: %d, len: %d\n",
|
__func__, ret, RESET_BUFSIZE);
|
ret = tty_insert_flip_string(mtty_dev->port,
|
(unsigned char *)reset_buf,
|
RESET_BUFSIZE); // -BT_SDIO_HEAD_LEN
|
pr_err("%s ret: %d, len: %d\n", __func__, ret, RESET_BUFSIZE);
|
if (ret)
|
tty_flip_buffer_push(mtty_dev->port);
|
block_size = block_size - ret;
|
ret = 0;
|
}
|
}
|
}
|
}
|
|
|
int bt_cp2_reset_callback(struct notifier_block *nb, unsigned long event, void *v) {
|
if (!v) {
|
pr_err("%s: v is NULL\n", __func__);
|
return NOTIFY_BAD;
|
}
|
|
pr_err("%s: %s %d\n", __func__, (char *)v, (int)event);
|
|
switch(event) {
|
case MARLIN_CP2_STS_ASSERTED:
|
bt_cp2_pre_reset();
|
break;
|
case MARLIN_CP2_STS_READY:
|
bt_cp2_post_reset();
|
break;
|
default:
|
pr_err("%s: parameter error event: %d\n", __func__, (int)event);
|
return NOTIFY_BAD;
|
}
|
|
return NOTIFY_OK;
|
}
|
|
static struct notifier_block bt_cp2_reset_notifier = {
|
.notifier_call = bt_cp2_reset_callback,
|
};
|
#endif /*CP2_RESET_SUPPORT*/
|
|
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;
|
|
if (marlin_get_wcn_module_vendor() < 0) {
|
pr_err("%s not unisoc soc, exit", __func__);
|
// mtty_remove(pdev);
|
// uwe5621_bt_tty_exit();
|
return -EACCES;
|
} else {
|
pr_err("%s unisoc soc, continue", __func__);
|
}
|
|
if (pdev->dev.of_node && !pdata) {
|
rval = mtty_parse_dt(&pdata, &pdev->dev);
|
|
if (rval) {
|
pr_err("%s failed to parse mtty device tree, ret=%d\n", __func__,
|
rval);
|
return rval;
|
}
|
}
|
|
mtty = kzalloc(sizeof(struct mtty_device), GFP_KERNEL);
|
|
if (mtty == NULL) {
|
mtty_destroy_pdata(&pdata);
|
pr_err("%s Failed to allocate device!\n", __func__);
|
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("%s regitster notifier failed (%d)\n", __func__, rval);
|
return rval;
|
}
|
|
pr_info("%s init device addr: 0x%p\n", __func__, mtty);
|
platform_set_drvdata(pdev, mtty);
|
|
atomic_set(&mtty->state, MTTY_STATE_CLOSE);
|
|
mtty_dev = mtty;
|
|
if (sysfs_create_group(&(pdev->dev.kobj), &bluetooth_group)) {
|
pr_err("%s create dispc attr node failed", __func__);
|
}
|
|
rfkill_bluetooth_init(pdev);
|
// bluesleep_init();
|
|
// uwe5621_bt_tty_exit();
|
hci_init();
|
|
bt_data_interface_cb.size = sizeof(struct bt_data_interface_cb_t);
|
bt_data_interface_cb.recv = mtty_recv;
|
bt_data_interface = get_marlin_sdio_interface();
|
bt_data_interface->init(&bt_data_interface_cb);
|
|
/********************************************/
|
#ifdef UNISOC_AMLOGIC_SUSPEND
|
bt_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;
|
bt_early_suspend.suspend = bt_earlysuspend;
|
bt_early_suspend.resume = bt_lateresume;
|
bt_early_suspend.param = pdev;
|
register_early_suspend(&bt_early_suspend);
|
#endif
|
/********************************************/
|
|
#ifdef CP2_RESET_SUPPORT
|
marlin_reset_callback_register(MARLIN_BLUETOOTH, &bt_cp2_reset_notifier);
|
#endif /*CP2_RESET_SUPPORT*/
|
|
return 0;
|
}
|
|
static int mtty_remove(struct platform_device* pdev)
|
{
|
struct mtty_device* mtty = platform_get_drvdata(pdev);
|
rfkill_bluetooth_remove(pdev);
|
pr_err("%s\n", __func__);
|
mtty_tty_driver_exit(mtty);
|
bt_data_interface->cleanup();
|
kfree(mtty->port);
|
mtty_destroy_pdata(&mtty->pdata);
|
/* tasklet_kill(&mtty->rx_task); */
|
kfree(mtty);
|
platform_set_drvdata(pdev, NULL);
|
// bluesleep_exit();
|
hci_destory();
|
return 0;
|
}
|
|
static int mtty_suspend(struct platform_device* device, pm_message_t state)
|
{
|
pr_err("%s\n", __func__);
|
// at_store(0, 0, 0, 0);
|
// stop_marlin(MARLIN_BLUETOOTH);
|
// sprdwcn_bus_remove_card();
|
return 0;
|
}
|
|
static void mtty_shutdown(struct platform_device* device)
|
{
|
pr_err("%s\n", __func__);
|
return;
|
}
|
static int mtty_resume(struct platform_device* device)
|
{
|
pr_err("%s\n", __func__);
|
return 0;
|
}
|
|
static void mtty_device_release(struct device* device)
|
{
|
pr_err("%s\n", __func__);
|
return;
|
}
|
|
static struct platform_device uwe5621_bt_tty_device = {
|
.name = "mtty",
|
.dev = {
|
.release = mtty_device_release,
|
},
|
};
|
static const struct of_device_id mtty_match_table[] = {
|
{
|
.compatible = "sprd,mtty",
|
},
|
};
|
static struct platform_driver uwe5621_bt_tty_driver = {
|
.driver = {
|
.owner = THIS_MODULE,
|
.name = "mtty",
|
.of_match_table = mtty_match_table,
|
},
|
.probe = mtty_probe,
|
.remove = mtty_remove,
|
.suspend = mtty_suspend,
|
.resume = mtty_resume,
|
.shutdown = mtty_shutdown,
|
};
|
|
#ifdef USE_DTS
|
// for dts
|
module_platform_driver(uwe5621_bt_tty_driver);
|
|
#else
|
|
static int __init uwe5621_bt_tty_init(void)
|
{
|
pr_err("%s\n", __func__);
|
platform_device_register(&uwe5621_bt_tty_device);
|
return platform_driver_register(&uwe5621_bt_tty_driver);
|
}
|
|
static void __exit uwe5621_bt_tty_exit(void)
|
{
|
pr_err("%s\n", __func__);
|
platform_driver_unregister(&uwe5621_bt_tty_driver);
|
platform_device_unregister(&uwe5621_bt_tty_device);
|
}
|
|
// module_init(uwe5621_bt_tty_init);
|
late_initcall_sync(uwe5621_bt_tty_init);
|
module_exit(uwe5621_bt_tty_exit);
|
|
#endif
|
|
MODULE_AUTHOR("Unisoc wcn bt");
|
MODULE_DESCRIPTION("Unisoc marlin tty driver");
|
