From 1488568801ac099d678d39e71c508543dd13ee17 Mon Sep 17 00:00:00 2001 From: BernardXiong Date: Mon, 6 Jul 2015 10:38:07 +0800 Subject: [PATCH] [DeviceDrivers] code cleanup for CAN driver and fix some critical issue --- components/drivers/can/can.c | 1083 +++++++++++++++++++--------------- 1 file changed, 616 insertions(+), 467 deletions(-) diff --git a/components/drivers/can/can.c b/components/drivers/can/can.c index fc0d74877f..4cc02818c6 100644 --- a/components/drivers/can/can.c +++ b/components/drivers/can/can.c @@ -8,9 +8,11 @@ * http://www.rt-thread.org/license/LICENSE * * 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. */ + #include #include #include @@ -33,74 +35,84 @@ 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; + rt_int32_t hdr; + 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) + 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); + 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; + rt_list_remove(&listmsg->hdrlist); + if (listmsg->owner != RT_NULL && listmsg->owner->msgs) + { + listmsg->owner->msgs--; + } + listmsg->owner = RT_NULL; #endif - } - else - { - /* no data, enable interrupt and break out */ - rt_hw_interrupt_enable(level); - break; - } + } + 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 +122,64 @@ 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); + + 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)) + if (can->ops->sendmsg(can, data , no)) { 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_RESUTL_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 +190,67 @@ 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)); + 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); } + 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_RESUTL_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; 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_RESUTL_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 +263,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; @@ -251,27 +278,28 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) { 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); @@ -281,29 +309,32 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) can->can_rx = RT_NULL; rt_exit_critical(); } - } else { + } + 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_RESUTL_OK; } rt_completion_init(&(tx_fifo->completion)); can->can_tx = tx_fifo; @@ -317,50 +348,71 @@ static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag) can->can_tx = RT_NULL; rt_exit_critical(); } - } else { + } + 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; + + /* 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)); + for (i = 0; i < can->config.maxhdr; i++) { - rt_list_init(&phdr[i].list); + rt_list_init(&phdr[i].list); } + + rt_enter_critical(); can->hdr = phdr; rt_exit_critical(); - } else { + } + 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); + +#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.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); + 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 +#endif rt_timer_start(&can->timer); - } else { + } + else + { rt_exit_critical(); } + return RT_EOK; } @@ -373,65 +425,78 @@ static rt_err_t rt_can_close(struct rt_device *dev) /* this device has more reference count */ if (dev->ref_count > 1) return RT_EOK; + rt_enter_critical(); - if(can->timerinitflag) { + 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 { +#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) { - rt_free(can->hdr); + if (can->hdr != RT_NULL) + { + struct rt_can_hdr *hdr; + + hdr = can->hdr; can->hdr = RT_NULL; rt_exit_critical(); - } else { + + rt_free(hdr); + } + 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_TX); } 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); 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; @@ -442,15 +507,16 @@ static rt_size_t rt_can_read(struct rt_device *dev, if (dev->open_flag & RT_DEVICE_FLAG_INT_RX) { - 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; @@ -461,18 +527,21 @@ static rt_size_t rt_can_write(struct rt_device *dev, if (dev->open_flag & RT_DEVICE_FLAG_INT_TX) { - 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 +551,266 @@ 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) { - if(res = can->ops->control(can, cmd, args) != RT_EOK) { + 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; + + 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++) + } + + tx_fifo = (struct rt_can_tx_fifo *) can->can_tx; + 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++) + { + level = rt_hw_interrupt_disable(); + if (tx_fifo->buffer[i].result == RT_CAN__SND_RESUTL_OK) { - 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); + rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list); } - } - return RT_EOK; + rt_hw_interrupt_enable(level); + } } - 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; + 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; - } + 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) { - 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++; - } - } + 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++; + } } - break; + 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); - } +#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); + } } /* * 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); @@ -713,16 +835,16 @@ 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); + 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,175 +854,202 @@ 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_RESUTL_OK; } + else + { + tx_fifo->buffer[no].result = RT_CAN__SND_RESUTL_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; }