#include <linux/kernel.h>
|
#include <linux/cdev.h>
|
#include <linux/module.h>
|
#include <linux/fs.h>
|
#include <linux/slab.h>
|
#include <linux/delay.h>
|
#include <linux/compat.h>
|
#include <linux/uaccess.h>
|
#include <linux/workqueue.h>
|
#include <linux/scatterlist.h>
|
#include <linux/notifier.h>
|
#include <linux/platform_device.h>
|
#include "skw_boot.h"
|
#include "skw_log_to_file.h"
|
#define UCOM_PORTNO_MAX 13
|
#define UCOM_DEV_PM_OPS NULL
|
int cp_exception_sts=0;
|
static int log_start;
|
static unsigned int tmp_chipid = 0;
|
static int log_portno = 0;
|
static int skw_major = 0;
|
struct mutex ucom_mutex;
|
static struct class *skw_com_class = NULL;
|
struct ucom_dev {
|
atomic_t open;
|
spinlock_t lock;
|
int rx_busy;
|
int tx_busy;
|
int devno;
|
int portno;
|
struct sv6160_platform_data *pdata;
|
wait_queue_head_t wq;
|
struct cdev cdev;
|
char *rx_buf;
|
char *tx_buf;
|
struct notifier_block notifier;
|
};
|
static struct ucom_dev *ucoms[UCOM_PORTNO_MAX];
|
static char *dump_memory_buffer;
|
static int dump_buffer_size, dump_log_size;
|
#include "skw_dump_mem.c"
|
static int user_boot_open(struct inode *ip, struct file *fp)
|
{
|
struct cdev *char_dev;
|
int ret = -EIO, i;
|
struct ucom_dev *ucom=NULL;
|
|
char_dev = ip->i_cdev;
|
for(i=0; i< UCOM_PORTNO_MAX; i++) {
|
if(ucoms[i] && (ucoms[i]->devno == char_dev->dev)) {
|
ucom = ucoms[i];
|
ret = 0;
|
break;
|
}
|
}
|
|
if(cp_exception_sts)
|
ret = -EIO;
|
if(ucom && !cp_exception_sts) {
|
if(atomic_read(&ucom->open))
|
return -EBUSY;
|
if(!cp_exception_sts)
|
ret=ucom->pdata->open_port(ucom->portno, NULL, NULL);
|
|
if (ret == 0) {
|
atomic_inc(&ucom->open);
|
fp->private_data = ucom;
|
}
|
}
|
skwboot_log("Open user_boot device: ret=%d task %d\n", ret, (int)current->pid);
|
|
return ret;
|
}
|
|
static int user_boot_release(struct inode *ip, struct file *fp)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
int count=100;
|
while(cp_exception_sts &&count--)
|
msleep(10);
|
|
if(ucom){
|
if(!cp_exception_sts)
|
ucom->pdata->close_port(ucom->portno);
|
atomic_dec(&ucom->open);
|
}
|
|
return 0;
|
}
|
|
static int ucom_open(struct inode *ip, struct file *fp)
|
{
|
struct cdev *char_dev;
|
int ret = -EIO, i;
|
struct ucom_dev *ucom=NULL;
|
|
char_dev = ip->i_cdev;
|
for(i=0; i< UCOM_PORTNO_MAX; i++) {
|
if(ucoms[i] && (ucoms[i]->devno == char_dev->dev)) {
|
ucom = ucoms[i];
|
ret = 0;
|
break;
|
}
|
}
|
if(ucom) {
|
if(cp_exception_sts && strncmp(ucom->pdata->port_name, "LOG", 3)){
|
skwboot_log("%s line:%d the modem assert \n", __func__,__LINE__);
|
return -EIO;
|
}
|
if(atomic_read(&ucom->open) > 1){
|
skwboot_log("%s ,%d\n", __func__, __LINE__);
|
return -EBUSY;
|
}
|
atomic_inc(&ucom->open);
|
if (atomic_read(&ucom->open)==1) {
|
init_waitqueue_head(&ucom->wq);
|
spin_lock_init(&ucom->lock);
|
ucom->pdata->open_port(ucom->portno, NULL, NULL);
|
}
|
fp->private_data = ucom;
|
skwboot_log("%s: ucom[%d] %s(0x%x)\n", __func__, i, ucom->pdata->port_name, ucom->portno);
|
|
if(!strncmp((char *)ucom->pdata->chipid,"SV6160",6))
|
tmp_chipid = 0x6160;
|
else if(!strncmp((char *)ucom->pdata->chipid,"SV6316", 6))
|
tmp_chipid = 0x6316;
|
else if(!strncmp((char *)ucom->pdata->chipid,"SV6160LITE", 10))
|
tmp_chipid = 0x6161;
|
|
skwboot_log("the portno=%d - chipid = 0x%lx \n",ucom->portno, (unsigned long)tmp_chipid);
|
}
|
|
return ret;
|
}
|
static int ucom_release(struct inode *ip, struct file *fp)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
int i;
|
|
for(i=0; i< UCOM_PORTNO_MAX; i++) {
|
if(ucoms[i] == ucom)
|
break;
|
}
|
fp->private_data = NULL;
|
if(ucom && (i<UCOM_PORTNO_MAX)) {
|
skwboot_log("%s: ucom%p %s(0x%x)\n", __func__, ucom, ucom->pdata->port_name, ucom->devno);
|
if (atomic_read(&ucom->open)) {
|
atomic_dec(&ucom->open);
|
// Don't close LOG/AT port once open it, otherwise RX transfer lost.
|
if (strncmp(ucom->pdata->port_name, "LOG", 3) &&
|
strncmp(ucom->pdata->port_name, "ATC", 3))
|
ucom->pdata->close_port(ucom->portno);
|
else if (!log_start && !strncmp(ucom->pdata->port_name, "LOG", 3))
|
ucom->pdata->close_port(ucom->portno);
|
wake_up(&ucom->wq);
|
} else
|
kfree(ucom);
|
}
|
return 0;
|
}
|
|
static ssize_t ucom_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
ssize_t r = count;
|
int ret;
|
unsigned long flags;
|
uint32_t *data;
|
|
if(atomic_read(&ucom->open)==0)
|
return -EIO;
|
if (strncmp(ucom->pdata->port_name, "LOG", 3) && cp_exception_sts)
|
return -EIO;
|
|
if (!strncmp(ucom->pdata->port_name, "LOG", 3) && dump_log_size) {
|
return skw_ucom_dump_from_buffer(buf, count, pos);
|
}
|
|
spin_lock_irqsave(&ucom->lock, flags);
|
if(ucom->rx_busy) {
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
return -EAGAIN;
|
}
|
ucom->rx_busy = 1;
|
if(count > ucom->pdata->max_buffer_size)
|
count = ucom->pdata->max_buffer_size;
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
ret = ucom->pdata->hw_sdma_rx(ucom->portno, ucom->rx_buf, count);
|
ucom->rx_busy = 0;
|
data = (uint32_t *)ucom->rx_buf;
|
|
if(ret > 0) {
|
r = ret;
|
if(ret > count)
|
ret = copy_to_user(buf, ucom->rx_buf, count);
|
else
|
ret = copy_to_user(buf, ucom->rx_buf, ret);
|
if(ret > 0)
|
return -EFAULT;
|
} else r = ret;
|
pr_debug("%s %s ret = %d\n", __func__,current->comm, (int)r);
|
return r;
|
}
|
|
static ssize_t ucom_write(struct file *fp, const char __user *buf, size_t count, loff_t *pos)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
int ret = 0;
|
ssize_t r = count;
|
ssize_t size;
|
unsigned long flags;
|
|
if(cp_exception_sts || atomic_read(&ucom->open)==0)
|
return -EIO;
|
spin_lock_irqsave(&ucom->lock, flags);
|
if(ucom->tx_busy) {
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
skwboot_log("%s error 0\n", __func__);
|
return -EAGAIN;
|
}
|
ucom->tx_busy = 1;
|
spin_unlock_irqrestore(&ucom->lock, flags);
|
while(count){
|
if(count > ucom->pdata->max_buffer_size)
|
size = ucom->pdata->max_buffer_size;
|
else
|
size = count;
|
if(copy_from_user(ucom->tx_buf, buf, size))
|
return -EFAULT;
|
|
if(ucom->pdata->port_name && !strncmp(ucom->pdata->port_name, "LOG", 3)){
|
if(!strncmp(ucom->tx_buf, "START", 5)){
|
skwboot_log("%s START log to file \n", __func__);
|
log_start = skw_modem_log_init(ucom->pdata, NULL, (void *)ucom);
|
|
}
|
else if(!strncmp(ucom->tx_buf, "STOP", 4)){
|
skwboot_log("%s STOP log to file \n", __func__);
|
skw_modem_log_exit();
|
log_start = 0;
|
}
|
else
|
skwboot_log("%s LOG write string:%s \n", __func__, ucom->tx_buf);
|
ucom->tx_busy = 0;
|
return r;
|
}
|
if (ucom->pdata->port_name && !strncmp(ucom->pdata->port_name, "ATC", 3)) {
|
ucom->tx_buf[size++] = 0x0D;
|
ucom->tx_buf[size++] = 0x0A;
|
count += 2;
|
}
|
ret = ucom->pdata->hw_sdma_tx(ucom->portno, ucom->tx_buf, size);
|
|
if(ret < 0){
|
skwboot_log("the close the ucom tx_busy=0");
|
ucom->tx_busy=0;
|
return ret;
|
}
|
count -= ret;
|
buf += ret;
|
}
|
ucom->tx_busy = 0;
|
pr_debug("%s %s ret = %d\n", __func__,current->comm,(int)r);
|
return r;
|
}
|
|
static long ucom_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
int i;
|
|
for(i=0; i< UCOM_PORTNO_MAX; i++) {
|
if(ucoms[i] == ucom)
|
break;
|
}
|
if((i<UCOM_PORTNO_MAX) && atomic_read(&ucom->open)) {
|
skwboot_log("%s ucom_%p rx_busy=%d\n", __func__, ucom, ucom->rx_busy);
|
if (ucom->pdata && ucom->rx_busy)
|
ucom->pdata->close_port(ucom->portno);
|
}
|
return 0;
|
}
|
#ifdef CONFIG_COMPAT
|
static long ucom_compat_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
|
{
|
return ucom_ioctl(fp, cmd, (unsigned long)compat_ptr(arg));
|
}
|
#endif
|
static ssize_t boot_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)
|
{
|
u32 status;
|
struct ucom_dev *ucom = fp->private_data;
|
int ret = 0;
|
|
ret = ucom->pdata->hw_sdma_rx(ucom->portno, (char *)&status, 4);
|
if (ret > 0)
|
ret = copy_to_user(buf, &status, ret);
|
return ret;
|
}
|
|
|
static ssize_t boot_write(struct file *fp, const char __user *buf, size_t count, loff_t *pos)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
int ret = 0;
|
ret = ucom->pdata->hw_sdma_tx(ucom->portno, "WAKE", 4);
|
if(ret > 0)
|
return count;
|
|
return ret;
|
}
|
static long boot_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
|
{
|
struct ucom_dev *ucom = fp->private_data;
|
unsigned char cp_log_state = 0;
|
int ret = 0;
|
switch (cmd) {
|
case 0:
|
ret = copy_to_user((char*)arg, (char*)&tmp_chipid, 4);
|
skwboot_log("the orgchip = %s ,the chipid = 0x%x\n",(char *)ucom->pdata->chipid, tmp_chipid);
|
break;
|
case _IOWR('S', 1, uint8_t *):
|
break;
|
case _IOWR('S', 2, uint8_t *):
|
#ifdef CONFIG_SEEKWAVE_PLD_RELEASE
|
cp_log_state =1; //close log
|
//skw_sdio_cp_log(1);
|
#else
|
cp_log_state = 2;//open log
|
#endif
|
ret = copy_to_user((char*)arg, (char*)&cp_log_state, 1);
|
skwboot_log("the cp_log_state = %d \n", cp_log_state);
|
break;
|
}
|
return 0;
|
}
|
|
#ifdef CONFIG_COMPAT
|
static long boot_compat_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
|
{
|
return boot_ioctl(fp, cmd, (unsigned long)compat_ptr(arg));
|
}
|
#endif
|
|
static const struct file_operations skw_ucom_ops = {
|
.owner = THIS_MODULE,
|
.open = ucom_open,
|
.read = ucom_read,
|
.write = ucom_write,
|
.unlocked_ioctl = ucom_ioctl,
|
#ifdef CONFIG_COMPAT
|
.compat_ioctl = ucom_compat_ioctl,
|
#endif
|
.release= ucom_release,
|
};
|
static const struct file_operations skw_user_boot_ops = {
|
.owner = THIS_MODULE,
|
.open = user_boot_open,
|
.read = boot_read,
|
.write = boot_write,
|
.unlocked_ioctl = boot_ioctl,
|
#ifdef CONFIG_COMPAT
|
.compat_ioctl = boot_compat_ioctl,
|
#endif
|
.release= user_boot_release,
|
};
|
|
static int skw_ucom_probe(struct platform_device *pdev)
|
{
|
struct device *dev = &pdev->dev;
|
struct sv6160_platform_data *pdata = dev->platform_data;
|
struct ucom_dev *ucom;
|
int ret = 0;
|
|
mutex_lock(&ucom_mutex);
|
if(skw_com_class == NULL) {
|
skw_com_class = class_create(THIS_MODULE, "btcom");
|
if(IS_ERR(skw_com_class)) {
|
skwboot_log("skw_ucom_probe: class prt = %p\n", skw_com_class);
|
ret = PTR_ERR(skw_com_class);
|
skw_com_class = NULL;
|
mutex_unlock(&ucom_mutex);
|
return ret;
|
}else{
|
skwboot_log(
|
"skw_ucom_probe:class prt = %p, name = %s\n",
|
skw_com_class, skw_com_class->name);
|
}
|
}
|
mutex_unlock(&ucom_mutex);
|
|
if (pdata) {
|
ucom = kzalloc(sizeof(struct ucom_dev), GFP_KERNEL);
|
if(!ucom)
|
return -ENOMEM;
|
if (strncmp(pdata->port_name, "BTBOOT", 6)) {
|
ucom->rx_buf = kzalloc(pdata->max_buffer_size, GFP_KERNEL);
|
if(ucom->rx_buf) {
|
ucom->tx_buf = kzalloc(pdata->max_buffer_size, GFP_KERNEL);
|
if(!ucom->tx_buf) {
|
kfree(ucom->rx_buf);
|
kfree(ucom);
|
return -ENOMEM;
|
}
|
}else{
|
kfree(ucom);
|
return -ENOMEM;
|
}
|
ret =__register_chrdev(skw_major, pdata->data_port+1, 1, pdata->port_name, &skw_ucom_ops);
|
} else {
|
pdata->data_port = UCOM_PORTNO_MAX - 1;
|
ret =__register_chrdev(skw_major, UCOM_PORTNO_MAX, 1,
|
pdata->port_name, &skw_user_boot_ops);
|
}
|
if(ret < 0) {
|
kfree(ucom->rx_buf);
|
kfree(ucom->tx_buf);
|
kfree(ucom);
|
return ret;
|
}
|
if(skw_major == 0)
|
skw_major = ret;
|
ucom->devno = MKDEV(skw_major, pdata->data_port+1);
|
ucom->pdata = pdata;
|
ucom->portno = pdata->data_port;
|
atomic_set(&ucom->open, 0);
|
platform_set_drvdata(pdev, ucom);
|
ucoms[ucom->portno] = ucom;
|
device_create(skw_com_class, NULL, ucom->devno, NULL, "%s", pdata->port_name);
|
if(!strncmp(ucom->pdata->port_name, "ATC", 3))
|
skw_bt_state_event_init(ucom);
|
if (!strncmp(ucom->pdata->port_name, "LOG", 3)) {
|
log_portno = ucom->portno;
|
#ifndef CONFIG_SEEKWAVE_PLD_RELEASE
|
log_start = skw_modem_log_init(ucom->pdata, NULL, (void *)ucom);
|
#endif
|
}
|
return 0;
|
}
|
return -EINVAL;
|
}
|
|
static int skw_ucom_remove(struct platform_device *pdev)
|
{
|
struct device *dev = &pdev->dev;
|
struct sv6160_platform_data *pdata = dev->platform_data;
|
struct ucom_dev *ucom;
|
int ret, i;
|
int devno;
|
|
ucom = platform_get_drvdata(pdev);
|
|
if(ucom) {
|
if(!strncmp(ucom->pdata->port_name, "LOG", 3)) {
|
skw_modem_log_exit();
|
log_start = 0;
|
}
|
|
if(!strncmp(ucom->pdata->port_name, "BTCMD", 5)) {
|
if (ucom->rx_busy) {
|
ucom->pdata->close_port(ucom->portno);
|
}
|
cp_exception_sts = 0;
|
}
|
if (!strncmp(ucom->pdata->port_name, "ATC", 3)) {
|
skw_bt_state_event_deinit(ucom);
|
}
|
ret = wait_event_interruptible_timeout(ucom->wq,
|
(!atomic_read(&ucom->open)),
|
msecs_to_jiffies(1000));
|
if (ret <= 0) {
|
skwboot_warn(
|
"%s: open timeout ucom%p %s(0x%x) -- open_count=%d \n",
|
__func__, ucom, ucom->pdata->port_name,
|
ucom->devno, atomic_read(&ucom->open));
|
}
|
skwboot_log("%s: ucom%p %s(0x%x) -- open_count=%d \n", __func__, ucom,
|
ucom->pdata->port_name, ucom->devno,atomic_read(&ucom->open));
|
|
devno = ucom->devno;
|
device_destroy(skw_com_class, devno);
|
ucoms[ucom->portno] = NULL;
|
kfree(ucom->rx_buf);
|
ucom->rx_buf = NULL;
|
kfree(ucom->tx_buf);
|
ucom->tx_buf = NULL;
|
if (!atomic_read(&ucom->open)) {
|
kfree(ucom);
|
ucom = NULL;
|
}else
|
atomic_set(&ucom->open, 0);
|
__unregister_chrdev(MAJOR(devno), MINOR(devno), 1, pdata->port_name);
|
platform_set_drvdata(pdev, NULL);
|
}
|
for(i=0; i<UCOM_PORTNO_MAX; i++) {
|
if(ucoms[i])
|
break;
|
}
|
if (i >= UCOM_PORTNO_MAX && skw_com_class) {
|
class_destroy(skw_com_class);
|
skw_com_class = NULL;
|
}
|
return 0;
|
}
|
|
static struct platform_driver skw_ucom_driver = {
|
.driver = {
|
.name = (char*)"skw_ucom",
|
.bus = &platform_bus_type,
|
.pm = UCOM_DEV_PM_OPS,
|
},
|
.probe = skw_ucom_probe,
|
.remove = skw_ucom_remove,
|
};
|
|
int skw_ucom_init(void)
|
{
|
dump_log_size = 0;
|
log_start = 0;
|
mutex_init(&ucom_mutex);
|
platform_driver_register(&skw_ucom_driver);
|
return 0;
|
}
|
|
void skw_ucom_exit(void)
|
{
|
if (dump_memory_buffer)
|
kfree(dump_memory_buffer);
|
dump_memory_buffer = NULL;
|
dump_log_size = 0;
|
cp_exception_sts=0;
|
mutex_destroy(&ucom_mutex);
|
platform_driver_unregister(&skw_ucom_driver);
|
}
|
