first commit for chrg
This commit is contained in:
@@ -0,0 +1,398 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-06-15 Sherman the first version
|
||||
*/
|
||||
|
||||
#define DBG_TAG "RTLINK_DEV"
|
||||
#define DBG_LVL DBG_LOG
|
||||
#include <rtdbg.h>
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <rtlink_dev.h>
|
||||
|
||||
#define RTLINK_SERV(dev) (((struct rt_link_device*)dev)->service)
|
||||
|
||||
#ifdef RT_USING_POSIX_DEVIO
|
||||
#include <unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/statfs.h>
|
||||
#include <poll.h>
|
||||
|
||||
int rtlink_fops_open(struct dfs_file *fd)
|
||||
{
|
||||
rt_uint16_t flags = 0;
|
||||
rt_device_t device;
|
||||
|
||||
switch (fd->flags & O_ACCMODE)
|
||||
{
|
||||
case O_RDONLY:
|
||||
LOG_D("fops open: O_RDONLY!");
|
||||
flags = RT_DEVICE_FLAG_RDONLY;
|
||||
break;
|
||||
case O_WRONLY:
|
||||
LOG_D("fops open: O_WRONLY!");
|
||||
flags = RT_DEVICE_FLAG_WRONLY;
|
||||
break;
|
||||
case O_RDWR:
|
||||
LOG_D("fops open: O_RDWR!");
|
||||
flags = RT_DEVICE_FLAG_RDWR;
|
||||
break;
|
||||
default:
|
||||
LOG_E("fops open: unknown mode - %d!", fd->flags & O_ACCMODE);
|
||||
break;
|
||||
}
|
||||
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
if (fd->flags & O_NONBLOCK)
|
||||
{
|
||||
rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
|
||||
}
|
||||
|
||||
return rt_device_open(device, flags);
|
||||
}
|
||||
|
||||
int rtlink_fops_close(struct dfs_file *fd)
|
||||
{
|
||||
rt_device_t device;
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
|
||||
rt_device_set_rx_indicate(device, RT_NULL);
|
||||
return rt_device_close(device);
|
||||
}
|
||||
|
||||
int rtlink_fops_ioctl(struct dfs_file *fd, int cmd, void *args)
|
||||
{
|
||||
rt_device_t device;
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
|
||||
if (cmd == O_NONBLOCK)
|
||||
{
|
||||
return rt_device_control(device, RT_LINK_TX_NONBLOCKING | RT_LINK_RX_NONBLOCKING, RT_NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
return rt_device_control(device, cmd, args);
|
||||
}
|
||||
}
|
||||
|
||||
int rtlink_fops_read(struct dfs_file *fd, void *buf, size_t count)
|
||||
{
|
||||
int size = 0;
|
||||
rt_device_t device;
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
|
||||
size = rt_device_read(device, -1, buf, count);
|
||||
if (size <= 0)
|
||||
{
|
||||
size = -EAGAIN;
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
int rtlink_fops_write(struct dfs_file *fd, const void *buf, size_t count)
|
||||
{
|
||||
int size = 0;
|
||||
rt_device_t device;
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
|
||||
size = rt_device_write(device, -1, buf, count);
|
||||
if (size <= 0)
|
||||
{
|
||||
size = -EAGAIN;
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
int rtlink_fops_poll(struct dfs_file *fd, struct rt_pollreq *req)
|
||||
{
|
||||
int mask = 0;
|
||||
int flags = 0;
|
||||
rt_device_t device;
|
||||
struct rt_link_device *rtlink_dev;
|
||||
|
||||
device = (rt_device_t)fd->vnode->data;
|
||||
RT_ASSERT(device != RT_NULL);
|
||||
|
||||
rtlink_dev = (struct rt_link_device *)device;
|
||||
|
||||
flags = fd->flags & O_ACCMODE;
|
||||
if (flags == O_RDONLY || flags == O_RDWR)
|
||||
{
|
||||
rt_base_t level;
|
||||
rt_poll_add(&(device->wait_queue), req);
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
if (RT_NULL != rt_slist_first(&rtlink_dev->recv_head))
|
||||
mask |= POLLIN;
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
mask |= POLLOUT;
|
||||
|
||||
return mask;
|
||||
}
|
||||
|
||||
const static struct dfs_file_ops _rtlink_fops =
|
||||
{
|
||||
rtlink_fops_open,
|
||||
rtlink_fops_close,
|
||||
rtlink_fops_ioctl,
|
||||
rtlink_fops_read,
|
||||
rtlink_fops_write,
|
||||
RT_NULL, /* flush */
|
||||
RT_NULL, /* lseek */
|
||||
RT_NULL, /* getdents */
|
||||
rtlink_fops_poll,
|
||||
};
|
||||
#endif /* RT_USING_POSIX_DEVIO */
|
||||
|
||||
/* The event type for the service channel number,
|
||||
* which is used to wake up the service thread in blocking receive mode */
|
||||
struct rt_event recv_event;
|
||||
|
||||
static rt_err_t rt_link_event_send(struct rt_link_service *serv)
|
||||
{
|
||||
RT_ASSERT(serv != RT_NULL);
|
||||
RT_ASSERT(serv->service < RT_LINK_SERVICE_MAX);
|
||||
rt_uint32_t set = 0x01 << serv->service;
|
||||
return rt_event_send(&recv_event, set);
|
||||
}
|
||||
|
||||
static rt_err_t rt_link_event_recv(struct rt_link_service *service)
|
||||
{
|
||||
RT_ASSERT(service != RT_NULL);
|
||||
RT_ASSERT(service->service < RT_LINK_SERVICE_MAX);
|
||||
|
||||
rt_uint32_t set = 0x01 << service->service;
|
||||
rt_uint32_t recved = 0;
|
||||
rt_err_t ret = rt_event_recv(&recv_event,
|
||||
set,
|
||||
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
|
||||
RT_WAITING_FOREVER,
|
||||
&recved);
|
||||
if (recved & set)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
static void send_cb(struct rt_link_service *service, void *buffer)
|
||||
{
|
||||
RT_ASSERT(service != RT_NULL);
|
||||
RT_ASSERT(buffer != RT_NULL);
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
|
||||
|
||||
if (rtlink && rtlink->parent.tx_complete)
|
||||
{
|
||||
rtlink->parent.tx_complete(&rtlink->parent, buffer);
|
||||
}
|
||||
}
|
||||
|
||||
static void recv_cb(struct rt_link_service *service, void *data, rt_size_t size)
|
||||
{
|
||||
RT_ASSERT(service != RT_NULL);
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)service->user_data;
|
||||
|
||||
if (rtlink)
|
||||
{
|
||||
struct rtlink_recv_list *node = rt_malloc(sizeof(struct rtlink_recv_list));
|
||||
node->data = data;
|
||||
node->size = size;
|
||||
node->index = 0;
|
||||
rt_slist_append(&rtlink->recv_head, &node->list);
|
||||
rt_link_event_send(service);
|
||||
|
||||
if (rtlink->parent.rx_indicate)
|
||||
{
|
||||
rtlink->parent.rx_indicate(&rtlink->parent, size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_free(data);
|
||||
}
|
||||
}
|
||||
|
||||
rt_err_t rt_link_dev_init(rt_device_t dev)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
|
||||
dev->rx_indicate = RT_NULL;
|
||||
dev->tx_complete = RT_NULL;
|
||||
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)dev;
|
||||
rtlink->service.service = RT_LINK_SERVICE_MAX;
|
||||
rtlink->service.recv_cb = RT_NULL;
|
||||
rtlink->service.send_cb = RT_NULL;
|
||||
rtlink->service.timeout_tx = RT_WAITING_NO;
|
||||
rtlink->service.user_data = (void *)dev;
|
||||
|
||||
rt_slist_init(&rtlink->recv_head);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
rt_err_t rt_link_dev_open(rt_device_t dev, rt_uint16_t oflag)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)dev;
|
||||
|
||||
rtlink->service.recv_cb = recv_cb;
|
||||
rtlink->service.send_cb = send_cb;
|
||||
|
||||
dev->open_flag = oflag & RT_DEVICE_OFLAG_MASK;
|
||||
if (dev->open_flag == RT_DEVICE_OFLAG_RDONLY)
|
||||
{
|
||||
rtlink->service.send_cb = RT_NULL;
|
||||
}
|
||||
else if (dev->open_flag == RT_DEVICE_OFLAG_WRONLY)
|
||||
{
|
||||
rtlink->service.recv_cb = RT_NULL;
|
||||
}
|
||||
return rt_link_service_attach(&rtlink->service);
|
||||
}
|
||||
|
||||
rt_err_t rt_link_dev_close(rt_device_t dev)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)dev;
|
||||
return rt_link_service_detach(&rtlink->service);
|
||||
}
|
||||
|
||||
rt_ssize_t rt_link_dev_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
RT_ASSERT(buffer != RT_NULL);
|
||||
RT_ASSERT(size != 0);
|
||||
|
||||
struct rt_link_device *rtlink = (struct rt_link_device *)dev;
|
||||
struct rtlink_recv_list *node;
|
||||
rt_size_t read_len = 0;
|
||||
rt_size_t unread_len = 0;
|
||||
|
||||
if (dev->rx_indicate == RT_NULL)
|
||||
{
|
||||
/* RT_LINK_RX_BLOCKING, wait service receive data event */
|
||||
rt_link_event_recv(&rtlink->service);
|
||||
}
|
||||
|
||||
if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
|
||||
{
|
||||
node = rt_container_of(rt_slist_next(&rtlink->recv_head), struct rtlink_recv_list, list);
|
||||
unread_len = (node->size) - (node->index);
|
||||
read_len = (size > unread_len) ? unread_len : size;
|
||||
rt_memcpy(buffer, (rt_uint8_t *)node->data + node->index, read_len);
|
||||
node->index += read_len;
|
||||
|
||||
if (node->index >= node->size)
|
||||
{
|
||||
rt_slist_remove(&rtlink->recv_head, &node->list);
|
||||
node->index = 0;
|
||||
rt_free(node->data);
|
||||
rt_free(node);
|
||||
}
|
||||
if (rt_slist_first(&rtlink->recv_head) != RT_NULL)
|
||||
{
|
||||
rt_link_event_send(&rtlink->service);
|
||||
}
|
||||
}
|
||||
return read_len;
|
||||
}
|
||||
|
||||
rt_ssize_t rt_link_dev_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
RT_ASSERT(buffer != RT_NULL);
|
||||
RT_ASSERT(size != 0);
|
||||
|
||||
return rt_link_send(&RTLINK_SERV(dev), buffer, size);
|
||||
}
|
||||
|
||||
rt_err_t rt_link_dev_control(rt_device_t dev, int cmd, void *args)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
|
||||
if (cmd & RT_DEVICE_CTRL_CONFIG)
|
||||
{
|
||||
if (args == RT_NULL)
|
||||
return -RT_EINVAL;
|
||||
RTLINK_SERV(dev).service = ((struct rt_link_service *)args)->service;
|
||||
RTLINK_SERV(dev).timeout_tx = ((struct rt_link_service *)args)->timeout_tx;
|
||||
RTLINK_SERV(dev).flag = ((struct rt_link_service *)args)->flag;
|
||||
}
|
||||
|
||||
if (cmd & RT_LINK_RX_BLOCKING)
|
||||
{
|
||||
dev->rx_indicate = RT_NULL;
|
||||
}
|
||||
if (cmd & RT_LINK_TX_BLOCKING)
|
||||
{
|
||||
RTLINK_SERV(dev).timeout_tx = RT_WAITING_FOREVER;
|
||||
dev->tx_complete = RT_NULL;
|
||||
}
|
||||
if (cmd & RT_LINK_TX_NONBLOCKING)
|
||||
{
|
||||
RTLINK_SERV(dev).timeout_tx = RT_WAITING_NO;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops rtlink_ops =
|
||||
{
|
||||
rt_link_dev_init,
|
||||
rt_link_dev_open,
|
||||
rt_link_dev_close,
|
||||
rt_link_dev_read,
|
||||
rt_link_dev_write,
|
||||
rt_link_dev_control
|
||||
};
|
||||
#endif /* RT_USING_DEVICE_OPS */
|
||||
|
||||
/*
|
||||
* rtlink device register
|
||||
*/
|
||||
rt_err_t rt_link_dev_register(struct rt_link_device *rtlink,
|
||||
const char *name,
|
||||
rt_uint32_t flag,
|
||||
void *data)
|
||||
{
|
||||
rt_err_t ret;
|
||||
struct rt_device *device;
|
||||
RT_ASSERT(rtlink != RT_NULL);
|
||||
|
||||
device = (struct rt_device *)rtlink;
|
||||
device->type = RT_Device_Class_Char;
|
||||
device->rx_indicate = RT_NULL;
|
||||
device->tx_complete = RT_NULL;
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->ops = &rtlink_ops;
|
||||
#else
|
||||
device->init = rt_link_dev_init;
|
||||
device->open = rt_link_dev_open;
|
||||
device->close = rt_link_dev_close;
|
||||
device->read = rt_link_dev_read;
|
||||
device->write = rt_link_dev_write;
|
||||
device->control = rt_link_dev_control;
|
||||
#endif
|
||||
device->user_data = data;
|
||||
|
||||
/* register a character device */
|
||||
ret = rt_device_register(device, name, flag);
|
||||
|
||||
#ifdef RT_USING_POSIX_DEVIO
|
||||
/* set fops */
|
||||
device->fops = &_rtlink_fops;
|
||||
#endif
|
||||
|
||||
rt_event_init(&recv_event, "rtlink_dev", RT_IPC_FLAG_FIFO);
|
||||
return ret;
|
||||
}
|
||||
Reference in New Issue
Block a user