diff --git a/components/drivers/can/can.c b/components/drivers/can/can.c index fc0d74877f..0ed971053d 100644 --- a/components/drivers/can/can.c +++ b/components/drivers/can/can.c @@ -3,18 +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 + * Date Author Notes + * 2015-05-14 aubrcool@qq.com first version + * 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; @@ -33,74 +48,87 @@ static rt_err_t rt_can_init(struct rt_device *dev) return result; } + /* * can interrupt routines */ rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, int msgs) { int size; - struct rt_can_rx_fifo* rx_fifo; + struct rt_can_rx_fifo *rx_fifo; RT_ASSERT(can != RT_NULL); - size = msgs; - - rx_fifo = (struct rt_can_rx_fifo*) can->can_rx; + size = msgs; + + rx_fifo = (struct rt_can_rx_fifo *) can->can_rx; RT_ASSERT(rx_fifo != RT_NULL); /* read from software FIFO */ while (msgs) { rt_base_t level; - struct rt_can_msg_list *listmsg=RT_NULL; + struct rt_can_msg_list *listmsg = RT_NULL; + /* disable interrupt */ level = rt_hw_interrupt_disable(); #ifdef RT_CAN_USING_HDR - rt_int32_t hdr = data->hdr; - if (hdr >=0 && can->hdr && hdr < can->config.maxhdr && !rt_list_isempty(&can->hdr[hdr].list)) + hdr = data->hdr; + + if (hdr >= 0 && can->hdr && hdr < can->config.maxhdr && !rt_list_isempty(&can->hdr[hdr].list)) { - listmsg=rt_list_entry(can->hdr[hdr].list.next, struct rt_can_msg_list, hdrlist); - rt_list_remove(&listmsg->list); - rt_list_remove(&listmsg->hdrlist); - if(can->hdr[hdr].msgs) { - can->hdr[hdr].msgs--; - } - listmsg->owner = RT_NULL; - } 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); - rt_list_remove(&listmsg->list); -#ifdef RT_CAN_USING_HDR - rt_list_remove(&listmsg->hdrlist); - if(listmsg->owner != RT_NULL && listmsg->owner->msgs) { - listmsg->owner->msgs--; - } - listmsg->owner = RT_NULL; -#endif + listmsg = rt_list_entry(can->hdr[hdr].list.next, struct rt_can_msg_list, hdrlist); + rt_list_remove(&listmsg->list); + rt_list_remove(&listmsg->hdrlist); + if (can->hdr[hdr].msgs) + { + can->hdr[hdr].msgs--; + } + listmsg->owner = RT_NULL; } - else + else if (hdr == -1) +#endif /*RT_CAN_USING_HDR*/ { - /* no data, enable interrupt and break out */ - rt_hw_interrupt_enable(level); - break; + if (!rt_list_isempty(&rx_fifo->uselist)) + { + listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list); + rt_list_remove(&listmsg->list); +#ifdef RT_CAN_USING_HDR + rt_list_remove(&listmsg->hdrlist); + if (listmsg->owner != RT_NULL && listmsg->owner->msgs) + { + listmsg->owner->msgs--; + } + listmsg->owner = RT_NULL; +#endif /*RT_CAN_USING_HDR*/ + } + else + { + /* no data, enable interrupt and break out */ + rt_hw_interrupt_enable(level); + break; + } } /* enable interrupt */ rt_hw_interrupt_enable(level); - if(listmsg!=RT_NULL) + if (listmsg != RT_NULL) { - rt_memcpy(data,&listmsg->data,sizeof(struct rt_can_msg)); + rt_memcpy(data, &listmsg->data, sizeof(struct rt_can_msg)); + level = rt_hw_interrupt_disable(); - rt_list_insert_before(&rx_fifo->freelist,&listmsg->list); + 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 { + } + else + { break; } - data ++; msgs -= sizeof(struct rt_can_msg); + data ++; + msgs -= sizeof(struct rt_can_msg); } return (size - msgs); @@ -110,56 +138,68 @@ rt_inline int _can_int_tx(struct rt_can_device *can, const struct rt_can_msg *da { int size; struct rt_can_tx_fifo *tx_fifo; - + RT_ASSERT(can != RT_NULL); size = msgs; - tx_fifo = (struct rt_can_tx_fifo*) can->can_tx; + tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; RT_ASSERT(tx_fifo != RT_NULL); while (msgs) - { + { rt_base_t level; rt_uint32_t no; - struct rt_can_sndbxinx_list* tx_tosnd = RT_NULL; + rt_uint32_t result; + struct rt_can_sndbxinx_list *tx_tosnd = RT_NULL; + level = rt_hw_interrupt_disable(); - if(!rt_list_isempty(&tx_fifo->freelist)) + if (!rt_list_isempty(&tx_fifo->freelist)) { tx_tosnd = rt_list_entry(tx_fifo->freelist.next, struct rt_can_sndbxinx_list, list); RT_ASSERT(tx_tosnd != RT_NULL); rt_list_remove(&tx_tosnd->list); - } else { + } + 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)) + + no = ((rt_uint32_t)tx_tosnd - (rt_uint32_t)tx_fifo->buffer) / sizeof(struct rt_can_sndbxinx_list); + 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_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); + level = rt_hw_interrupt_disable(); - rt_uint32_t result = tx_tosnd->result; - if(!rt_list_isempty(&tx_tosnd->list)) { - rt_list_remove(&tx_tosnd->list); + result = tx_tosnd->result; + if (!rt_list_isempty(&tx_tosnd->list)) + { + rt_list_remove(&tx_tosnd->list); } - rt_list_insert_before(&tx_fifo->freelist,&tx_tosnd->list); + 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; + + data ++; + msgs -= sizeof(struct rt_can_msg); + if (!msgs) break; } else { @@ -170,61 +210,64 @@ 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)) + 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_completion_done(&(tx_fifo->completion)); } + rt_hw_interrupt_enable(level); } return (size - msgs); } + rt_inline int _can_int_tx_priv(struct rt_can_device *can, const struct rt_can_msg *data, int msgs) { int size; + rt_base_t level; + rt_uint32_t no, result; struct rt_can_tx_fifo *tx_fifo; - + RT_ASSERT(can != RT_NULL); size = msgs; - tx_fifo = (struct rt_can_tx_fifo*) can->can_tx; + tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; RT_ASSERT(tx_fifo != RT_NULL); - rt_base_t level; - rt_uint32_t no; - rt_uint32_t result; while (msgs) - { + { no = data->priv; - if(no >= can->config.sndboxnumber) { - break; + if (no >= can->config.sndboxnumber) + { + break; } + level = rt_hw_interrupt_disable(); - if((tx_fifo->buffer[no].result != RT_CAN__SND_RESUTL_OK)) { - rt_hw_interrupt_enable(level); - rt_completion_wait(&(tx_fifo->buffer[no].completion), RT_WAITING_FOREVER); - continue; + 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; } can->status.sndchange = 1; 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++; rt_hw_interrupt_enable(level); - data ++; msgs -= sizeof(struct rt_can_msg); - if(!msgs) break; + data ++; + msgs -= sizeof(struct rt_can_msg); + if (!msgs) break; } else { @@ -237,6 +280,7 @@ rt_inline int _can_int_tx_priv(struct rt_can_device *can, const struct rt_can_ms return (size - msgs); } + static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) { struct rt_can_device *can; @@ -244,123 +288,101 @@ 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) { - struct rt_can_rx_fifo* rx_fifo; + 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)); + 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); + + 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); rt_list_init(&rx_fifo->uselist); - rx_fifo->freenumbers=can->config.msgboxsz; - int i = 0; - for(i = 0; i< can->config.msgboxsz; i++) + rx_fifo->freenumbers = can->config.msgboxsz; + for (i = 0; i < can->config.msgboxsz; i++) { - rt_list_insert_before(&rx_fifo->freelist,&rx_fifo->buffer[i].list); + rt_list_insert_before(&rx_fifo->freelist, &rx_fifo->buffer[i].list); #ifdef RT_CAN_USING_HDR - rt_list_init(&rx_fifo->buffer[i].hdrlist); - rx_fifo->buffer[i].owner = RT_NULL; + rt_list_init(&rx_fifo->buffer[i].hdrlist); + rx_fifo->buffer[i].owner = RT_NULL; #endif } can->can_rx = rx_fifo; - rt_exit_critical(); + dev->open_flag |= RT_DEVICE_FLAG_INT_RX; /* configure low level device */ can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX); } - 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) { + int i = 0; struct rt_can_tx_fifo *tx_fifo; - tx_fifo = (struct rt_can_tx_fifo*) rt_malloc(sizeof(struct rt_can_tx_fifo)+ - can->config.sndboxnumber*sizeof(struct rt_can_sndbxinx_list)); + 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)); + + 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)); rt_list_init(&tx_fifo->freelist); - int i = 0; - for(i = 0; i< can->config.sndboxnumber; i++) + for (i = 0; i < can->config.sndboxnumber; i++) { - 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; + 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_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); } - 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) { - struct rt_can_hdr * phdr; - 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)); + if (can->hdr == RT_NULL) + { int i = 0; - for(i = 0; i< can->config.maxhdr; i++) + struct rt_can_hdr *phdr; + + 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)); + for (i = 0; i < can->config.maxhdr; i++) { - rt_list_init(&phdr[i].list); + rt_list_init(&phdr[i].list); } + can->hdr = phdr; - rt_exit_critical(); - } else { - rt_exit_critical(); } #endif - rt_enter_critical(); - if(!can->timerinitflag) { + + 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; } @@ -371,67 +393,70 @@ static rt_err_t rt_can_close(struct rt_device *dev) RT_ASSERT(dev != RT_NULL); can = (struct rt_can_device *)dev; + CAN_LOCK(can); + /* this device has more reference count */ - if (dev->ref_count > 1) 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(); + if (dev->ref_count > 1) + { + CAN_UNLOCK(can); + return RT_EOK; } - rt_enter_critical(); + + if (can->timerinitflag) + { + can->timerinitflag = 0; + + rt_timer_stop(&can->timer); + } + 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) { + if (can->hdr != RT_NULL) + { rt_free(can->hdr); can->hdr = RT_NULL; - rt_exit_critical(); - } else { - rt_exit_critical(); } #endif + if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) { - struct rt_can_rx_fifo* rx_fifo; + struct rt_can_rx_fifo *rx_fifo; - rx_fifo = (struct rt_can_rx_fifo*)can->can_rx; + rx_fifo = (struct rt_can_rx_fifo *)can->can_rx; RT_ASSERT(rx_fifo != RT_NULL); 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; + struct rt_can_tx_fifo *tx_fifo; - tx_fifo = (struct rt_can_tx_fifo*)can->can_rx; + tx_fifo = (struct rt_can_tx_fifo *)can->can_rx; RT_ASSERT(tx_fifo != RT_NULL); rt_free(tx_fifo); dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX; /* 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_TX); } + can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_CAN_INT_ERR); + + CAN_UNLOCK(can); + return RT_EOK; } static rt_size_t rt_can_read(struct rt_device *dev, - rt_off_t pos, - void *buffer, - rt_size_t size) + rt_off_t pos, + void *buffer, + rt_size_t size) { struct rt_can_device *can; @@ -440,17 +465,18 @@ 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); + return _can_int_rx(can, buffer, size); } + return 0; } static rt_size_t rt_can_write(struct rt_device *dev, - rt_off_t pos, - const void *buffer, - rt_size_t size) + rt_off_t pos, + const void *buffer, + rt_size_t size) { struct rt_can_device *can; @@ -459,20 +485,23 @@ 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) { - return _can_int_tx_priv(can, buffer, size); - } else { - return _can_int_tx(can, buffer, size); - } + if (can->config.privmode) + { + return _can_int_tx_priv(can, buffer, size); + } + else + { + return _can_int_tx(can, buffer, size); + } } return 0; } static rt_err_t rt_can_control(struct rt_device *dev, - rt_uint8_t cmd, - void *args) + rt_uint8_t cmd, + void *args) { struct rt_can_device *can; rt_err_t res; @@ -482,213 +511,177 @@ static rt_err_t rt_can_control(struct rt_device *dev, switch (cmd) { - case RT_DEVICE_CTRL_SUSPEND: - /* suspend device */ - dev->flag |= RT_DEVICE_FLAG_SUSPENDED; - break; + case RT_DEVICE_CTRL_SUSPEND: + /* suspend device */ + dev->flag |= RT_DEVICE_FLAG_SUSPENDED; + break; - case RT_DEVICE_CTRL_RESUME: - /* resume device */ - dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED; - break; + case RT_DEVICE_CTRL_RESUME: + /* resume device */ + dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED; + break; + + case RT_DEVICE_CTRL_CONFIG: + /* configure device */ + can->ops->configure(can, (struct can_configure *)args); + break; + case RT_CAN_CMD_SET_PRIV: + /* configure device */ + if ((rt_uint32_t)args != can->config.privmode) + { + int i; + rt_base_t level; + struct rt_can_tx_fifo *tx_fifo; - case RT_DEVICE_CTRL_CONFIG: - /* configure device */ - can->ops->configure(can, (struct can_configure *)args); - break; - case RT_CAN_CMD_SET_PRIV: - /* configure device */ - if((rt_uint32_t)args != can->config.privmode) { - if(res = can->ops->control(can, cmd, args) != RT_EOK) { - return res; - } - struct rt_can_tx_fifo* tx_fifo; - tx_fifo = (struct rt_can_tx_fifo*) can->can_tx; - int i; - rt_base_t level; - if(can->config.privmode) { - rt_completion_done(&(tx_fifo->completion)); - level = rt_hw_interrupt_disable(); - for(i = 0; i< can->config.sndboxnumber; i++) - { - rt_list_remove(&tx_fifo->buffer[i].list); - } - rt_hw_interrupt_enable(level); - } else { - for(i = 0; i< can->config.sndboxnumber; i++) - { - rt_base_t level; - level = rt_hw_interrupt_disable(); - if(tx_fifo->buffer[i].result == RT_CAN__SND_RESUTL_OK) { - rt_list_insert_before(&tx_fifo->freelist,&tx_fifo->buffer[i].list); - } - rt_hw_interrupt_enable(level); - } - } - 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); - if(res != RT_EOK || can->hdr == RT_NULL) { - return res; - } + if (res != RT_EOK) return res; + + tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; + if (can->config.privmode) { - struct rt_can_filter_config* pfilter; - struct rt_can_filter_item* pitem; - rt_uint32_t count; - rt_base_t level; - pfilter = (struct rt_can_filter_config*)args; - count = pfilter->count; - pitem = pfilter->items; - if(pfilter->actived) { - while(count) { - if(pitem->hdr >= can->config.maxhdr || pitem->hdr < 0) { - count--; - pitem++; - continue; - } - level = rt_hw_interrupt_disable(); - if(!can->hdr[pitem->hdr].connected) { - rt_memcpy(&can->hdr[pitem->hdr].filter,pitem, - sizeof(struct rt_can_filter_item)); - can->hdr[pitem->hdr].connected = 1; - can->hdr[pitem->hdr].msgs = 0; - rt_list_init(&can->hdr[pitem->hdr].list); - } - rt_hw_interrupt_enable(level); - count--; - pitem++; - } - } else { - while(count) { - if(pitem->hdr >= can->config.maxhdr || pitem->hdr < 0) { - count--; - pitem++; - continue; - } - level = rt_hw_interrupt_disable(); - if(can->hdr[pitem->hdr].connected) { - rt_memset(&can->hdr[pitem->hdr].filter,0, - sizeof(struct rt_can_filter_item)); - can->hdr[pitem->hdr].connected = 0; - can->hdr[pitem->hdr].msgs = 0; - if(!rt_list_isempty(&can->hdr[pitem->hdr].list)) - { - rt_list_remove(can->hdr[pitem->hdr].list.next); - } - } - rt_hw_interrupt_enable(level); - count--; - pitem++; - } - } + rt_completion_done(&(tx_fifo->completion)); + + level = rt_hw_interrupt_disable(); + for (i = 0; i < can->config.sndboxnumber; i++) + { + rt_list_remove(&tx_fifo->buffer[i].list); + } + rt_hw_interrupt_enable(level); } - break; + else + { + for (i = 0; i < can->config.sndboxnumber; i++) + { + level = rt_hw_interrupt_disable(); + if (tx_fifo->buffer[i].result == RT_CAN_SND_RESULT_OK) + { + rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list); + } + rt_hw_interrupt_enable(level); + } + } + 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); + if (res != RT_EOK || can->hdr == RT_NULL) + { + return res; + } + + { + struct rt_can_filter_config *pfilter; + struct rt_can_filter_item *pitem; + rt_uint32_t count; + rt_base_t level; + + pfilter = (struct rt_can_filter_config *)args; + count = pfilter->count; + pitem = pfilter->items; + if (pfilter->actived) + { + while (count) + { + if (pitem->hdr >= can->config.maxhdr || pitem->hdr < 0) + { + count--; + pitem++; + continue; + } + + level = rt_hw_interrupt_disable(); + if (!can->hdr[pitem->hdr].connected) + { + rt_memcpy(&can->hdr[pitem->hdr].filter, pitem, + sizeof(struct rt_can_filter_item)); + can->hdr[pitem->hdr].connected = 1; + can->hdr[pitem->hdr].msgs = 0; + rt_list_init(&can->hdr[pitem->hdr].list); + } + rt_hw_interrupt_enable(level); + + count--; + pitem++; + } + } + else + { + while (count) + { + if (pitem->hdr >= can->config.maxhdr || pitem->hdr < 0) + { + count--; + pitem++; + continue; + } + level = rt_hw_interrupt_disable(); + + if (can->hdr[pitem->hdr].connected) + { + rt_memset(&can->hdr[pitem->hdr].filter, 0, + sizeof(struct rt_can_filter_item)); + can->hdr[pitem->hdr].connected = 0; + can->hdr[pitem->hdr].msgs = 0; + if (!rt_list_isempty(&can->hdr[pitem->hdr].list)) + { + rt_list_remove(can->hdr[pitem->hdr].list.next); + } + } + rt_hw_interrupt_enable(level); + count--; + pitem++; + } + } + } + break; #endif /*RT_CAN_USING_HDR*/ - default : - /* control device */ - if(can->ops->control != RT_NULL) - { - can->ops->control(can, cmd, args); - } - break; + + default : + /* control device */ + if (can->ops->control != RT_NULL) + { + can->ops->control(can, cmd, args); + } + break; } return RT_EOK; } + /* * can timer */ -static void cantimeout(void* arg) +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); - } + 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) + { + can->timerinitflag = 0xFF; + } + + if (can->status_indicate.ind != RT_NULL) + { + can->status_indicate.ind(can, can->status_indicate.args); + } } /* * can register */ 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) { struct rt_device *device; RT_ASSERT(can != RT_NULL); @@ -703,6 +696,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; @@ -713,16 +708,17 @@ rt_err_t rt_hw_can_register(struct rt_can_device *can, can->status_indicate.ind = RT_NULL; can->status_indicate.args = RT_NULL; - rt_memset(&can->status,0,sizeof(can->status)); + rt_memset(&can->status, 0, sizeof(can->status)); device->user_data = data; - can->timerinitflag = 0; - rt_timer_init(&can->timer, - name, - cantimeout, - (void*)can, - can->config.ticks, - RT_TIMER_FLAG_PERIODIC); + + can->timerinitflag = 0; + rt_timer_init(&can->timer, + name, + cantimeout, + (void *)can, + can->config.ticks, + RT_TIMER_FLAG_PERIODIC); /* register a character device */ return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR); } @@ -732,177 +728,208 @@ void rt_hw_can_isr(struct rt_can_device *can, int event) { switch (event & 0xff) { - case RT_CAN_EVENT_RXOF_IND: + case RT_CAN_EVENT_RXOF_IND: + { + rt_base_t level; + level = rt_hw_interrupt_disable(); + can->status.dropedrcvpkg++; + rt_hw_interrupt_enable(level); + } + case RT_CAN_EVENT_RX_IND: + { + struct rt_can_msg tmpmsg; + struct rt_can_rx_fifo *rx_fifo; + struct rt_can_msg_list *listmsg = RT_NULL; +#ifdef RT_CAN_USING_HDR + rt_int32_t hdr; +#endif + int ch = -1; + rt_base_t level; + rt_uint32_t no; + + rx_fifo = (struct rt_can_rx_fifo *)can->can_rx; + RT_ASSERT(rx_fifo != RT_NULL); + /* interrupt mode receive */ + RT_ASSERT(can->parent.open_flag & RT_DEVICE_FLAG_INT_RX); + + no = event >> 8; + ch = can->ops->recvmsg(can, &tmpmsg, no); + if (ch == -1) break; + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + can->status.rcvpkg++; + can->status.rcvchange = 1; + if (!rt_list_isempty(&rx_fifo->freelist)) { - rt_base_t level; - level = rt_hw_interrupt_disable(); + listmsg = rt_list_entry(rx_fifo->freelist.next, struct rt_can_msg_list, list); + rt_list_remove(&listmsg->list); +#ifdef RT_CAN_USING_HDR + rt_list_remove(&listmsg->hdrlist); + if (listmsg->owner != RT_NULL && listmsg->owner->msgs) + { + listmsg->owner->msgs--; + } + listmsg->owner = RT_NULL; +#endif /*RT_CAN_USING_HDR*/ + RT_ASSERT(rx_fifo->freenumbers > 0); + rx_fifo->freenumbers--; + } + else if (!rt_list_isempty(&rx_fifo->uselist)) + { + listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list); can->status.dropedrcvpkg++; + rt_list_remove(&listmsg->list); +#ifdef RT_CAN_USING_HDR + rt_list_remove(&listmsg->hdrlist); + if (listmsg->owner != RT_NULL && listmsg->owner->msgs) + { + listmsg->owner->msgs--; + } + listmsg->owner = RT_NULL; +#endif + } + /* enable interrupt */ + rt_hw_interrupt_enable(level); + + if (listmsg != RT_NULL) + { + rt_memcpy(&listmsg->data, &tmpmsg, sizeof(struct rt_can_msg)); + level = rt_hw_interrupt_disable(); + rt_list_insert_before(&rx_fifo->uselist, &listmsg->list); +#ifdef RT_CAN_USING_HDR + hdr = tmpmsg.hdr; + if (can->hdr != RT_NULL) + { + RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0); + if (can->hdr[hdr].connected) + { + rt_list_insert_before(&can->hdr[hdr].list, &listmsg->hdrlist); + listmsg->owner = &can->hdr[hdr]; + can->hdr[hdr].msgs++; + } + + } +#endif rt_hw_interrupt_enable(level); } - case RT_CAN_EVENT_RX_IND: + + /* invoke callback */ +#ifdef RT_CAN_USING_HDR + if (can->hdr != RT_NULL && can->hdr[hdr].connected && can->hdr[hdr].filter.ind) { - struct rt_can_msg tmpmsg; - struct rt_can_rx_fifo* rx_fifo; - struct rt_can_msg_list* listmsg=RT_NULL; -#ifdef RT_CAN_USING_HDR - rt_int32_t hdr; -#endif - int ch = -1; - rt_base_t level; - rx_fifo = (struct rt_can_rx_fifo*)can->can_rx; - RT_ASSERT(rx_fifo != RT_NULL); - /* interrupt mode receive */ - RT_ASSERT(can->parent.open_flag & RT_DEVICE_FLAG_INT_RX); - - rt_uint32_t no; - no = event >> 8; - ch = can->ops->recvmsg(can,&tmpmsg,no); - if (ch == -1) break; - /* disable interrupt */ + rt_size_t rx_length; + RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0); + level = rt_hw_interrupt_disable(); - can->status.rcvpkg++; - can->status.rcvchange = 1; - if(!rt_list_isempty(&rx_fifo->freelist)) - { - listmsg = rt_list_entry(rx_fifo->freelist.next, struct rt_can_msg_list, list); - rt_list_remove(&listmsg->list); -#ifdef RT_CAN_USING_HDR - rt_list_remove(&listmsg->hdrlist); - if(listmsg->owner != RT_NULL && listmsg->owner->msgs) { - listmsg->owner->msgs--; - } - listmsg->owner = RT_NULL; -#endif /*RT_CAN_USING_HDR*/ - RT_ASSERT(rx_fifo->freenumbers >0); - rx_fifo->freenumbers--; - } else if(!rt_list_isempty(&rx_fifo->uselist)) { - listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list); - can->status.dropedrcvpkg++; - rt_list_remove(&listmsg->list); -#ifdef RT_CAN_USING_HDR - rt_list_remove(&listmsg->hdrlist); - if(listmsg->owner != RT_NULL && listmsg->owner->msgs) { - listmsg->owner->msgs--; - } - listmsg->owner = RT_NULL; -#endif - } - /* enable interrupt */ + rx_length = can->hdr[hdr].msgs * sizeof(struct rt_can_msg); rt_hw_interrupt_enable(level); - if(listmsg != RT_NULL) { - rt_memcpy(&listmsg->data,&tmpmsg,sizeof(struct rt_can_msg)); - level = rt_hw_interrupt_disable(); - rt_list_insert_before(&rx_fifo->uselist,&listmsg->list); -#ifdef RT_CAN_USING_HDR - hdr = tmpmsg.hdr; - if(can->hdr != RT_NULL) { - RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0); - if(can->hdr[hdr].connected) { - rt_list_insert_before(&can->hdr[hdr].list,&listmsg->hdrlist); - listmsg->owner = &can->hdr[hdr]; - can->hdr[hdr].msgs++; - } - - } + can->hdr[hdr].filter.ind(&can->parent, can->hdr[hdr].filter.args, hdr, rx_length); + } + else #endif - rt_hw_interrupt_enable(level); - } - - /* invoke callback */ -#ifdef RT_CAN_USING_HDR - if(can->hdr != RT_NULL && can->hdr[hdr].connected && can->hdr[hdr].filter.ind) { - RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0); - rt_size_t rx_length; - level = rt_hw_interrupt_disable(); - rx_length = can->hdr[hdr].msgs * sizeof(struct rt_can_msg); - rt_hw_interrupt_enable(level); - can->hdr[hdr].filter.ind(&can->parent, can->hdr[hdr].filter.args, hdr, rx_length); - - } else -#endif - if (can->parent.rx_indicate != RT_NULL) { + { + if (can->parent.rx_indicate != RT_NULL) + { rt_size_t rx_length; - /* get rx length */ + level = rt_hw_interrupt_disable(); - rx_length = rx_fifo->freenumbers*sizeof(struct rt_can_msg); + /* get rx length */ + rx_length = rx_fifo->freenumbers * sizeof(struct rt_can_msg); rt_hw_interrupt_enable(level); can->parent.rx_indicate(&can->parent, rx_length); } - break; } - case RT_CAN_EVENT_TX_DONE: - case RT_CAN_EVENT_TX_FAIL: + break; + } + + case RT_CAN_EVENT_TX_DONE: + case RT_CAN_EVENT_TX_FAIL: + { + struct rt_can_tx_fifo *tx_fifo; + rt_uint32_t no; + 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) { - struct rt_can_tx_fifo* tx_fifo; - rt_uint32_t no; - 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; - } else { - tx_fifo->buffer[no].result = RT_CAN__SND_RESUTL_ERR; - } - rt_completion_done(&(tx_fifo->buffer[no].completion)); - break; + tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_OK; } + else + { + tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_ERR; + } + rt_completion_done(&(tx_fifo->buffer[no].completion)); + break; + } } } + #ifdef RT_USING_FINSH #include -int cmd_canstat(int argc,void** argv) +int cmd_canstat(int argc, void **argv) { - static const char* ErrCode[] = { - "No Error!", - "Warning !", - "Passive !", - "Bus Off !" + static const char *ErrCode[] = + { + "No Error!", + "Warning !", + "Passive !", + "Bus Off !" }; - if(argc >= 2) { + + if (argc >= 2) + { + struct rt_can_status status; rt_device_t candev = rt_device_find(argv[1]); - if(!candev) { - rt_kprintf(" Can't find can device %s\n",argv[1]); + if (!candev) + { + rt_kprintf(" Can't find can device %s\n", argv[1]); return -1; } - rt_kprintf(" Finded can device: %s...",argv[1]); - struct rt_can_status status; - rt_device_control(candev,RT_CAN_CMD_GET_STATUS,&status); + rt_kprintf(" Finded can device: %s...", argv[1]); + + rt_device_control(candev, RT_CAN_CMD_GET_STATUS, &status); rt_kprintf("\n Receive...error..count: %010ld. Send.....error....count: %010ld.", - status.rcverrcnt,status.snderrcnt); + status.rcverrcnt, status.snderrcnt); rt_kprintf("\n Bit..pad..error..count: %010ld. Format...error....count: %010ld", - status.bitpaderrcnt,status.formaterrcnt); + status.bitpaderrcnt, status.formaterrcnt); rt_kprintf("\n Ack.......error..count: %010ld. Bit......error....count: %010ld.", - status.ackerrcnt,status.biterrcnt); + status.ackerrcnt, status.biterrcnt); rt_kprintf("\n CRC.......error..count: %010ld. Error.code.[%010ld]: ", - status.crcerrcnt,status.errcode); - switch(status.errcode) { + status.crcerrcnt, status.errcode); + switch (status.errcode) + { case 0: - rt_kprintf("%s.",ErrCode[0]); - break; + rt_kprintf("%s.", ErrCode[0]); + break; case 1: - rt_kprintf("%s.",ErrCode[1]); - break; + rt_kprintf("%s.", ErrCode[1]); + break; case 2: case 3: - rt_kprintf("%s.",ErrCode[2]); - break; + rt_kprintf("%s.", ErrCode[2]); + break; case 4: case 5: case 6: case 7: - rt_kprintf("%s.",ErrCode[3]); - break; + rt_kprintf("%s.", ErrCode[3]); + break; } rt_kprintf("\n Total.receive.packages: %010ld. Droped.receive.packages: %010ld.", - status.rcvpkg,status.dropedrcvpkg); + status.rcvpkg, status.dropedrcvpkg); rt_kprintf("\n Total..send...packages: %010ld. Droped...send..packages: %010ld.\n", - status.sndpkg + status.dropedsndpkg,status.dropedsndpkg); - } else { - rt_kprintf(" Invalid Call %s\n",argv[0]); - rt_kprintf(" Please using %s cannamex .Here canname is driver name and x is candrive number.\n",argv[0]); + status.sndpkg + status.dropedsndpkg, status.dropedsndpkg); + } + else + { + rt_kprintf(" Invalid Call %s\n", argv[0]); + rt_kprintf(" Please using %s cannamex .Here canname is driver name and x is candrive number.\n", argv[0]); } return 0; } 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*/ +