|
@@ -27,7 +27,7 @@ static VIRT_UART_HandleTypeDef huart0;
|
|
|
|
|
|
static rt_uint8_t rx_buffer[MAX_BUFFER_SIZE];
|
|
static rt_uint8_t rx_buffer[MAX_BUFFER_SIZE];
|
|
static rt_uint8_t tx_buffer[MAX_BUFFER_SIZE];
|
|
static rt_uint8_t tx_buffer[MAX_BUFFER_SIZE];
|
|
-
|
|
|
|
|
|
+
|
|
struct rthw_openamp
|
|
struct rthw_openamp
|
|
{
|
|
{
|
|
struct rt_device parent;
|
|
struct rt_device parent;
|
|
@@ -36,41 +36,41 @@ struct rthw_openamp
|
|
};
|
|
};
|
|
static struct rthw_openamp dev_openamp;
|
|
static struct rthw_openamp dev_openamp;
|
|
|
|
|
|
-void IPCC_RX1_IRQHandler(void)
|
|
|
|
|
|
+void IPCC_RX1_IRQHandler(void)
|
|
{
|
|
{
|
|
rt_interrupt_enter();
|
|
rt_interrupt_enter();
|
|
-
|
|
|
|
|
|
+
|
|
HAL_IPCC_RX_IRQHandler(&hipcc);
|
|
HAL_IPCC_RX_IRQHandler(&hipcc);
|
|
-
|
|
|
|
|
|
+
|
|
rt_interrupt_leave();
|
|
rt_interrupt_leave();
|
|
}
|
|
}
|
|
|
|
|
|
void IPCC_TX1_IRQHandler(void)
|
|
void IPCC_TX1_IRQHandler(void)
|
|
{
|
|
{
|
|
rt_interrupt_enter();
|
|
rt_interrupt_enter();
|
|
-
|
|
|
|
|
|
+
|
|
HAL_IPCC_TX_IRQHandler(&hipcc);
|
|
HAL_IPCC_TX_IRQHandler(&hipcc);
|
|
-
|
|
|
|
|
|
+
|
|
rt_interrupt_leave();
|
|
rt_interrupt_leave();
|
|
}
|
|
}
|
|
|
|
|
|
-void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)
|
|
|
|
-{
|
|
|
|
|
|
+void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)
|
|
|
|
+{
|
|
rt_uint16_t rx_size = 0, i = 0;
|
|
rt_uint16_t rx_size = 0, i = 0;
|
|
rt_size_t count, size, offset;
|
|
rt_size_t count, size, offset;
|
|
rt_uint8_t *buf = RT_NULL;
|
|
rt_uint8_t *buf = RT_NULL;
|
|
-
|
|
|
|
|
|
+
|
|
struct rthw_openamp *device;
|
|
struct rthw_openamp *device;
|
|
device = (struct rthw_openamp *)rt_device_find("openamp");
|
|
device = (struct rthw_openamp *)rt_device_find("openamp");
|
|
RT_ASSERT(device != RT_NULL);
|
|
RT_ASSERT(device != RT_NULL);
|
|
-
|
|
|
|
- buf = device->serial.rbuf;
|
|
|
|
|
|
+
|
|
|
|
+ buf = device->serial.rbuf;
|
|
count = device->serial.rbuf_count;
|
|
count = device->serial.rbuf_count;
|
|
size = device->serial.rbuf_size;
|
|
size = device->serial.rbuf_size;
|
|
offset = device->serial.rbuf_start + count;
|
|
offset = device->serial.rbuf_start + count;
|
|
-
|
|
|
|
|
|
+
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
-
|
|
|
|
|
|
+
|
|
rx_size = (huart->RxXferSize < MAX_BUFFER_SIZE) ? huart->RxXferSize : MAX_BUFFER_SIZE - 1;
|
|
rx_size = (huart->RxXferSize < MAX_BUFFER_SIZE) ? huart->RxXferSize : MAX_BUFFER_SIZE - 1;
|
|
|
|
|
|
if (count < size)
|
|
if (count < size)
|
|
@@ -79,7 +79,7 @@ void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)
|
|
{
|
|
{
|
|
offset -= size;
|
|
offset -= size;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
for (i = 0; i < rx_size; i++)
|
|
for (i = 0; i < rx_size; i++)
|
|
{
|
|
{
|
|
buf[offset++] = huart->pRxBuffPtr[i];
|
|
buf[offset++] = huart->pRxBuffPtr[i];
|
|
@@ -88,16 +88,16 @@ void VIRT_UART0_RxCpltCallback(VIRT_UART_HandleTypeDef *huart)
|
|
}
|
|
}
|
|
|
|
|
|
device->serial.rbuf_count = count;
|
|
device->serial.rbuf_count = count;
|
|
-
|
|
|
|
|
|
+
|
|
rt_sem_release(&device->sema);
|
|
rt_sem_release(&device->sema);
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
static rt_err_t _init(struct rt_device *dev)
|
|
static rt_err_t _init(struct rt_device *dev)
|
|
{
|
|
{
|
|
struct rthw_openamp *device;
|
|
struct rthw_openamp *device;
|
|
device = (struct rthw_openamp *)dev;
|
|
device = (struct rthw_openamp *)dev;
|
|
RT_ASSERT(device != RT_NULL);
|
|
RT_ASSERT(device != RT_NULL);
|
|
-
|
|
|
|
|
|
+
|
|
device->serial.rbuf_start = 0;
|
|
device->serial.rbuf_start = 0;
|
|
device->serial.rbuf_count = 0;
|
|
device->serial.rbuf_count = 0;
|
|
device->serial.tbuf_start = 0;
|
|
device->serial.tbuf_start = 0;
|
|
@@ -106,79 +106,79 @@ static rt_err_t _init(struct rt_device *dev)
|
|
device->serial.tbuf_size = MAX_BUFFER_SIZE;
|
|
device->serial.tbuf_size = MAX_BUFFER_SIZE;
|
|
device->serial.rbuf = rx_buffer;
|
|
device->serial.rbuf = rx_buffer;
|
|
device->serial.tbuf = tx_buffer;
|
|
device->serial.tbuf = tx_buffer;
|
|
-
|
|
|
|
|
|
+
|
|
if (rt_sem_init(&device->sema, "openamplock", 1, RT_IPC_FLAG_FIFO) != RT_EOK)
|
|
if (rt_sem_init(&device->sema, "openamplock", 1, RT_IPC_FLAG_FIFO) != RT_EOK)
|
|
{
|
|
{
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
return RT_EOK;
|
|
return RT_EOK;
|
|
}
|
|
}
|
|
|
|
|
|
static rt_ssize_t _read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
|
|
static rt_ssize_t _read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
|
|
{
|
|
{
|
|
rt_size_t count, rbsize, offset;
|
|
rt_size_t count, rbsize, offset;
|
|
- rt_uint8_t *buf = RT_NULL;
|
|
|
|
|
|
+ rt_uint8_t *buf = RT_NULL;
|
|
rt_uint8_t *pBuffer = RT_NULL;
|
|
rt_uint8_t *pBuffer = RT_NULL;
|
|
rt_uint16_t i = 0;
|
|
rt_uint16_t i = 0;
|
|
-
|
|
|
|
|
|
+
|
|
struct rthw_openamp *device;
|
|
struct rthw_openamp *device;
|
|
device = (struct rthw_openamp *)dev;
|
|
device = (struct rthw_openamp *)dev;
|
|
RT_ASSERT(device != RT_NULL);
|
|
RT_ASSERT(device != RT_NULL);
|
|
-
|
|
|
|
|
|
+
|
|
pBuffer = (unsigned char*)buffer;
|
|
pBuffer = (unsigned char*)buffer;
|
|
count = device->serial.rbuf_count;
|
|
count = device->serial.rbuf_count;
|
|
buf = device->serial.rbuf;
|
|
buf = device->serial.rbuf;
|
|
-
|
|
|
|
|
|
+
|
|
if (count == 0)
|
|
if (count == 0)
|
|
{
|
|
{
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
-
|
|
|
|
|
|
+
|
|
if (count >= size)
|
|
if (count >= size)
|
|
{
|
|
{
|
|
count = size;
|
|
count = size;
|
|
- }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
offset = device->serial.rbuf_start;
|
|
offset = device->serial.rbuf_start;
|
|
rbsize = device->serial.rbuf_size;
|
|
rbsize = device->serial.rbuf_size;
|
|
-
|
|
|
|
|
|
+
|
|
for (i = 0; i < count; i++)
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
{
|
|
*pBuffer++ = buf[offset++];
|
|
*pBuffer++ = buf[offset++];
|
|
if (offset > rbsize)
|
|
if (offset > rbsize)
|
|
{
|
|
{
|
|
- offset = 0;
|
|
|
|
|
|
+ offset = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
device->serial.rbuf_start = offset;
|
|
device->serial.rbuf_start = offset;
|
|
device->serial.rbuf_count -= count;
|
|
device->serial.rbuf_count -= count;
|
|
-
|
|
|
|
|
|
+
|
|
rt_sem_release(&device->sema);
|
|
rt_sem_release(&device->sema);
|
|
-
|
|
|
|
|
|
+
|
|
return count;
|
|
return count;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
static rt_ssize_t _write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
|
static rt_ssize_t _write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
|
{
|
|
{
|
|
rt_err_t result = VIRT_UART_OK;
|
|
rt_err_t result = VIRT_UART_OK;
|
|
-
|
|
|
|
|
|
+
|
|
struct rthw_openamp *device;
|
|
struct rthw_openamp *device;
|
|
device = (struct rthw_openamp *)dev;
|
|
device = (struct rthw_openamp *)dev;
|
|
RT_ASSERT(device != RT_NULL);
|
|
RT_ASSERT(device != RT_NULL);
|
|
-
|
|
|
|
|
|
+
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
rt_sem_take(&device->sema, RT_WAITING_FOREVER);
|
|
- result = VIRT_UART_Transmit(&huart0, (uint8_t *)buffer, size);
|
|
|
|
|
|
+ result = VIRT_UART_Transmit(&huart0, (uint8_t *)buffer, size);
|
|
rt_sem_release(&device->sema);
|
|
rt_sem_release(&device->sema);
|
|
-
|
|
|
|
|
|
+
|
|
if (result != VIRT_UART_OK)
|
|
if (result != VIRT_UART_OK)
|
|
{
|
|
{
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
return size;
|
|
return size;
|
|
}
|
|
}
|
|
|
|
|
|
@@ -206,7 +206,7 @@ static rt_err_t rt_hw_openamp_register(struct rthw_openamp *openamp, const char
|
|
}
|
|
}
|
|
|
|
|
|
static int openamp_init(void)
|
|
static int openamp_init(void)
|
|
-{
|
|
|
|
|
|
+{
|
|
extern int MX_OPENAMP_Init(int RPMsgRole, rpmsg_ns_bind_cb ns_bind_cb);
|
|
extern int MX_OPENAMP_Init(int RPMsgRole, rpmsg_ns_bind_cb ns_bind_cb);
|
|
|
|
|
|
/* IPCC init */
|
|
/* IPCC init */
|
|
@@ -217,25 +217,25 @@ static int openamp_init(void)
|
|
}
|
|
}
|
|
/* openamp slave device */
|
|
/* openamp slave device */
|
|
MX_OPENAMP_Init(RPMSG_REMOTE, NULL);
|
|
MX_OPENAMP_Init(RPMSG_REMOTE, NULL);
|
|
-
|
|
|
|
- if (VIRT_UART_Init(&huart0) != VIRT_UART_OK)
|
|
|
|
|
|
+
|
|
|
|
+ if (VIRT_UART_Init(&huart0) != VIRT_UART_OK)
|
|
{
|
|
{
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
}
|
|
}
|
|
- if (VIRT_UART_RegisterCallback(&huart0, VIRT_UART_RXCPLT_CB_ID, VIRT_UART0_RxCpltCallback) != VIRT_UART_OK)
|
|
|
|
|
|
+ if (VIRT_UART_RegisterCallback(&huart0, VIRT_UART_RXCPLT_CB_ID, VIRT_UART0_RxCpltCallback) != VIRT_UART_OK)
|
|
{
|
|
{
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
}
|
|
}
|
|
-
|
|
|
|
- return RT_EOK;
|
|
|
|
|
|
+
|
|
|
|
+ return RT_EOK;
|
|
}
|
|
}
|
|
|
|
|
|
int rt_hw_openamp_init(void)
|
|
int rt_hw_openamp_init(void)
|
|
{
|
|
{
|
|
openamp_init();
|
|
openamp_init();
|
|
-
|
|
|
|
|
|
+
|
|
rt_hw_openamp_register(&dev_openamp, "openamp", 0, NULL);
|
|
rt_hw_openamp_register(&dev_openamp, "openamp", 0, NULL);
|
|
-
|
|
|
|
|
|
+
|
|
if (rt_strcmp(RT_CONSOLE_DEVICE_NAME, "openamp") == 0)
|
|
if (rt_strcmp(RT_CONSOLE_DEVICE_NAME, "openamp") == 0)
|
|
{
|
|
{
|
|
rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
|
|
rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
|
|
@@ -245,27 +245,27 @@ int rt_hw_openamp_init(void)
|
|
}
|
|
}
|
|
INIT_PREV_EXPORT(rt_hw_openamp_init);
|
|
INIT_PREV_EXPORT(rt_hw_openamp_init);
|
|
|
|
|
|
-static void openamp_thread_entry(void *parameter)
|
|
|
|
|
|
+static void openamp_thread_entry(void *parameter)
|
|
{
|
|
{
|
|
rt_size_t size = 0;
|
|
rt_size_t size = 0;
|
|
struct rthw_openamp *device = RT_NULL;
|
|
struct rthw_openamp *device = RT_NULL;
|
|
-
|
|
|
|
|
|
+
|
|
device = (struct rthw_openamp *)rt_device_find("openamp");
|
|
device = (struct rthw_openamp *)rt_device_find("openamp");
|
|
RT_ASSERT(device != RT_NULL);
|
|
RT_ASSERT(device != RT_NULL);
|
|
-
|
|
|
|
- for (;;)
|
|
|
|
|
|
+
|
|
|
|
+ for (;;)
|
|
{
|
|
{
|
|
OPENAMP_check_for_message();
|
|
OPENAMP_check_for_message();
|
|
|
|
|
|
size = device->serial.rbuf_count;
|
|
size = device->serial.rbuf_count;
|
|
if (size > 0)
|
|
if (size > 0)
|
|
{
|
|
{
|
|
- if (device->parent.rx_indicate != RT_NULL)
|
|
|
|
|
|
+ if (device->parent.rx_indicate != RT_NULL)
|
|
{
|
|
{
|
|
device->parent.rx_indicate(&device->parent, size);
|
|
device->parent.rx_indicate(&device->parent, size);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
-
|
|
|
|
|
|
+
|
|
rt_thread_mdelay(1);
|
|
rt_thread_mdelay(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -273,22 +273,22 @@ static void openamp_thread_entry(void *parameter)
|
|
static int creat_openamp_thread(void)
|
|
static int creat_openamp_thread(void)
|
|
{
|
|
{
|
|
rt_thread_t tid = RT_NULL;
|
|
rt_thread_t tid = RT_NULL;
|
|
-
|
|
|
|
- tid = rt_thread_create("OpenAMP",
|
|
|
|
- openamp_thread_entry,
|
|
|
|
- RT_NULL,
|
|
|
|
- OPENAMP_THREAD_STACK_SIZE,
|
|
|
|
- OPENAMP_THREAD_PRIORITY,
|
|
|
|
|
|
+
|
|
|
|
+ tid = rt_thread_create("OpenAMP",
|
|
|
|
+ openamp_thread_entry,
|
|
|
|
+ RT_NULL,
|
|
|
|
+ OPENAMP_THREAD_STACK_SIZE,
|
|
|
|
+ OPENAMP_THREAD_PRIORITY,
|
|
OPENAMP_THREAD_TIMESLICE);
|
|
OPENAMP_THREAD_TIMESLICE);
|
|
-
|
|
|
|
- if (tid == RT_NULL)
|
|
|
|
|
|
+
|
|
|
|
+ if (tid == RT_NULL)
|
|
{
|
|
{
|
|
LOG_E("openamp thread create failed!");
|
|
LOG_E("openamp thread create failed!");
|
|
return -RT_ERROR;
|
|
return -RT_ERROR;
|
|
- }
|
|
|
|
-
|
|
|
|
|
|
+ }
|
|
|
|
+
|
|
rt_thread_startup(tid);
|
|
rt_thread_startup(tid);
|
|
-
|
|
|
|
|
|
+
|
|
return RT_EOK;
|
|
return RT_EOK;
|
|
}
|
|
}
|
|
INIT_APP_EXPORT(creat_openamp_thread);
|
|
INIT_APP_EXPORT(creat_openamp_thread);
|
|
@@ -298,7 +298,7 @@ INIT_APP_EXPORT(creat_openamp_thread);
|
|
static int console(int argc, char **argv)
|
|
static int console(int argc, char **argv)
|
|
{
|
|
{
|
|
rt_err_t result = RT_EOK;
|
|
rt_err_t result = RT_EOK;
|
|
-
|
|
|
|
|
|
+
|
|
if (argc > 1)
|
|
if (argc > 1)
|
|
{
|
|
{
|
|
if (!strcmp(argv[1], "set"))
|
|
if (!strcmp(argv[1], "set"))
|