404 lines
14 KiB
C
404 lines
14 KiB
C
/**
|
||
* @file ips.c
|
||
* @brief
|
||
*
|
||
* Copyright (c) 2021 Bouffalolab team
|
||
*
|
||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||
* contributor license agreements. See the NOTICE file distributed with
|
||
* this work for additional information regarding copyright ownership. The
|
||
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
||
* "License"); you may not use this file except in compliance with the
|
||
* License. You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
* License for the specific language governing permissions and limitations
|
||
* under the License.
|
||
*
|
||
*/
|
||
|
||
#include "drv_mmheap.h"
|
||
#include "hal_uart.h"
|
||
#include "hal_dma.h"
|
||
#include "data_protocol.h"
|
||
|
||
struct device *uart;
|
||
static isp_obj_t *isp_obj_uart;
|
||
|
||
void ips_obj_init(isp_obj_t *isp_obj_p)
|
||
{
|
||
if (!isp_obj_p)
|
||
return;
|
||
isp_obj_p->cmd_id = 0;
|
||
isp_obj_p->check = 0;
|
||
isp_obj_p->length = 0;
|
||
isp_obj_p->file_type = 0;
|
||
isp_obj_p->auot_ack = 1;
|
||
isp_obj_p->status.isp_state_mode = 0;
|
||
isp_obj_p->status.already_steps = 0;
|
||
}
|
||
|
||
/**
|
||
* @brief uart tx dma irq, ch0
|
||
*
|
||
* @param dev
|
||
* @param args
|
||
* @param size
|
||
* @param state
|
||
*/
|
||
void dma_ch0_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state)
|
||
{
|
||
if (isp_obj_uart == NULL) {
|
||
return;
|
||
}
|
||
|
||
/* close dma and dma irq */
|
||
device_control(uart, DEVICE_CTRL_TX_DMA_SUSPEND, NULL);
|
||
device_control(UART_DEV(uart)->tx_dma, DEVICE_CTRL_CLR_INT, NULL);
|
||
|
||
if (isp_obj_uart->status.isp_state_mode == SEND_DATA) {
|
||
isp_obj_uart->status.isp_state_mode = SEND_WAIT_ACK;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_SEND_ACK_WAIT);
|
||
}
|
||
}
|
||
|
||
// void dma_ch1_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state)
|
||
// {
|
||
// if (isp_obj_uart == NULL) {
|
||
// return;
|
||
// }
|
||
|
||
// if (isp_obj_uart->status.isp_state_mode == RECEIVE_DATA) {
|
||
// isp_obj_uart->status.isp_state_mode = RECEIVE_WAIT_ACK;
|
||
// isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_RECEIVE_ACK_WAIT);
|
||
// }
|
||
// device_control(uart, DEVICE_CTRL_RX_DMA_SUSPEND, 0);
|
||
// isp_obj_uart->status.already_steps = 0;
|
||
// device_control(uart, DEVICE_CTRL_SET_INT, (void *)(UART_RX_FIFO_IT));
|
||
|
||
// MSG("tx dma init\r\n");
|
||
// }
|
||
|
||
uint8_t isp_check(isp_obj_t *isp_obj)
|
||
{
|
||
if (isp_obj == NULL) {
|
||
return 0;
|
||
}
|
||
uint8_t check = isp_obj->cmd_id + (isp_obj->length & 0x00FF) + ((isp_obj->length >> 8) & 0x00FF);
|
||
|
||
if (isp_obj->length && isp_obj->file_data) {
|
||
for (uint16_t i = 0; i < isp_obj->length; i++) {
|
||
check += isp_obj->file_data[i];
|
||
}
|
||
}
|
||
return check;
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param isp_obj_uart
|
||
* @return int
|
||
*/
|
||
int isp_uart_send_data(isp_obj_t *isp_obj_uart)
|
||
{
|
||
if (isp_obj_uart == NULL || isp_obj_uart->cmd_id == 0) {
|
||
return -1;
|
||
}
|
||
|
||
if ((isp_obj_uart->cmd_id & 0xF0) != 0x50)
|
||
return -2;
|
||
|
||
if (isp_obj_uart->status.isp_state_mode != NO_TASK)
|
||
return -3;
|
||
|
||
isp_obj_uart->check = isp_check(isp_obj_uart);
|
||
|
||
/* use tx blocking */
|
||
device_write(uart, 0, (void *)isp_obj_uart, sizeof(isp_cmd_id_t) + sizeof(uint8_t) + sizeof(uint16_t) + sizeof(isp_file_type_t));
|
||
|
||
/* use DMA tx non-blocking */
|
||
device_control(uart, DEVICE_CTRL_TX_DMA_RESUME, NULL);
|
||
device_control(UART_DEV(uart)->tx_dma, DEVICE_CTRL_SET_INT, NULL);
|
||
device_write(uart, 0, isp_obj_uart->file_data, isp_obj_uart->length);
|
||
|
||
isp_obj_uart->status.already_steps = 0;
|
||
isp_obj_uart->status.isp_state_mode = SEND_DATA;
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param isp_obj_uart
|
||
* @return int
|
||
*/
|
||
|
||
int isp_uart_send_ack(isp_obj_t *isp_obj_uart, ips_reply_t ips_reply)
|
||
{
|
||
if (isp_obj_uart == NULL || isp_obj_uart->cmd_id == 0) {
|
||
return -1;
|
||
}
|
||
|
||
// if (isp_obj_uart->status.isp_state_mode != RECEIVE_WAIT_ACK) {
|
||
// return -2;
|
||
// }
|
||
|
||
/* use DMA tx blocking */
|
||
device_write(uart, 0, (uint8_t *)&ips_reply, 2);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param isp_obj
|
||
* @param buff
|
||
* @param size
|
||
*/
|
||
void isp_task_handler(isp_obj_t *isp_obj, uint8_t *buff, uint32_t size)
|
||
{
|
||
static uint32_t time_last = 0;
|
||
|
||
uint32_t time_now = bflb_platform_get_time_ms();
|
||
|
||
/* debug information */
|
||
// MSG("hand:%d, len:%d, mode:%d\r\n", isp_obj_uart->status.already_steps, isp_obj_uart->status.receive_length, isp_obj_uart->status.isp_state_mode);
|
||
|
||
if (size == 0) {
|
||
if ((time_now - time_last > isp_obj->time_out) && isp_obj->time_out) {
|
||
/* time out */
|
||
}
|
||
}
|
||
|
||
for (uint32_t i = 0; i < size; i++) {
|
||
/* receive 状态机 */
|
||
switch (isp_obj_uart->status.already_steps) {
|
||
case 0:
|
||
if (isp_obj_uart->status.isp_state_mode == NO_TASK) {
|
||
isp_obj_uart->status.isp_state_mode = OTHER_STATE;
|
||
} else if (isp_obj_uart->status.isp_state_mode != SEND_WAIT_ACK) {
|
||
return;
|
||
}
|
||
|
||
isp_obj_uart->cmd_id = *buff;
|
||
isp_obj_uart->status.already_steps++;
|
||
|
||
break;
|
||
case 1:
|
||
isp_obj_uart->check = *buff;
|
||
isp_obj_uart->status.already_steps++;
|
||
|
||
if (isp_obj_uart->status.isp_state_mode == SEND_WAIT_ACK) {
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
if (isp_obj_uart->cmd_id == 0X4F && isp_obj_uart->check == 0X4B) {
|
||
isp_obj_uart->status.ips_reply = REPLY_SUCCES;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_SEND_SUCCES_ACK);
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
isp_obj_uart->status.already_steps = 0;
|
||
} else if (isp_obj_uart->cmd_id == 0X52 && isp_obj_uart->check == 0X45) {
|
||
isp_obj_uart->status.ips_reply = REPLY_ERROR;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_SEND_ERROR_ACK);
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
isp_obj_uart->status.already_steps = 0;
|
||
}
|
||
}
|
||
break;
|
||
case 2:
|
||
isp_obj_uart->length = *buff;
|
||
isp_obj_uart->status.already_steps++;
|
||
break;
|
||
case 3:
|
||
isp_obj_uart->length += *buff << 8;
|
||
isp_obj_uart->status.already_steps++;
|
||
break;
|
||
case 4: /* 接收的如果是命令，无法判断命令是简短命令(只需回复2个字节信息)，还是复杂命令(需要回复一段数据包)，需要自己在用户回调函数里处理，但这似乎不太合理 */
|
||
isp_obj_uart->file_type = *buff;
|
||
isp_obj_uart->status.already_steps++;
|
||
if ((isp_obj_uart->cmd_id & 0xF0) == 0x50) {
|
||
isp_obj_uart->status.isp_state_mode = RECEIVE_DATA;
|
||
isp_obj_uart->status.receive_length = 0;
|
||
} else {
|
||
isp_obj_uart->status.already_steps = 0;
|
||
/* 等待ACK的时候收到命令，同时代表 命令 与 成功ACK */
|
||
if (isp_obj_uart->status.isp_state_mode == SEND_WAIT_ACK) {
|
||
/* 响应 CMD 含义 */
|
||
isp_obj_uart->status.isp_state_mode = RECEIVE_WAIT_ACK;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_CMD_);
|
||
/* 响应 ACK 含义 */
|
||
isp_obj_uart->status.ips_reply = REPLY_SUCCES;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_SEND_SUCCES_ACK);
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
} else {
|
||
/* 正常空闲收到命令 */
|
||
isp_obj_uart->status.isp_state_mode = RECEIVE_WAIT_ACK;
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_CMD_);
|
||
}
|
||
//isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
}
|
||
|
||
break;
|
||
case 5:
|
||
if (isp_obj_uart->status.receive_length < isp_obj_uart->length) {
|
||
isp_obj_uart->file_data[isp_obj_uart->status.receive_length] = *buff;
|
||
isp_obj_uart->status.receive_length++;
|
||
}
|
||
if (isp_obj_uart->status.receive_length >= isp_obj_uart->length) {
|
||
isp_obj_uart->status.isp_state_mode = RECEIVE_WAIT_ACK;
|
||
uint8_t check_data = isp_check(isp_obj_uart);
|
||
//MSG("check:%X\r\n", check);
|
||
if (isp_obj_uart->check == check_data) {
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_RECEIVE_ACK_WAIT);
|
||
/* auot send ack */
|
||
if (isp_obj_uart->auot_ack == 0) {
|
||
isp_uart_send_ack(isp_obj_uart, REPLY_SUCCES);
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
}
|
||
} else {
|
||
isp_obj_uart->isp_callback(isp_obj_uart, ISP_CALLBACK_RECEIVE_NACK_WAIT);
|
||
/* auot send Nack */
|
||
if (isp_obj_uart->auot_ack == 0) {
|
||
isp_uart_send_ack(isp_obj_uart, REPLY_ERROR);
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
}
|
||
}
|
||
|
||
isp_obj_uart->status.receive_length = 0;
|
||
isp_obj_uart->status.already_steps = 0;
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
buff++;
|
||
}
|
||
|
||
time_last = time_now;
|
||
}
|
||
|
||
/**
|
||
* @brief uart_irq_callback
|
||
*
|
||
* @param dev
|
||
* @param args
|
||
* @param size
|
||
* @param state
|
||
*/
|
||
void uart_irq_callback(struct device *dev, void *args, uint32_t size, uint32_t state)
|
||
{
|
||
static uint8_t fer_err_flag = 0;
|
||
if (state == UART_EVENT_RX_FIFO || state == UART_EVENT_RTO) {
|
||
if (isp_obj_uart == NULL) {
|
||
return;
|
||
}
|
||
|
||
/* Tx fifo overflow, send nack*/
|
||
if(fer_err_flag){
|
||
if(state == UART_EVENT_RX_FIFO){
|
||
|
||
}else if(state == UART_EVENT_RTO){
|
||
isp_obj_uart->status.isp_state_mode = NO_TASK;
|
||
isp_uart_send_ack(isp_obj_uart, REPLY_ERROR);
|
||
fer_err_flag = 0;
|
||
}
|
||
return;
|
||
}
|
||
|
||
isp_task_handler(isp_obj_uart, args, size);
|
||
}
|
||
else if(state == UART_EVENT_RX_FER){
|
||
/* Tx fifo overflow, baud rate should be reduced */
|
||
fer_err_flag = 1;
|
||
device_control(dev,DEVICE_CTRL_UART_CLEAR_RX_FIFO,NULL);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
*/
|
||
uint8_t isp_uart_init(isp_obj_t *isp_obj)
|
||
{
|
||
if (isp_obj == NULL)
|
||
return 1;
|
||
|
||
uart = device_find("debug_log");
|
||
if(uart){
|
||
device_close(uart);
|
||
}else{
|
||
uart_register(UART0_INDEX, "debug_log");
|
||
uart = device_find("debug_log");
|
||
}
|
||
|
||
if (uart) {
|
||
device_close(uart);
|
||
UART_DEV(uart)->id = 0;
|
||
UART_DEV(uart)->baudrate = 3000000;
|
||
UART_DEV(uart)->databits = UART_DATA_LEN_8;
|
||
UART_DEV(uart)->stopbits = UART_STOP_ONE;
|
||
UART_DEV(uart)->parity = UART_PAR_NONE;
|
||
UART_DEV(uart)->fifo_threshold = 4;
|
||
|
||
device_close(uart);
|
||
device_open(uart, DEVICE_OFLAG_DMA_TX | DEVICE_OFLAG_INT_RX);
|
||
bflb_platform_delay_ms(5);
|
||
device_set_callback(uart, uart_irq_callback);
|
||
device_control(uart, DEVICE_CTRL_SET_INT, (void *)(UART_RX_FIFO_IT | UART_RTO_IT));
|
||
}
|
||
|
||
dma_register(DMA0_CH0_INDEX, "ch0");
|
||
struct device *dma_ch0 = device_find("ch0");
|
||
|
||
if (dma_ch0) {
|
||
DMA_DEV(dma_ch0)->direction = DMA_MEMORY_TO_PERIPH;
|
||
DMA_DEV(dma_ch0)->transfer_mode = DMA_LLI_ONCE_MODE;
|
||
DMA_DEV(dma_ch0)->src_req = DMA_REQUEST_NONE;
|
||
DMA_DEV(dma_ch0)->dst_req = DMA_REQUEST_UART0_TX;
|
||
DMA_DEV(dma_ch0)->src_addr_inc = DMA_ADDR_INCREMENT_ENABLE;
|
||
DMA_DEV(dma_ch0)->dst_addr_inc = DMA_ADDR_INCREMENT_DISABLE;
|
||
DMA_DEV(dma_ch0)->src_burst_size = DMA_BURST_INCR1;
|
||
DMA_DEV(dma_ch0)->dst_burst_size = DMA_BURST_INCR1;
|
||
DMA_DEV(dma_ch0)->src_width = DMA_TRANSFER_WIDTH_8BIT;
|
||
DMA_DEV(dma_ch0)->dst_width = DMA_TRANSFER_WIDTH_8BIT;
|
||
device_open(dma_ch0, 0);
|
||
|
||
device_control(uart, DEVICE_CTRL_ATTACH_TX_DMA, dma_ch0);
|
||
device_set_callback(dma_ch0, dma_ch0_irq_callback);
|
||
/* close dma irq */
|
||
//device_control(UART_DEV(uart)->tx_dma, DEVICE_CTRL_CLR_INT, NULL);
|
||
}
|
||
|
||
// dma_register(DMA0_CH1_INDEX, "ch1");
|
||
// struct device *dma_ch1 = device_find("ch1");
|
||
|
||
// if (dma_ch1) {
|
||
// DMA_DEV(dma_ch1)->direction = DMA_PERIPH_TO_MEMORY;
|
||
// DMA_DEV(dma_ch1)->transfer_mode = DMA_LLI_ONCE_MODE;
|
||
// DMA_DEV(dma_ch1)->src_req = DMA_REQUEST_UART0_RX;
|
||
// DMA_DEV(dma_ch1)->dst_req = DMA_REQUEST_NONE;
|
||
// DMA_DEV(dma_ch1)->src_addr_inc = DMA_ADDR_INCREMENT_DISABLE;
|
||
// DMA_DEV(dma_ch1)->dst_addr_inc = DMA_ADDR_INCREMENT_ENABLE;
|
||
// DMA_DEV(dma_ch1)->src_burst_size = DMA_BURST_INCR1;
|
||
// DMA_DEV(dma_ch1)->dst_burst_size = DMA_BURST_INCR1;
|
||
// DMA_DEV(dma_ch1)->src_width = DMA_TRANSFER_WIDTH_8BIT;
|
||
// DMA_DEV(dma_ch1)->dst_width = DMA_TRANSFER_WIDTH_8BIT;
|
||
// device_open(dma_ch1, 0);
|
||
|
||
// device_control(uart, DEVICE_CTRL_ATTACH_RX_DMA, dma_ch1);
|
||
// device_set_callback(dma_ch1, dma_ch1_irq_callback);
|
||
// device_control(dma_ch1, DEVICE_CTRL_SET_INT, NULL);
|
||
// }
|
||
|
||
device_control(uart, DEVICE_CTRL_TX_DMA_SUSPEND, NULL);
|
||
|
||
isp_obj_uart = isp_obj;
|
||
|
||
return 0;
|
||
}
|