From 91d866d81a20e014b25365391ee1dda0f544fd01 Mon Sep 17 00:00:00 2001 From: BernardXiong Date: Mon, 6 Jul 2015 18:11:46 +0800 Subject: [PATCH] [DeviceDrivers] Use mutex to lock can_open/close --- components/drivers/can/can.c | 280 ++++++------------- components/drivers/include/drivers/can.h | 332 ++++++++++++----------- 2 files changed, 250 insertions(+), 362 deletions(-) diff --git a/components/drivers/can/can.c b/components/drivers/can/can.c index 4cc02818c6..e0db377018 100644 --- a/components/drivers/can/can.c +++ b/components/drivers/can/can.c @@ -3,20 +3,33 @@ * This file is part of RT-Thread RTOS * COPYRIGHT (C) 2015, RT-Thread Development Team * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rt-thread.org/license/LICENSE + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Change Logs: * Date Author Notes * 2015-05-14 aubrcool@qq.com first version - * 2015-07-06 Bernard code cleanup. + * 2015-07-06 Bernard code cleanup and remove RT_CAN_USING_LED; */ #include #include #include +#define CAN_LOCK(can) rt_mutex_take(&(can->lock), RT_WAITING_FOREVER) +#define CAN_UNLOCK(can) rt_mutex_release(&(can->lock)) + static rt_err_t rt_can_init(struct rt_device *dev) { rt_err_t result = RT_EOK; @@ -54,7 +67,6 @@ rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, in while (msgs) { rt_base_t level; - rt_int32_t hdr; struct rt_can_msg_list *listmsg = RT_NULL; /* disable interrupt */ @@ -75,6 +87,7 @@ rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, in } else if (hdr == -1) #endif /*RT_CAN_USING_HDR*/ + { if (!rt_list_isempty(&rx_fifo->uselist)) { listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list); @@ -86,7 +99,7 @@ rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, in listmsg->owner->msgs--; } listmsg->owner = RT_NULL; -#endif +#endif /*RT_CAN_USING_HDR*/ } else { @@ -94,17 +107,20 @@ rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, in rt_hw_interrupt_enable(level); break; } + } /* enable interrupt */ rt_hw_interrupt_enable(level); if (listmsg != RT_NULL) { rt_memcpy(data, &listmsg->data, sizeof(struct rt_can_msg)); + level = rt_hw_interrupt_disable(); rt_list_insert_before(&rx_fifo->freelist, &listmsg->list); rx_fifo->freenumbers++; RT_ASSERT(rx_fifo->freenumbers <= can->config.msgboxsz); rt_hw_interrupt_enable(level); + listmsg = RT_NULL; } else @@ -146,20 +162,23 @@ rt_inline int _can_int_tx(struct rt_can_device *can, const struct rt_can_msg *da else { rt_hw_interrupt_enable(level); + rt_completion_wait(&(tx_fifo->completion), RT_WAITING_FOREVER); continue; } rt_hw_interrupt_enable(level); no = ((rt_uint32_t)tx_tosnd - (rt_uint32_t)tx_fifo->buffer) / sizeof(struct rt_can_sndbxinx_list); - tx_tosnd->result = RT_CAN__SND_RESUTL_WAIT; - if (can->ops->sendmsg(can, data , no)) + tx_tosnd->result = RT_CAN_SND_RESULT_WAIT; + if (can->ops->sendmsg(can, data, no) != RT_EOK) { + /* send failed. */ level = rt_hw_interrupt_disable(); rt_list_insert_after(&tx_fifo->freelist, &tx_tosnd->list); rt_hw_interrupt_enable(level); continue; } + can->status.sndchange = 1; rt_completion_wait(&(tx_tosnd->completion), RT_WAITING_FOREVER); @@ -172,11 +191,12 @@ rt_inline int _can_int_tx(struct rt_can_device *can, const struct rt_can_msg *da rt_list_insert_before(&tx_fifo->freelist, &tx_tosnd->list); rt_hw_interrupt_enable(level); - if (result == RT_CAN__SND_RESUTL_OK) + if (result == RT_CAN_SND_RESULT_OK) { level = rt_hw_interrupt_disable(); can->status.sndpkg++; rt_hw_interrupt_enable(level); + data ++; msgs -= sizeof(struct rt_can_msg); if (!msgs) break; @@ -192,13 +212,9 @@ rt_inline int _can_int_tx(struct rt_can_device *can, const struct rt_can_msg *da level = rt_hw_interrupt_disable(); if (rt_list_isempty(&tx_fifo->freelist)) { - rt_hw_interrupt_enable(level); rt_completion_done(&(tx_fifo->completion)); } - else - { - rt_hw_interrupt_enable(level); - } + rt_hw_interrupt_enable(level); } return (size - msgs); @@ -226,16 +242,17 @@ rt_inline int _can_int_tx_priv(struct rt_can_device *can, const struct rt_can_ms } level = rt_hw_interrupt_disable(); - if ((tx_fifo->buffer[no].result != RT_CAN__SND_RESUTL_OK)) + if ((tx_fifo->buffer[no].result != RT_CAN_SND_RESULT_OK)) { rt_hw_interrupt_enable(level); + rt_completion_wait(&(tx_fifo->buffer[no].completion), RT_WAITING_FOREVER); continue; } - tx_fifo->buffer[no].result = RT_CAN__SND_RESUTL_WAIT; + tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_WAIT; rt_hw_interrupt_enable(level); - if (can->ops->sendmsg(can, data , no) != RT_EOK) + if (can->ops->sendmsg(can, data, no) != RT_EOK) { continue; } @@ -243,7 +260,7 @@ rt_inline int _can_int_tx_priv(struct rt_can_device *can, const struct rt_can_ms rt_completion_wait(&(tx_fifo->buffer[no].completion), RT_WAITING_FOREVER); result = tx_fifo->buffer[no].result; - if (result == RT_CAN__SND_RESUTL_OK) + if (result == RT_CAN_SND_RESULT_OK) { level = rt_hw_interrupt_disable(); can->status.sndpkg++; @@ -271,19 +288,21 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) RT_ASSERT(dev != RT_NULL); can = (struct rt_can_device *)dev; + CAN_LOCK(can); + /* get open flags */ dev->open_flag = oflag & 0xff; - rt_enter_critical(); if (can->can_rx == RT_NULL) { if (oflag & RT_DEVICE_FLAG_INT_RX) { - int i=0; + int i = 0; struct rt_can_rx_fifo *rx_fifo; rx_fifo = (struct rt_can_rx_fifo *) rt_malloc(sizeof(struct rt_can_rx_fifo) + can->config.msgboxsz * sizeof(struct rt_can_msg_list)); RT_ASSERT(rx_fifo != RT_NULL); + rx_fifo->buffer = (struct rt_can_msg_list *)(rx_fifo + 1); rt_memset(rx_fifo->buffer, 0, can->config.msgboxsz * sizeof(struct rt_can_msg_list)); rt_list_init(&rx_fifo->freelist); @@ -298,7 +317,6 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) #endif } can->can_rx = rx_fifo; - rt_exit_critical(); dev->open_flag |= RT_DEVICE_FLAG_INT_RX; /* configure low level device */ @@ -307,15 +325,9 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) else { can->can_rx = RT_NULL; - rt_exit_critical(); } } - else - { - rt_exit_critical(); - } - rt_enter_critical(); if (can->can_tx == RT_NULL) { if (oflag & RT_DEVICE_FLAG_INT_TX) @@ -326,6 +338,7 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) tx_fifo = (struct rt_can_tx_fifo *) rt_malloc(sizeof(struct rt_can_tx_fifo) + can->config.sndboxnumber * sizeof(struct rt_can_sndbxinx_list)); RT_ASSERT(tx_fifo != RT_NULL); + tx_fifo->buffer = (struct rt_can_sndbxinx_list *)(tx_fifo + 1); rt_memset(tx_fifo->buffer, 0, can->config.sndboxnumber * sizeof(struct rt_can_sndbxinx_list)); @@ -334,11 +347,11 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) { rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list); rt_completion_init(&(tx_fifo->buffer[i].completion)); - tx_fifo->buffer[i].result = RT_CAN__SND_RESUTL_OK; + tx_fifo->buffer[i].result = RT_CAN_SND_RESULT_OK; } rt_completion_init(&(tx_fifo->completion)); can->can_tx = tx_fifo; - rt_exit_critical(); + dev->open_flag |= RT_DEVICE_FLAG_INT_TX; /* configure low level device */ can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX); @@ -346,25 +359,17 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) else { can->can_tx = RT_NULL; - rt_exit_critical(); } } - else - { - rt_exit_critical(); - } can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_CAN_INT_ERR); + #ifdef RT_CAN_USING_HDR - rt_enter_critical(); if (can->hdr == RT_NULL) { int i = 0; struct rt_can_hdr *phdr; - /* exit critical region for malloc a header. */ - rt_exit_critical(); - phdr = (struct rt_can_hdr *) rt_malloc(can->config.maxhdr * sizeof(struct rt_can_hdr)); RT_ASSERT(phdr != RT_NULL); rt_memset(phdr, 0, can->config.maxhdr * sizeof(struct rt_can_hdr)); @@ -373,45 +378,18 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) rt_list_init(&phdr[i].list); } - rt_enter_critical(); can->hdr = phdr; - rt_exit_critical(); - } - else - { - rt_exit_critical(); } #endif - rt_enter_critical(); if (!can->timerinitflag) { can->timerinitflag = 1; - rt_exit_critical(); -#ifdef RT_CAN_USING_LED - if (can->config.rcvled != RT_NULL) - { - rt_pin_mode(can->config.rcvled->pin, can->config.rcvled->mode); - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init); - } - if (can->config.sndled != RT_NULL) - { - rt_pin_mode(can->config.sndled->pin, can->config.sndled->mode); - rt_pin_write(can->config.sndled->pin, can->config.sndled->init); - } - if (can->config.errled != RT_NULL) - { - rt_pin_mode(can->config.errled->pin, can->config.errled->mode); - rt_pin_write(can->config.errled->pin, can->config.errled->init); - } -#endif rt_timer_start(&can->timer); } - else - { - rt_exit_critical(); - } + + CAN_UNLOCK(can); return RT_EOK; } @@ -423,48 +401,33 @@ static rt_err_t rt_can_close(struct rt_device *dev) RT_ASSERT(dev != RT_NULL); can = (struct rt_can_device *)dev; - /* this device has more reference count */ - if (dev->ref_count > 1) return RT_EOK; + CAN_LOCK(can); + + /* this device has more reference count */ + if (dev->ref_count > 1) + { + CAN_UNLOCK(can); + return RT_EOK; + } - rt_enter_critical(); if (can->timerinitflag) { can->timerinitflag = 0; - rt_exit_critical(); + rt_timer_stop(&can->timer); -#ifdef RT_CAN_USING_LED - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init); - rt_pin_write(can->config.rcvled->pin, can->config.sndled->init); - rt_pin_write(can->config.rcvled->pin, can->config.errled->init); -#endif - } - else - { - rt_exit_critical(); } - rt_enter_critical(); can->status_indicate.ind = RT_NULL; can->status_indicate.args = RT_NULL; - rt_exit_critical(); #ifdef RT_CAN_USING_HDR - rt_enter_critical(); if (can->hdr != RT_NULL) { - struct rt_can_hdr *hdr; - - hdr = can->hdr; + rt_free(can->hdr); can->hdr = RT_NULL; - rt_exit_critical(); - - rt_free(hdr); - } - else - { - rt_exit_critical(); } #endif + if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) { struct rt_can_rx_fifo *rx_fifo; @@ -475,8 +438,9 @@ static rt_err_t rt_can_close(struct rt_device *dev) rt_free(rx_fifo); dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX; /* configure low level device */ - can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_TX); + can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_RX); } + if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) { struct rt_can_tx_fifo *tx_fifo; @@ -489,7 +453,11 @@ static rt_err_t rt_can_close(struct rt_device *dev) /* configure low level device */ can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_TX); } + can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_CAN_INT_ERR); + + CAN_UNLOCK(can); + return RT_EOK; } @@ -505,7 +473,7 @@ static rt_size_t rt_can_read(struct rt_device *dev, can = (struct rt_can_device *)dev; - if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) + if ((dev->open_flag & RT_DEVICE_FLAG_INT_RX) && (dev->ref_count > 0)) { return _can_int_rx(can, buffer, size); } @@ -525,7 +493,7 @@ static rt_size_t rt_can_write(struct rt_device *dev, can = (struct rt_can_device *)dev; - if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) + if ((dev->open_flag & RT_DEVICE_FLAG_INT_TX) && (dev->ref_count > 0)) { if (can->config.privmode) { @@ -573,10 +541,8 @@ static rt_err_t rt_can_control(struct rt_device *dev, rt_base_t level; struct rt_can_tx_fifo *tx_fifo; - if (res = can->ops->control(can, cmd, args) != RT_EOK) - { - return res; - } + res = can->ops->control(can, cmd, args); + if (res != RT_EOK) return res; tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; if (can->config.privmode) @@ -595,7 +561,7 @@ static rt_err_t rt_can_control(struct rt_device *dev, for (i = 0; i < can->config.sndboxnumber; i++) { level = rt_hw_interrupt_disable(); - if (tx_fifo->buffer[i].result == RT_CAN__SND_RESUTL_OK) + if (tx_fifo->buffer[i].result == RT_CAN_SND_RESULT_OK) { rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list); } @@ -605,10 +571,12 @@ static rt_err_t rt_can_control(struct rt_device *dev, return RT_EOK; } break; + case RT_CAN_CMD_SET_STATUS_IND: can->status_indicate.ind = ((rt_can_status_ind_type_t)args)->ind; can->status_indicate.args = ((rt_can_status_ind_type_t)args)->args; break; + #ifdef RT_CAN_USING_HDR case RT_CAN_CMD_SET_FILTER: res = can->ops->control(can, cmd, args); @@ -636,8 +604,8 @@ static rt_err_t rt_can_control(struct rt_device *dev, pitem++; continue; } - level = rt_hw_interrupt_disable(); + level = rt_hw_interrupt_disable(); if (!can->hdr[pitem->hdr].connected) { rt_memcpy(&can->hdr[pitem->hdr].filter, pitem, @@ -647,6 +615,7 @@ static rt_err_t rt_can_control(struct rt_device *dev, rt_list_init(&can->hdr[pitem->hdr].list); } rt_hw_interrupt_enable(level); + count--; pitem++; } @@ -682,6 +651,7 @@ static rt_err_t rt_can_control(struct rt_device *dev, } break; #endif /*RT_CAN_USING_HDR*/ + default : /* control device */ if (can->ops->control != RT_NULL) @@ -699,105 +669,14 @@ static rt_err_t rt_can_control(struct rt_device *dev, */ static void cantimeout(void *arg) { -#ifdef RT_CAN_USING_LED - rt_uint32_t ledonflag = 0; -#endif /*RT_CAN_USING_LED*/ rt_can_t can = (rt_can_t)arg; rt_device_control((rt_device_t)can, RT_CAN_CMD_GET_STATUS, (void *)&can->status); if (can->timerinitflag == 1) { -#ifdef RT_CAN_USING_LED - ledonflag = 1; -#endif /*RT_CAN_USING_LED*/ can->timerinitflag = 0xFF; } -#ifdef RT_CAN_USING_LED - if (can->config.rcvled != RT_NULL && can->config.sndled == RT_NULL) - { - if (ledonflag == 1) - { - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init ? 0 : 1); - } - else - { - if (can->status.rcvchange == 1 || can->status.sndchange == 1) - { - can->status.rcvchange = 0; - can->status.sndchange = 0; - rt_pin_write(can->config.rcvled->pin, rt_pin_read(can->config.rcvled->pin) ? 0 : 1); - } - else - { - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init); - } - } - } - else if (can->config.rcvled != RT_NULL && can->config.sndled != RT_NULL) - { - if (ledonflag == 1) - { - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init ? 0 : 1); - rt_pin_write(can->config.sndled->pin, can->config.sndled->init ? 0 : 1); - } - else - { - if (can->status.rcvchange == 1) - { - can->status.rcvchange = 0; - rt_pin_write(can->config.rcvled->pin, rt_pin_read(can->config.rcvled->pin) ? 0 : 1); - } - else - { - rt_pin_write(can->config.rcvled->pin, can->config.rcvled->init); - } - if (can->status.sndchange == 1) - { - can->status.sndchange = 0; - rt_pin_write(can->config.sndled->pin, rt_pin_read(can->config.sndled->pin) ? 0 : 1); - } - else - { - rt_pin_write(can->config.sndled->pin, can->config.sndled->init); - } - } - } - else if (can->config.rcvled == RT_NULL && can->config.sndled != RT_NULL) - { - if (ledonflag == 1) - { - rt_pin_write(can->config.sndled->pin, can->config.sndled->init ? 0 : 1); - } - else - { - if (can->status.rcvchange == 1 || can->status.sndchange == 1) - { - can->status.rcvchange = 0; - can->status.sndchange = 0; - rt_pin_write(can->config.sndled->pin, rt_pin_read(can->config.sndled->pin) ? 0 : 1); - } - else - { - rt_pin_write(can->config.sndled->pin, can->config.sndled->init); - } - } - } - if (ledonflag == 1) - { - rt_pin_write(can->config.errled->pin, can->config.errled->init ? 0 : 1); - } - else - { - if (can->status.errcode) - { - rt_pin_write(can->config.errled->pin, can->config.errled->init ? 0 : 1); - } - else - { - rt_pin_write(can->config.errled->pin, can->config.errled->init); - } - } -#endif + if (can->status_indicate.ind != RT_NULL) { can->status_indicate.ind(can, can->status_indicate.args); @@ -825,6 +704,8 @@ rt_err_t rt_hw_can_register(struct rt_can_device *can, #endif can->can_rx = RT_NULL; can->can_tx = RT_NULL; + rt_mutex_init(&(can->lock), "can", RT_IPC_FLAG_PRIO); + device->init = rt_can_init; device->open = rt_can_open; device->close = rt_can_close; @@ -838,7 +719,8 @@ rt_err_t rt_hw_can_register(struct rt_can_device *can, rt_memset(&can->status, 0, sizeof(can->status)); device->user_data = data; - can->timerinitflag = 0; + + can->timerinitflag = 0; rt_timer_init(&can->timer, name, cantimeout, @@ -954,6 +836,7 @@ void rt_hw_can_isr(struct rt_can_device *can, int event) } else #endif + { if (can->parent.rx_indicate != RT_NULL) { rt_size_t rx_length; @@ -965,6 +848,7 @@ void rt_hw_can_isr(struct rt_can_device *can, int event) can->parent.rx_indicate(&can->parent, rx_length); } + } break; } @@ -976,13 +860,14 @@ void rt_hw_can_isr(struct rt_can_device *can, int event) no = event >> 8; tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; RT_ASSERT(tx_fifo != RT_NULL); + if ((event & 0xff) == RT_CAN_EVENT_TX_DONE) { - tx_fifo->buffer[no].result = RT_CAN__SND_RESUTL_OK; + tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_OK; } else { - tx_fifo->buffer[no].result = RT_CAN__SND_RESUTL_ERR; + tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_ERR; } rt_completion_done(&(tx_fifo->buffer[no].completion)); break; @@ -1055,3 +940,4 @@ int cmd_canstat(int argc, void **argv) } FINSH_FUNCTION_EXPORT_ALIAS(cmd_canstat, __cmd_canstat, Stat Can Device Status.); #endif + diff --git a/components/drivers/include/drivers/can.h b/components/drivers/include/drivers/can.h index a6c60cd28e..ec0f597f1c 100644 --- a/components/drivers/include/drivers/can.h +++ b/components/drivers/include/drivers/can.h @@ -3,80 +3,76 @@ * This file is part of RT-Thread RTOS * COPYRIGHT (C) 2015, RT-Thread Development Team * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rt-thread.org/license/LICENSE + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Change Logs: - * Date Author Notes - * 2015-05-14 aubrcool@qq.com first version + * Date Author Notes + * 2015-05-14 aubrcool@qq.com first version + * 2015-07-06 Bernard remove RT_CAN_USING_LED. */ + #ifndef CAN_H_ #define CAN_H_ #include #ifndef RT_CANMSG_BOX_SZ -#define RT_CANMSG_BOX_SZ 16 +#define RT_CANMSG_BOX_SZ 16 #endif #ifndef RT_CANSND_BOX_NUM -#define RT_CANSND_BOX_NUM 1 +#define RT_CANSND_BOX_NUM 1 #endif enum CANBAUD { - CAN1MBaud=0, // 1 MBit/sec - CAN800kBaud, // 800 kBit/sec - CAN500kBaud, // 500 kBit/sec - CAN250kBaud, // 250 kBit/sec - CAN125kBaud, // 125 kBit/sec - CAN100kBaud, // 100 kBit/sec - CAN50kBaud, // 50 kBit/sec - CAN20kBaud, // 20 kBit/sec - CAN10kBaud // 10 kBit/sec + CAN1MBaud = 0, /* 1 MBit/sec */ + CAN800kBaud, /* 800 kBit/sec */ + CAN500kBaud, /* 500 kBit/sec */ + CAN250kBaud, /* 250 kBit/sec */ + CAN125kBaud, /* 125 kBit/sec */ + CAN100kBaud, /* 100 kBit/sec */ + CAN50kBaud, /* 50 kBit/sec */ + CAN20kBaud, /* 20 kBit/sec */ + CAN10kBaud /* 10 kBit/sec */ }; -#define RT_CAN_MODE_NORMAL 0 -#define RT_CAN_MODE_LISEN 1 -#define RT_CAN_MODE_LOOPBACK 2 -#define RT_CAN_MODE_LOOPBACKANLISEN 3 -#define RT_CAN_MODE_PRIV 0x01 -#define RT_CAN_MODE_NOPRIV 0x00 +#define RT_CAN_MODE_NORMAL 0 +#define RT_CAN_MODE_LISEN 1 +#define RT_CAN_MODE_LOOPBACK 2 +#define RT_CAN_MODE_LOOPBACKANLISEN 3 -#ifdef RT_CAN_USING_LED -struct rt_can_led -{ - rt_uint32_t pin,mode,init; - struct rt_timer* timer; - const char* timer_name; -}; -#endif /*RT_CAN_USING_LED*/ +#define RT_CAN_MODE_PRIV 0x01 +#define RT_CAN_MODE_NOPRIV 0x00 struct rt_can_filter_item { - rt_uint32_t id :29; - rt_uint32_t ide :1; - rt_uint32_t rtr :1; - rt_uint32_t mode :1; - rt_uint32_t mask; - rt_int32_t hdr; + rt_uint32_t id : 29; + rt_uint32_t ide : 1; + rt_uint32_t rtr : 1; + rt_uint32_t mode : 1; + rt_uint32_t mask; + rt_int32_t hdr; #ifdef RT_CAN_USING_HDR - rt_err_t (*ind)(rt_device_t dev, void* args ,rt_int32_t hdr, rt_size_t size); - void* args; + rt_err_t (*ind)(rt_device_t dev, void *args , rt_int32_t hdr, rt_size_t size); + void *args; #endif /*RT_CAN_USING_HDR*/ }; + #ifdef RT_CAN_USING_HDR #define RT_CAN_FILTER_ITEM_INIT(id,ide,rtr,mode,mask,ind,args) \ - {\ - id,\ - ide,\ - rtr,\ - mode,\ - mask,\ - -1,\ - ind,\ - args,\ - } + {(id), (ide), (rtr), (mode), (mask), -1, (ind), (args)} #define RT_CAN_FILTER_STD_INIT(id,ind,args) \ RT_CAN_FILTER_ITEM_INIT(id,0,0,0,0xFFFFFFFF,ind,args) #define RT_CAN_FILTER_EXT_INIT(id,ind,args) \ @@ -90,15 +86,9 @@ struct rt_can_filter_item #define RT_CAN_EXT_RMT_DATA_FILTER_INIT(id,ind,args) \ RT_CAN_FILTER_ITEM_INIT(id,1,0,1,0xFFFFFFFF,ind,args) #else + #define RT_CAN_FILTER_ITEM_INIT(id,ide,rtr,mode,mask) \ - {\ - id,\ - ide,\ - rtr,\ - mode,\ - mask,\ - -1,\ - } + {(id), (ide), (rtr), (mode), (mask), -1, } #define RT_CAN_FILTER_STD_INIT(id) \ RT_CAN_FILTER_ITEM_INIT(id,0,0,0,0xFFFFFFFF) #define RT_CAN_FILTER_EXT_INIT(id) \ @@ -115,26 +105,22 @@ struct rt_can_filter_item struct rt_can_filter_config { - rt_uint32_t count; - rt_uint32_t actived; - struct rt_can_filter_item* items; + rt_uint32_t count; + rt_uint32_t actived; + struct rt_can_filter_item *items; }; + struct can_configure { - rt_uint32_t baud_rate; - rt_uint32_t msgboxsz; - rt_uint32_t sndboxnumber; - rt_uint32_t mode :8; - rt_uint32_t privmode :8; - rt_uint32_t reserved :16; - #ifdef RT_CAN_USING_LED - const struct rt_can_led* rcvled; - const struct rt_can_led* sndled; - const struct rt_can_led* errled; - #endif /*RT_CAN_USING_LED*/ - rt_uint32_t ticks; + rt_uint32_t baud_rate; + rt_uint32_t msgboxsz; + rt_uint32_t sndboxnumber; + rt_uint32_t mode : 8; + rt_uint32_t privmode : 8; + rt_uint32_t reserved : 16; + rt_uint32_t ticks; #ifdef RT_CAN_USING_HDR - rt_uint32_t maxhdr; + rt_uint32_t maxhdr; #endif }; @@ -147,80 +133,88 @@ struct can_configure }; struct rt_can_ops; -#define RT_CAN_CMD_SET_FILTER 0x13 -#define RT_CAN_CMD_SET_BAUD 0x14 -#define RT_CAN_CMD_SET_MODE 0x15 -#define RT_CAN_CMD_SET_PRIV 0x16 -#define RT_CAN_CMD_GET_STATUS 0x17 -#define RT_CAN_CMD_SET_STATUS_IND 0x18 +#define RT_CAN_CMD_SET_FILTER 0x13 +#define RT_CAN_CMD_SET_BAUD 0x14 +#define RT_CAN_CMD_SET_MODE 0x15 +#define RT_CAN_CMD_SET_PRIV 0x16 +#define RT_CAN_CMD_GET_STATUS 0x17 +#define RT_CAN_CMD_SET_STATUS_IND 0x18 -#define RT_DEVICE_CAN_INT_ERR 0x1000 +#define RT_DEVICE_CAN_INT_ERR 0x1000 enum RT_CAN_STATUS_MODE { - NORMAL = 0, - ERRWARNING = 1, - ERRPASSIVE = 2, - BUSOFF = 4, + NORMAL = 0, + ERRWARNING = 1, + ERRPASSIVE = 2, + BUSOFF = 4, }; enum RT_CAN_BUS_ERR { - RT_CAN_BUS_NO_ERR = 0, - RT_CAN_BUS_BIT_PAD_ERR = 1, - RT_CAN_BUS_FORMAT_ERR = 2, - RT_CAN_BUS_ACK_ERR = 3, - RT_CAN_BUS_IMPLICIT_BIT_ERR = 4, - RT_CAN_BUS_EXPLICIT_BIT_ERR = 5, - RT_CAN_BUS_CRC_ERR = 6, + RT_CAN_BUS_NO_ERR = 0, + RT_CAN_BUS_BIT_PAD_ERR = 1, + RT_CAN_BUS_FORMAT_ERR = 2, + RT_CAN_BUS_ACK_ERR = 3, + RT_CAN_BUS_IMPLICIT_BIT_ERR = 4, + RT_CAN_BUS_EXPLICIT_BIT_ERR = 5, + RT_CAN_BUS_CRC_ERR = 6, }; + struct rt_can_status { - rt_uint32_t rcverrcnt; - rt_uint32_t snderrcnt; - rt_uint32_t errcode; - rt_uint32_t rcvpkg; - rt_uint32_t dropedrcvpkg; - rt_uint32_t sndpkg; - rt_uint32_t dropedsndpkg; - rt_uint32_t bitpaderrcnt; - rt_uint32_t formaterrcnt; - rt_uint32_t ackerrcnt; - rt_uint32_t biterrcnt; - rt_uint32_t crcerrcnt; - rt_uint32_t rcvchange; - rt_uint32_t sndchange; - rt_uint32_t lasterrtype; + rt_uint32_t rcverrcnt; + rt_uint32_t snderrcnt; + rt_uint32_t errcode; + rt_uint32_t rcvpkg; + rt_uint32_t dropedrcvpkg; + rt_uint32_t sndpkg; + rt_uint32_t dropedsndpkg; + rt_uint32_t bitpaderrcnt; + rt_uint32_t formaterrcnt; + rt_uint32_t ackerrcnt; + rt_uint32_t biterrcnt; + rt_uint32_t crcerrcnt; + rt_uint32_t rcvchange; + rt_uint32_t sndchange; + rt_uint32_t lasterrtype; }; + #ifdef RT_CAN_USING_HDR -struct rt_can_hdr { - rt_uint32_t connected; - rt_uint32_t msgs; - struct rt_can_filter_item filter; - struct rt_list_node list; +struct rt_can_hdr +{ + rt_uint32_t connected; + rt_uint32_t msgs; + struct rt_can_filter_item filter; + struct rt_list_node list; }; #endif struct rt_can_device; -typedef rt_err_t (*rt_canstatus_ind)(struct rt_can_device*, void*); +typedef rt_err_t (*rt_canstatus_ind)(struct rt_can_device *, void *); typedef struct rt_can_status_ind_type { rt_canstatus_ind ind; - void* args; + void *args; } *rt_can_status_ind_type_t; + struct rt_can_device { - struct rt_device parent; + struct rt_device parent; - const struct rt_can_ops *ops; - struct can_configure config; - struct rt_can_status status; - rt_uint32_t timerinitflag; - struct rt_timer timer; - struct rt_can_status_ind_type status_indicate; + const struct rt_can_ops *ops; + struct can_configure config; + struct rt_can_status status; + + rt_uint32_t timerinitflag; + struct rt_timer timer; + + struct rt_can_status_ind_type status_indicate; #ifdef RT_CAN_USING_HDR - struct rt_can_hdr* hdr; + struct rt_can_hdr *hdr; #endif - void *can_rx; - void *can_tx; + + struct rt_mutex lock; + void *can_rx; + void *can_tx; }; typedef struct rt_can_device *rt_can_t; @@ -229,68 +223,76 @@ typedef struct rt_can_device *rt_can_t; #define RT_CAN_DTR 0 #define RT_CAN_RTR 1 -typedef struct rt_can_status * rt_can_status_t; +typedef struct rt_can_status *rt_can_status_t; struct rt_can_msg { - rt_uint32_t id :29; - rt_uint32_t ide :1; - rt_uint32_t rtr :1; - rt_uint32_t rsv :1; - rt_uint32_t len :8; - rt_uint32_t priv :8; - rt_uint32_t hdr :8; - rt_uint32_t reserved :8; - rt_uint8_t data[8]; + rt_uint32_t id : 29; + rt_uint32_t ide : 1; + rt_uint32_t rtr : 1; + rt_uint32_t rsv : 1; + rt_uint32_t len : 8; + rt_uint32_t priv : 8; + rt_uint32_t hdr : 8; + rt_uint32_t reserved : 8; + rt_uint8_t data[8]; }; -typedef struct rt_can_msg* rt_can_msg_t; -struct rt_can_msg_list { - struct rt_list_node list; +typedef struct rt_can_msg *rt_can_msg_t; + +struct rt_can_msg_list +{ + struct rt_list_node list; #ifdef RT_CAN_USING_HDR - struct rt_list_node hdrlist; - struct rt_can_hdr* owner; + struct rt_list_node hdrlist; + struct rt_can_hdr *owner; #endif - struct rt_can_msg data; + struct rt_can_msg data; }; + struct rt_can_rx_fifo { - /* software fifo */ - struct rt_can_msg_list *buffer; - rt_uint32_t freenumbers; - struct rt_list_node freelist; - struct rt_list_node uselist; + /* software fifo */ + struct rt_can_msg_list *buffer; + rt_uint32_t freenumbers; + struct rt_list_node freelist; + struct rt_list_node uselist; }; -#define RT_CAN__SND_RESUTL_OK 0 -#define RT_CAN__SND_RESUTL_ERR 1 -#define RT_CAN__SND_RESUTL_WAIT 2 +#define RT_CAN_SND_RESULT_OK 0 +#define RT_CAN_SND_RESULT_ERR 1 +#define RT_CAN_SND_RESULT_WAIT 2 -#define RT_CAN_EVENT_RX_IND 0x01 /* Rx indication */ -#define RT_CAN_EVENT_TX_DONE 0x02 /* Tx complete */ -#define RT_CAN_EVENT_TX_FAIL 0x03 /* Tx complete */ -#define RT_CAN_EVENT_RX_TIMEOUT 0x05 /* Rx timeout */ -#define RT_CAN_EVENT_RXOF_IND 0x06 /* Rx overflow */ +#define RT_CAN_EVENT_RX_IND 0x01 /* Rx indication */ +#define RT_CAN_EVENT_TX_DONE 0x02 /* Tx complete */ +#define RT_CAN_EVENT_TX_FAIL 0x03 /* Tx complete */ +#define RT_CAN_EVENT_RX_TIMEOUT 0x05 /* Rx timeout */ +#define RT_CAN_EVENT_RXOF_IND 0x06 /* Rx overflow */ -struct rt_can_sndbxinx_list { - struct rt_list_node list; - struct rt_completion completion; - rt_uint32_t result; +struct rt_can_sndbxinx_list +{ + struct rt_list_node list; + struct rt_completion completion; + rt_uint32_t result; }; + struct rt_can_tx_fifo { - struct rt_can_sndbxinx_list *buffer; - struct rt_completion completion; - struct rt_list_node freelist; + struct rt_can_sndbxinx_list *buffer; + struct rt_completion completion; + struct rt_list_node freelist; }; + struct rt_can_ops { - rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg); - rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg); - int (*sendmsg)(struct rt_can_device *can, const void* buf, rt_uint32_t boxno); - int (*recvmsg)(struct rt_can_device *can,void* buf, rt_uint32_t boxno); + rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg); + rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg); + int (*sendmsg)(struct rt_can_device *can, const void *buf, rt_uint32_t boxno); + int (*recvmsg)(struct rt_can_device *can, void *buf, rt_uint32_t boxno); }; + rt_err_t rt_hw_can_register(struct rt_can_device *can, - const char *name, - const struct rt_can_ops *ops, - void *data); + const char *name, + const struct rt_can_ops *ops, + void *data); void rt_hw_can_isr(struct rt_can_device *can, int event); #endif /*_CAN_H*/ +