Module: xenomai-2.5 Branch: master Commit: 4f3b908c3488e78956002ef2a2daff192776d6a3 URL: http://git.xenomai.org/?p=xenomai-2.5.git;a=commit;h=4f3b908c3488e78956002ef2a2daff192776d6a3
Author: Wolfgang Grandegger <w...@denx.de> Date: Thu Jan 14 13:07:43 2010 +0100 rtcan: mscan: use tabs for indention and white space cleanup This patch introduces tabs for indention, deletes training white space and corrects some other white space issues. Signed-off-by: Wolfgang Grandegger <w...@denx.de> --- ksrc/drivers/can/mscan/Makefile | 4 +- ksrc/drivers/can/mscan/rtcan_mscan.c | 1226 ++++++++++++++--------------- ksrc/drivers/can/mscan/rtcan_mscan_proc.c | 172 ++-- ksrc/drivers/can/mscan/rtcan_mscan_regs.h | 66 +- 4 files changed, 732 insertions(+), 736 deletions(-) diff --git a/ksrc/drivers/can/mscan/Makefile b/ksrc/drivers/can/mscan/Makefile index 20e29e4..8976ffe 100644 --- a/ksrc/drivers/can/mscan/Makefile +++ b/ksrc/drivers/can/mscan/Makefile @@ -14,9 +14,9 @@ else O_TARGET := built-in.o -obj-$(CONFIG_XENO_DRIVERS_CAN_MSCAN) := xeno_can_mscan.o +obj-$(CONFIG_XENO_DRIVERS_CAN_MSCAN) := xeno_can_mscan.o -list-multi := xeno_can_mscan.o +list-multi := xeno_can_mscan.o xeno_can_mscan-objs := rtcan_mscan.o rtcan_mscan_proc.o diff --git a/ksrc/drivers/can/mscan/rtcan_mscan.c b/ksrc/drivers/can/mscan/rtcan_mscan.c index 9618057..b5b6489 100644 --- a/ksrc/drivers/can/mscan/rtcan_mscan.c +++ b/ksrc/drivers/can/mscan/rtcan_mscan.c @@ -74,9 +74,9 @@ int port[RTCAN_MSCAN_DEVS] = { compat_module_param_array(port, int, RTCAN_MSCAN_DEVS, 0444); MODULE_PARM_DESC(port, "Enabled CAN ports (1,1 or 0,1 or 0,1)"); -/* - * Note: on the MPC5200 the MSCAN clock source is the IP bus - * clock (IP_CLK) while on the MPC5200B it is the oscillator +/* + * Note: on the MPC5200 the MSCAN clock source is the IP bus + * clock (IP_CLK) while on the MPC5200B it is the oscillator * clock (SYS_XTAL_IN). */ unsigned int mscan_clock = CONFIG_XENO_DRIVERS_CAN_MSCAN_CLOCK; @@ -86,11 +86,10 @@ MODULE_PARM_DESC(mscan_clock, "Clock frequency in Hz"); char *mscan_pins = NULL; module_param(mscan_pins, charp, 0444); MODULE_PARM_DESC(mscan_pins, "Routing to GPIO pins (PSC2 or I2C1/TMR01)"); - + static struct rtcan_device *rtcan_mscan_devs[RTCAN_MSCAN_DEVS]; static int rtcan_mscan_count; - /** * Reception Interrupt handler * @@ -103,224 +102,220 @@ static int rtcan_mscan_count; * @param[in] dev Device ID */ static inline void rtcan_mscan_rx_interrupt(struct rtcan_device *dev, - struct rtcan_skb *skb - ) + struct rtcan_skb *skb) { - int i; - unsigned char size; - struct rtcan_rb_frame *frame = &skb->rb_frame; - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - - skb->rb_frame_size = EMPTY_RB_FRAME_SIZE; - - frame->can_dlc = regs->canrxfg.dlr & 0x0F; - - /* If DLC exceeds 8 bytes adjust it to 8 (for the payload size) */ - size = (frame->can_dlc > 8) ? 8 : frame->can_dlc; - - if (regs->canrxfg.idr[1] & MSCAN_BUF_EXTENDED) { - frame->can_id = ((regs->canrxfg.idr[0] << 21) | - ((regs->canrxfg.idr[1] & 0xE0) << 13) | - ((regs->canrxfg.idr[1] & 0x07) << 15) | - (regs->canrxfg.idr[4] << 7) | - (regs->canrxfg.idr[5] >> 1)); - - frame->can_id |= CAN_EFF_FLAG; - - if ((regs->canrxfg.idr[5] & MSCAN_BUF_EXT_RTR)) { - frame->can_id |= CAN_RTR_FLAG; - } else { - for (i = 0; i < size; i++) - frame->data[i] = regs->canrxfg.dsr[i + (i / 2) * 2]; - skb->rb_frame_size += size; - } - - } else { - frame->can_id = ((regs->canrxfg.idr[0] << 3) | - (regs->canrxfg.idr[1] >> 5)); - - if ((regs->canrxfg.idr[1] & MSCAN_BUF_STD_RTR)) { - frame->can_id |= CAN_RTR_FLAG; - } else { - for (i = 0; i < size; i++) - frame->data[i] = regs->canrxfg.dsr[i + (i / 2) * 2]; - skb->rb_frame_size += size; - } - } - - - /* Store the interface index */ - frame->can_ifindex = dev->ifindex; -} - + int i; + unsigned char size; + struct rtcan_rb_frame *frame = &skb->rb_frame; + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; -static can_state_t mscan_stat_map[4] = { - CAN_STATE_ACTIVE, - CAN_STATE_BUS_WARNING, - CAN_STATE_BUS_PASSIVE, - CAN_STATE_BUS_OFF -}; + skb->rb_frame_size = EMPTY_RB_FRAME_SIZE; -static inline void rtcan_mscan_err_interrupt(struct rtcan_device *dev, - struct rtcan_skb *skb, - int r_status) -{ - u8 rstat, tstat; - struct rtcan_rb_frame *frame = &skb->rb_frame; - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - - skb->rb_frame_size = EMPTY_RB_FRAME_SIZE + CAN_ERR_DLC; + frame->can_dlc = regs->canrxfg.dlr & 0x0F; - frame->can_id = CAN_ERR_FLAG; - frame->can_dlc = CAN_ERR_DLC; + /* If DLC exceeds 8 bytes adjust it to 8 (for the payload size) */ + size = (frame->can_dlc > 8) ? 8 : frame->can_dlc; - memset(&frame->data[0], 0, frame->can_dlc); + if (regs->canrxfg.idr[1] & MSCAN_BUF_EXTENDED) { + frame->can_id = ((regs->canrxfg.idr[0] << 21) | + ((regs->canrxfg.idr[1] & 0xE0) << 13) | + ((regs->canrxfg.idr[1] & 0x07) << 15) | + (regs->canrxfg.idr[4] << 7) | + (regs->canrxfg.idr[5] >> 1)); - if ((r_status & MSCAN_OVRIF)) { - frame->can_id |= CAN_ERR_CRTL; - frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; + frame->can_id |= CAN_EFF_FLAG; - } else if ((r_status & (MSCAN_CSCIF))) { - - rstat = (r_status & (MSCAN_TSTAT0 | - MSCAN_TSTAT1)) >> 2 & 0x3; - tstat = (r_status & (MSCAN_RSTAT0 | - MSCAN_RSTAT1)) >> 4 & 0x3; - dev->state = mscan_stat_map[max(rstat, tstat)]; + if ((regs->canrxfg.idr[5] & MSCAN_BUF_EXT_RTR)) { + frame->can_id |= CAN_RTR_FLAG; + } else { + for (i = 0; i < size; i++) + frame->data[i] = + regs->canrxfg.dsr[i + (i / 2) * 2]; + skb->rb_frame_size += size; + } - switch (dev->state) { - case CAN_STATE_BUS_OFF: - /* Bus-off condition */ - frame->can_id |= CAN_ERR_BUSOFF; - dev->state = CAN_STATE_BUS_OFF; - /* Disable receiver interrupts */ - regs->canrier = 0; - /* Wake up waiting senders */ - rtdm_sem_destroy(&dev->tx_sem); - break; + } else { + frame->can_id = ((regs->canrxfg.idr[0] << 3) | + (regs->canrxfg.idr[1] >> 5)); + + if ((regs->canrxfg.idr[1] & MSCAN_BUF_STD_RTR)) { + frame->can_id |= CAN_RTR_FLAG; + } else { + for (i = 0; i < size; i++) + frame->data[i] = + regs->canrxfg.dsr[i + (i / 2) * 2]; + skb->rb_frame_size += size; + } + } - case CAN_STATE_BUS_PASSIVE: - frame->can_id |= CAN_ERR_CRTL; - if (tstat > rstat) - frame->data[1] = CAN_ERR_CRTL_TX_PASSIVE; - else - frame->data[1] = CAN_ERR_CRTL_RX_PASSIVE; - break; - case CAN_STATE_BUS_WARNING: - frame->can_id |= CAN_ERR_CRTL; - if (tstat > rstat) - frame->data[1] = CAN_ERR_CRTL_TX_WARNING; - else - frame->data[1] = CAN_ERR_CRTL_RX_WARNING; - break; + /* Store the interface index */ + frame->can_ifindex = dev->ifindex; +} - default: - break; +static can_state_t mscan_stat_map[4] = { + CAN_STATE_ACTIVE, + CAN_STATE_BUS_WARNING, + CAN_STATE_BUS_PASSIVE, + CAN_STATE_BUS_OFF +}; +static inline void rtcan_mscan_err_interrupt(struct rtcan_device *dev, + struct rtcan_skb *skb, + int r_status) +{ + u8 rstat, tstat; + struct rtcan_rb_frame *frame = &skb->rb_frame; + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; + + skb->rb_frame_size = EMPTY_RB_FRAME_SIZE + CAN_ERR_DLC; + + frame->can_id = CAN_ERR_FLAG; + frame->can_dlc = CAN_ERR_DLC; + + memset(&frame->data[0], 0, frame->can_dlc); + + if ((r_status & MSCAN_OVRIF)) { + frame->can_id |= CAN_ERR_CRTL; + frame->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; + + } else if ((r_status & (MSCAN_CSCIF))) { + + rstat = (r_status & (MSCAN_TSTAT0 | + MSCAN_TSTAT1)) >> 2 & 0x3; + tstat = (r_status & (MSCAN_RSTAT0 | + MSCAN_RSTAT1)) >> 4 & 0x3; + dev->state = mscan_stat_map[max(rstat, tstat)]; + + switch (dev->state) { + case CAN_STATE_BUS_OFF: + /* Bus-off condition */ + frame->can_id |= CAN_ERR_BUSOFF; + dev->state = CAN_STATE_BUS_OFF; + /* Disable receiver interrupts */ + regs->canrier = 0; + /* Wake up waiting senders */ + rtdm_sem_destroy(&dev->tx_sem); + break; + + case CAN_STATE_BUS_PASSIVE: + frame->can_id |= CAN_ERR_CRTL; + if (tstat > rstat) + frame->data[1] = CAN_ERR_CRTL_TX_PASSIVE; + else + frame->data[1] = CAN_ERR_CRTL_RX_PASSIVE; + break; + + case CAN_STATE_BUS_WARNING: + frame->can_id |= CAN_ERR_CRTL; + if (tstat > rstat) + frame->data[1] = CAN_ERR_CRTL_TX_WARNING; + else + frame->data[1] = CAN_ERR_CRTL_RX_WARNING; + break; + + default: + break; + + } } - } - /* Store the interface index */ - frame->can_ifindex = dev->ifindex; + /* Store the interface index */ + frame->can_ifindex = dev->ifindex; } - - /** Interrupt handler */ static int rtcan_mscan_interrupt(rtdm_irq_t *irq_handle) { - struct rtcan_skb skb; - struct rtcan_device *dev; - struct mscan_regs *regs; - u8 canrflg; - int recv_lock_free = 1; - int ret = RTDM_IRQ_NONE; + struct rtcan_skb skb; + struct rtcan_device *dev; + struct mscan_regs *regs; + u8 canrflg; + int recv_lock_free = 1; + int ret = RTDM_IRQ_NONE; - dev = (struct rtcan_device *)rtdm_irq_get_arg(irq_handle, void); - regs = (struct mscan_regs *)dev->base_addr; + dev = (struct rtcan_device *)rtdm_irq_get_arg(irq_handle, void); + regs = (struct mscan_regs *)dev->base_addr; - rtdm_lock_get(&dev->device_lock); + rtdm_lock_get(&dev->device_lock); - canrflg = regs->canrflg; + canrflg = regs->canrflg; - ret = RTDM_IRQ_HANDLED; + ret = RTDM_IRQ_HANDLED; - /* Transmit Interrupt? */ - if ((regs->cantier & MSCAN_TXIE0) && (regs->cantflg & MSCAN_TXE0)) { - regs->cantier = 0; - /* Wake up a sender */ - rtdm_sem_up(&dev->tx_sem); + /* Transmit Interrupt? */ + if ((regs->cantier & MSCAN_TXIE0) && (regs->cantflg & MSCAN_TXE0)) { + regs->cantier = 0; + /* Wake up a sender */ + rtdm_sem_up(&dev->tx_sem); - if (rtcan_loopback_pending(dev)) { + if (rtcan_loopback_pending(dev)) { - if (recv_lock_free) { - recv_lock_free = 0; - rtdm_lock_get(&rtcan_recv_list_lock); - rtdm_lock_get(&rtcan_socket_lock); - } + if (recv_lock_free) { + recv_lock_free = 0; + rtdm_lock_get(&rtcan_recv_list_lock); + rtdm_lock_get(&rtcan_socket_lock); + } - rtcan_loopback(dev); + rtcan_loopback(dev); + } } - } - - /* Wakeup interrupt? */ - if ((canrflg & MSCAN_WUPIF)) { - rtdm_printk("WUPIF interrupt\n"); - } - - /* Receive Interrupt? */ - if ((canrflg & MSCAN_RXF)) { - - /* Read out HW registers */ - rtcan_mscan_rx_interrupt(dev, &skb); - - /* Take more locks. Ensure that they are taken and - * released only once in the IRQ handler. */ - /* WARNING: Nested locks are dangerous! But they are - * nested only in this routine so a deadlock should - * not be possible. */ - if (recv_lock_free) { - recv_lock_free = 0; - rtdm_lock_get(&rtcan_recv_list_lock); - rtdm_lock_get(&rtcan_socket_lock); + + /* Wakeup interrupt? */ + if ((canrflg & MSCAN_WUPIF)) { + rtdm_printk("WUPIF interrupt\n"); } - - /* Pass received frame out to the sockets */ - rtcan_rcv(dev, &skb); - } - - /* Error Interrupt? */ - if ((canrflg & (MSCAN_CSCIF | MSCAN_OVRIF))) { - /* Check error condition and fill error frame */ - rtcan_mscan_err_interrupt(dev, &skb, canrflg); - - if (recv_lock_free) { - recv_lock_free = 0; - rtdm_lock_get(&rtcan_recv_list_lock); - rtdm_lock_get(&rtcan_socket_lock); + + /* Receive Interrupt? */ + if ((canrflg & MSCAN_RXF)) { + + /* Read out HW registers */ + rtcan_mscan_rx_interrupt(dev, &skb); + + /* Take more locks. Ensure that they are taken and + * released only once in the IRQ handler. */ + /* WARNING: Nested locks are dangerous! But they are + * nested only in this routine so a deadlock should + * not be possible. */ + if (recv_lock_free) { + recv_lock_free = 0; + rtdm_lock_get(&rtcan_recv_list_lock); + rtdm_lock_get(&rtcan_socket_lock); + } + + /* Pass received frame out to the sockets */ + rtcan_rcv(dev, &skb); } - - /* Pass error frame out to the sockets */ - rtcan_rcv(dev, &skb); - } - - /* Acknowledge the handled interrupt within the controller. - * Only do so for the receiver interrupts. - */ - if (canrflg) - regs->canrflg = canrflg; - - if (!recv_lock_free) { - rtdm_lock_put(&rtcan_socket_lock); - rtdm_lock_put(&rtcan_recv_list_lock); - } - rtdm_lock_put(&dev->device_lock); - - return ret; -} + /* Error Interrupt? */ + if ((canrflg & (MSCAN_CSCIF | MSCAN_OVRIF))) { + /* Check error condition and fill error frame */ + rtcan_mscan_err_interrupt(dev, &skb, canrflg); + if (recv_lock_free) { + recv_lock_free = 0; + rtdm_lock_get(&rtcan_recv_list_lock); + rtdm_lock_get(&rtcan_socket_lock); + } + + /* Pass error frame out to the sockets */ + rtcan_rcv(dev, &skb); + } + + /* Acknowledge the handled interrupt within the controller. + * Only do so for the receiver interrupts. + */ + if (canrflg) + regs->canrflg = canrflg; + + if (!recv_lock_free) { + rtdm_lock_put(&rtcan_socket_lock); + rtdm_lock_put(&rtcan_recv_list_lock); + } + rtdm_lock_put(&dev->device_lock); + + return ret; +} /** * Set controller into reset mode. Called from @ref rtcan_mscan_ioctl @@ -345,45 +340,43 @@ static int rtcan_mscan_interrupt(rtdm_irq_t *irq_handle) static int rtcan_mscan_mode_stop(struct rtcan_device *dev, rtdm_lockctx_t *lock_ctx) { - int ret = 0; - int rinit = 0; - can_state_t state; - volatile struct mscan_regs *regs = - (struct mscan_regs *)dev->base_addr; - u8 reg; - - state = dev->state; - /* If controller is not operating anyway, go out */ - if (!CAN_STATE_OPERATING(state)) - goto out; - - /* Switch to sleep mode */ - regs->canctl0 |= MSCAN_SLPRQ; - regs->canctl0 |= MSCAN_INITRQ; - - reg = regs->canctl1; - while (!(reg & MSCAN_SLPAK) || - !(reg & MSCAN_INITAK)) { - if (likely(lock_ctx != NULL)) - rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); - /* Busy sleep 1 microsecond */ - rtdm_task_busy_sleep(1000); - if (likely(lock_ctx != NULL)) - rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); - rinit++; - reg = regs->canctl1; - } + int ret = 0; + int rinit = 0; + can_state_t state; + volatile struct mscan_regs *regs = + (struct mscan_regs *)dev->base_addr; + u8 reg; - /* Volatile state could have changed while we slept busy. */ - dev->state = CAN_STATE_STOPPED; - /* Wake up waiting senders */ - rtdm_sem_destroy(&dev->tx_sem); + state = dev->state; + /* If controller is not operating anyway, go out */ + if (!CAN_STATE_OPERATING(state)) + goto out; - out: - return ret; -} + /* Switch to sleep mode */ + regs->canctl0 |= MSCAN_SLPRQ; + regs->canctl0 |= MSCAN_INITRQ; + reg = regs->canctl1; + while (!(reg & MSCAN_SLPAK) || + !(reg & MSCAN_INITAK)) { + if (likely(lock_ctx != NULL)) + rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); + /* Busy sleep 1 microsecond */ + rtdm_task_busy_sleep(1000); + if (likely(lock_ctx != NULL)) + rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); + rinit++; + reg = regs->canctl1; + } + /* Volatile state could have changed while we slept busy. */ + dev->state = CAN_STATE_STOPPED; + /* Wake up waiting senders */ + rtdm_sem_destroy(&dev->tx_sem); + +out: + return ret; +} /** * Set controller into operating mode. @@ -405,183 +398,185 @@ static int rtcan_mscan_mode_stop(struct rtcan_device *dev, static int rtcan_mscan_mode_start(struct rtcan_device *dev, rtdm_lockctx_t *lock_ctx) { - int ret = 0, retries = 0; - can_state_t state; - volatile struct mscan_regs *regs = - (struct mscan_regs *)dev->base_addr; - - /* We won't forget that state in the device structure is volatile and - * access to it will not be optimized by the compiler. So ... */ - state = dev->state; - - switch (state) { - case CAN_STATE_ACTIVE: - case CAN_STATE_BUS_WARNING: - case CAN_STATE_BUS_PASSIVE: - break; - - case CAN_STATE_SLEEPING: - case CAN_STATE_STOPPED: - /* Set error active state */ - state = CAN_STATE_ACTIVE; - /* Set up sender "mutex" */ - rtdm_sem_init(&dev->tx_sem, 1); - - if ((dev->ctrl_mode & CAN_CTRLMODE_LISTENONLY)) { - regs->canctl1 |= MSCAN_LISTEN; - } else { - regs->canctl1 &= ~MSCAN_LISTEN; - } - if ((dev->ctrl_mode & CAN_CTRLMODE_LOOPBACK)) { - regs->canctl1 |= MSCAN_LOOPB; - } else { - regs->canctl1 &= ~MSCAN_LOOPB; - } + int ret = 0, retries = 0; + can_state_t state; + volatile struct mscan_regs *regs = + (struct mscan_regs *)dev->base_addr; - /* Switch to normal mode */ - regs->canctl0 &= ~MSCAN_INITRQ; - regs->canctl0 &= ~MSCAN_SLPRQ; - while ((regs->canctl1 & MSCAN_INITAK) || - (regs->canctl1 & MSCAN_SLPAK)) { - if (likely(lock_ctx != NULL)) - rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); - /* Busy sleep 1 microsecond */ - rtdm_task_busy_sleep(1000); - if (likely(lock_ctx != NULL)) - rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); - retries++; - } - /* Enable interrupts */ - regs->canrier |= MSCAN_RIER; + /* We won't forget that state in the device structure is volatile and + * access to it will not be optimized by the compiler. So ... */ + state = dev->state; - break; + switch (state) { + case CAN_STATE_ACTIVE: + case CAN_STATE_BUS_WARNING: + case CAN_STATE_BUS_PASSIVE: + break; - case CAN_STATE_BUS_OFF: - /* Trigger bus-off recovery */ - regs->canrier = MSCAN_RIER; - /* Set up sender "mutex" */ - rtdm_sem_init(&dev->tx_sem, 1); - /* Set error active state */ - state = CAN_STATE_ACTIVE; + case CAN_STATE_SLEEPING: + case CAN_STATE_STOPPED: + /* Set error active state */ + state = CAN_STATE_ACTIVE; + /* Set up sender "mutex" */ + rtdm_sem_init(&dev->tx_sem, 1); + + if ((dev->ctrl_mode & CAN_CTRLMODE_LISTENONLY)) { + regs->canctl1 |= MSCAN_LISTEN; + } else { + regs->canctl1 &= ~MSCAN_LISTEN; + } + if ((dev->ctrl_mode & CAN_CTRLMODE_LOOPBACK)) { + regs->canctl1 |= MSCAN_LOOPB; + } else { + regs->canctl1 &= ~MSCAN_LOOPB; + } + + /* Switch to normal mode */ + regs->canctl0 &= ~MSCAN_INITRQ; + regs->canctl0 &= ~MSCAN_SLPRQ; + while ((regs->canctl1 & MSCAN_INITAK) || + (regs->canctl1 & MSCAN_SLPAK)) { + if (likely(lock_ctx != NULL)) + rtdm_lock_put_irqrestore(&dev->device_lock, + *lock_ctx); + /* Busy sleep 1 microsecond */ + rtdm_task_busy_sleep(1000); + if (likely(lock_ctx != NULL)) + rtdm_lock_get_irqsave(&dev->device_lock, + *lock_ctx); + retries++; + } + /* Enable interrupts */ + regs->canrier |= MSCAN_RIER; - break; + break; + + case CAN_STATE_BUS_OFF: + /* Trigger bus-off recovery */ + regs->canrier = MSCAN_RIER; + /* Set up sender "mutex" */ + rtdm_sem_init(&dev->tx_sem, 1); + /* Set error active state */ + state = CAN_STATE_ACTIVE; - default: - /* Never reached, but we don't want nasty compiler warnings ... */ - break; - } - /* Store new state in device structure (or old state) */ - dev->state = state; + break; - return ret; + default: + /* Never reached, but we don't want nasty compiler warnings */ + break; + } + /* Store new state in device structure (or old state) */ + dev->state = state; + + return ret; } -int rtcan_mscan_set_bit_time(struct rtcan_device *dev, +int rtcan_mscan_set_bit_time(struct rtcan_device *dev, struct can_bittime *bit_time, rtdm_lockctx_t *lock_ctx) { - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - u8 btr0, btr1; - - switch (bit_time->type) { - case CAN_BITTIME_BTR: - btr0 = bit_time->btr.btr0; - btr1 = bit_time->btr.btr1; - break; - - case CAN_BITTIME_STD: - btr0 = (BTR0_SET_BRP(bit_time->std.brp) | - BTR0_SET_SJW(bit_time->std.sjw)); - btr1 = (BTR1_SET_TSEG1(bit_time->std.prop_seg + - bit_time->std.phase_seg1) | - BTR1_SET_TSEG2(bit_time->std.phase_seg2) | - BTR1_SET_SAM(bit_time->std.sam)); - break; - - default: - return -EINVAL; - } - - regs->canbtr0 = btr0; - regs->canbtr1 = btr1; - - rtdm_printk("%s: btr0=0x%02x btr1=0x%02x\n", dev->name, btr0, btr1); - - return 0; + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; + u8 btr0, btr1; + + switch (bit_time->type) { + case CAN_BITTIME_BTR: + btr0 = bit_time->btr.btr0; + btr1 = bit_time->btr.btr1; + break; + + case CAN_BITTIME_STD: + btr0 = (BTR0_SET_BRP(bit_time->std.brp) | + BTR0_SET_SJW(bit_time->std.sjw)); + btr1 = (BTR1_SET_TSEG1(bit_time->std.prop_seg + + bit_time->std.phase_seg1) | + BTR1_SET_TSEG2(bit_time->std.phase_seg2) | + BTR1_SET_SAM(bit_time->std.sam)); + break; + + default: + return -EINVAL; + } + + regs->canbtr0 = btr0; + regs->canbtr1 = btr1; + + rtdm_printk("%s: btr0=0x%02x btr1=0x%02x\n", dev->name, btr0, btr1); + + return 0; } -int rtcan_mscan_set_mode(struct rtcan_device *dev, +int rtcan_mscan_set_mode(struct rtcan_device *dev, can_mode_t mode, rtdm_lockctx_t *lock_ctx) { - int ret = 0, retries = 0; - can_state_t state; - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - - switch (mode) { + int ret = 0, retries = 0; + can_state_t state; + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - case CAN_MODE_STOP: - ret = rtcan_mscan_mode_stop(dev, lock_ctx); - break; + switch (mode) { - case CAN_MODE_START: - ret = rtcan_mscan_mode_start(dev, lock_ctx); - break; + case CAN_MODE_STOP: + ret = rtcan_mscan_mode_stop(dev, lock_ctx); + break; - case CAN_MODE_SLEEP: - - state = dev->state; - - /* Controller must operate, otherwise go out */ - if (!CAN_STATE_OPERATING(state)) { - ret = -ENETDOWN; - goto mode_sleep_out; - } - - /* Is controller sleeping yet? If yes, go out */ - if (state == CAN_STATE_SLEEPING) - goto mode_sleep_out; - - /* Remember into which state to return when we - * wake up */ - dev->state_before_sleep = state; - state = CAN_STATE_SLEEPING; - - /* Let's take a nap. (Now I REALLY understand - * the meaning of interrupts ...) */ - regs->canrier = 0; - regs->cantier = 0; - regs->canctl0 |= MSCAN_SLPRQ /*| MSCAN_INITRQ*/ | MSCAN_WUPE; - while (!(regs->canctl1 & MSCAN_SLPAK)) { - rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); - /* Busy sleep 1 microsecond */ - rtdm_task_busy_sleep(1000); - rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); - if (retries++ >= 1000) + case CAN_MODE_START: + ret = rtcan_mscan_mode_start(dev, lock_ctx); break; - } - rtdm_printk("Fallen asleep after %d tries.\n", retries); - regs->canctl0 &= ~MSCAN_INITRQ; - while ((regs->canctl1 & MSCAN_INITAK)) { - rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); - /* Busy sleep 1 microsecond */ - rtdm_task_busy_sleep(1000); - rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); - if (retries++ >= 1000) + + case CAN_MODE_SLEEP: + + state = dev->state; + + /* Controller must operate, otherwise go out */ + if (!CAN_STATE_OPERATING(state)) { + ret = -ENETDOWN; + goto mode_sleep_out; + } + + /* Is controller sleeping yet? If yes, go out */ + if (state == CAN_STATE_SLEEPING) + goto mode_sleep_out; + + /* Remember into which state to return when we + * wake up */ + dev->state_before_sleep = state; + state = CAN_STATE_SLEEPING; + + /* Let's take a nap. (Now I REALLY understand + * the meaning of interrupts ...) */ + regs->canrier = 0; + regs->cantier = 0; + regs->canctl0 |= MSCAN_SLPRQ /*| MSCAN_INITRQ*/ | MSCAN_WUPE; + while (!(regs->canctl1 & MSCAN_SLPAK)) { + rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); + /* Busy sleep 1 microsecond */ + rtdm_task_busy_sleep(1000); + rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); + if (retries++ >= 1000) + break; + } + rtdm_printk("Fallen asleep after %d tries.\n", retries); + regs->canctl0 &= ~MSCAN_INITRQ; + while ((regs->canctl1 & MSCAN_INITAK)) { + rtdm_lock_put_irqrestore(&dev->device_lock, *lock_ctx); + /* Busy sleep 1 microsecond */ + rtdm_task_busy_sleep(1000); + rtdm_lock_get_irqsave(&dev->device_lock, *lock_ctx); + if (retries++ >= 1000) + break; + } + rtdm_printk("Back to normal after %d tries.\n", retries); + regs->canrier = MSCAN_WUPIE; + + mode_sleep_out: + dev->state = state; break; - } - rtdm_printk("Back to normal after %d tries.\n", retries); - regs->canrier = MSCAN_WUPIE; - - mode_sleep_out: - dev->state = state; - break; - default: - ret = -EOPNOTSUPP; - } + default: + ret = -EOPNOTSUPP; + } - return ret; + return ret; } /** @@ -594,81 +589,80 @@ int rtcan_mscan_set_mode(struct rtcan_device *dev, * @param[in] frame Pointer to CAN frame which is about to be sent * @param[in] dev Device ID */ -static int rtcan_mscan_start_xmit(struct rtcan_device *dev, - can_frame_t *frame) +static int rtcan_mscan_start_xmit(struct rtcan_device *dev, can_frame_t *frame) { - int i, id; - /* "Real" size of the payload */ - unsigned char size; - /* Content of frame information register */ - unsigned char dlc; - - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - - /* Is TX buffer empty? */ - if (!(regs->cantflg & MSCAN_TXE0)) { - rtdm_printk("rtcan_mscan_start_xmit: TX buffer not empty"); - return -EIO; - } - /* Select the buffer we've found. */ - regs->cantbsel = MSCAN_TXE0; - - /* Get DLC and ID */ - dlc = frame->can_dlc; - - /* If DLC exceeds 8 bytes adjust it to 8 (for the payload) */ - size = (dlc > 8) ? 8 : dlc; - - id = frame->can_id; - if (frame->can_id & CAN_EFF_FLAG) { - regs->cantxfg.idr[0] = (id & 0x1fe00000) >> 21; - regs->cantxfg.idr[1] = (id & 0x001c0000) >> 13; - regs->cantxfg.idr[1] |= (id & 0x00038000) >> 15; - regs->cantxfg.idr[1] |= 0x18; /* set SRR and IDE bits */ - - regs->cantxfg.idr[4] = (id & 0x00007f80) >> 7 ; - regs->cantxfg.idr[5] = (id & 0x0000007f) << 1 ; - - /* RTR? */ - if (frame->can_id & CAN_RTR_FLAG) - regs->cantxfg.idr[5] |= 0x1; - else { - regs->cantxfg.idr[5] &= ~0x1; - /* No RTR, write data bytes */ - for (i = 0; i < size; i++) - regs->cantxfg.dsr[i + (i / 2) * 2] = frame->data[i]; - } - - } else { - /* Send standard frame */ - - regs->cantxfg.idr[0] = (id & 0x000007f8) >> 3; - regs->cantxfg.idr[1] = (id & 0x00000007) << 5; - - /* RTR? */ - if (frame->can_id & CAN_RTR_FLAG) - regs->cantxfg.idr[1] |= 0x10; - else { - regs->cantxfg.idr[1] &= ~0x10; - /* No RTR, write data bytes */ - for (i = 0; i < size; i++) - regs->cantxfg.dsr[i + (i / 2) * 2] = frame->data[i]; - } - } - - regs->cantxfg.dlr = frame->can_dlc; - regs->cantxfg.tbpr = 0; /* all messages have the same prio */ - - /* Trigger transmission. */ - regs->cantflg = MSCAN_TXE0; - - /* Enable interrupt. */ - regs->cantier |= MSCAN_TXIE0; - - return 0; -} + int i, id; + /* "Real" size of the payload */ + unsigned char size; + /* Content of frame information register */ + unsigned char dlc; + + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; + + /* Is TX buffer empty? */ + if (!(regs->cantflg & MSCAN_TXE0)) { + rtdm_printk("rtcan_mscan_start_xmit: TX buffer not empty"); + return -EIO; + } + /* Select the buffer we've found. */ + regs->cantbsel = MSCAN_TXE0; + + /* Get DLC and ID */ + dlc = frame->can_dlc; + + /* If DLC exceeds 8 bytes adjust it to 8 (for the payload) */ + size = (dlc > 8) ? 8 : dlc; + + id = frame->can_id; + if (frame->can_id & CAN_EFF_FLAG) { + regs->cantxfg.idr[0] = (id & 0x1fe00000) >> 21; + regs->cantxfg.idr[1] = (id & 0x001c0000) >> 13; + regs->cantxfg.idr[1] |= (id & 0x00038000) >> 15; + regs->cantxfg.idr[1] |= 0x18; /* set SRR and IDE bits */ + + regs->cantxfg.idr[4] = (id & 0x00007f80) >> 7 ; + regs->cantxfg.idr[5] = (id & 0x0000007f) << 1 ; + + /* RTR? */ + if (frame->can_id & CAN_RTR_FLAG) + regs->cantxfg.idr[5] |= 0x1; + else { + regs->cantxfg.idr[5] &= ~0x1; + /* No RTR, write data bytes */ + for (i = 0; i < size; i++) + regs->cantxfg.dsr[i + (i / 2) * 2] = + frame->data[i]; + } + } else { + /* Send standard frame */ + + regs->cantxfg.idr[0] = (id & 0x000007f8) >> 3; + regs->cantxfg.idr[1] = (id & 0x00000007) << 5; + + /* RTR? */ + if (frame->can_id & CAN_RTR_FLAG) + regs->cantxfg.idr[1] |= 0x10; + else { + regs->cantxfg.idr[1] &= ~0x10; + /* No RTR, write data bytes */ + for (i = 0; i < size; i++) + regs->cantxfg.dsr[i + (i / 2) * 2] = + frame->data[i]; + } + } + regs->cantxfg.dlr = frame->can_dlc; + regs->cantxfg.tbpr = 0; /* all messages have the same prio */ + + /* Trigger transmission. */ + regs->cantflg = MSCAN_TXE0; + + /* Enable interrupt. */ + regs->cantier |= MSCAN_TXIE0; + + return 0; +} /** * MSCAN Chip configuration @@ -682,231 +676,231 @@ static int rtcan_mscan_start_xmit(struct rtcan_device *dev, */ static inline void __init mscan_chip_config(struct mscan_regs *regs) { - /* Choose IP bus as clock source. - */ - regs->canctl1 |= MSCAN_CLKSRC; - regs->canctl1 &= ~MSCAN_LISTEN; - - /* Configure MSCAN to accept all incoming messages. - */ - regs->canidar0 = regs->canidar1 = 0x00; - regs->canidar2 = regs->canidar3 = 0x00; - regs->canidmr0 = regs->canidmr1 = 0xFF; - regs->canidmr2 = regs->canidmr3 = 0xFF; - regs->canidar4 = regs->canidar5 = 0x00; - regs->canidar6 = regs->canidar7 = 0x00; - regs->canidmr4 = regs->canidmr5 = 0xFF; - regs->canidmr6 = regs->canidmr7 = 0xFF; - regs->canidac &= ~(MSCAN_IDAM0 | MSCAN_IDAM1); + /* Choose IP bus as clock source. + */ + regs->canctl1 |= MSCAN_CLKSRC; + regs->canctl1 &= ~MSCAN_LISTEN; + + /* Configure MSCAN to accept all incoming messages. + */ + regs->canidar0 = regs->canidar1 = 0x00; + regs->canidar2 = regs->canidar3 = 0x00; + regs->canidmr0 = regs->canidmr1 = 0xFF; + regs->canidmr2 = regs->canidmr3 = 0xFF; + regs->canidar4 = regs->canidar5 = 0x00; + regs->canidar6 = regs->canidar7 = 0x00; + regs->canidmr4 = regs->canidmr5 = 0xFF; + regs->canidmr6 = regs->canidmr7 = 0xFF; + regs->canidac &= ~(MSCAN_IDAM0 | MSCAN_IDAM1); } static inline void __init mscan_gpio_config(void) { - struct mpc5xxx_gpio *gpio = (struct mpc5xxx_gpio *)MPC5xxx_GPIO; - int can_to_psc2 = -1; + struct mpc5xxx_gpio *gpio = (struct mpc5xxx_gpio *)MPC5xxx_GPIO; + int can_to_psc2 = -1; #if defined(CONFIG_XENO_DRIVERS_CAN_MSCAN_ALT) - can_to_psc2 = 0; + can_to_psc2 = 0; #elif defined(CONFIG_XENO_DRIVERS_CAN_MSCAN_PSC2) - can_to_psc2 = 1; + can_to_psc2 = 1; #endif - /* Configure CAN routing to GPIO pins. - */ - if (mscan_pins != NULL) { - if (strncmp(mscan_pins, "psc2", 4) == 0 || - !strncmp(mscan_pins, "PSC2", 4)) - can_to_psc2 = 1; - else if (strncmp(mscan_pins, "i2c1/tmr01", 10) == 0 || - strncmp(mscan_pins, "I2C1/TMR01", 10) == 0) - can_to_psc2 = 0; - else { - printk("Module parameter mscan_pins=%s is invalid. " - "Please use PSC2 or I2C1/TMR01.\n", mscan_pins); + /* Configure CAN routing to GPIO pins. + */ + if (mscan_pins != NULL) { + if (strncmp(mscan_pins, "psc2", 4) == 0 || + !strncmp(mscan_pins, "PSC2", 4)) + can_to_psc2 = 1; + else if (strncmp(mscan_pins, "i2c1/tmr01", 10) == 0 || + strncmp(mscan_pins, "I2C1/TMR01", 10) == 0) + can_to_psc2 = 0; + else { + printk("Module parameter mscan_pins=%s is invalid. " + "Please use PSC2 or I2C1/TMR01.\n", mscan_pins); + } + } + + if (!gpio || can_to_psc2 < 0) { + printk("%s: use pre-configure CAN routing\n", RTCAN_DRV_NAME); + return; + } + + if (can_to_psc2) { + gpio->port_config &= ~0x10000070; + gpio->port_config |= 0x00000010; + printk("%s: CAN 1 and 2 routed to PSC2 pins\n", RTCAN_DRV_NAME); + } else { + gpio->port_config |= 0x10000000; + printk("%s: CAN 1 routed to I2C1 pins and CAN2 to TMR01 pins\n", + RTCAN_DRV_NAME); } - } - - if (!gpio || can_to_psc2 < 0) { - printk("%s: use pre-configure CAN routing\n", RTCAN_DRV_NAME); - return; - } - - if (can_to_psc2) { - gpio->port_config &= ~0x10000070; - gpio->port_config |= 0x00000010; - printk("%s: CAN 1 and 2 routed to PSC2 pins\n", RTCAN_DRV_NAME); - } else { - gpio->port_config |= 0x10000000; - printk("%s: CAN 1 routed to I2C1 pins and CAN2 to TMR01 pins\n", - RTCAN_DRV_NAME); - } } -static inline int mscan_get_config(unsigned long *addr, - unsigned int *irq) +static inline int mscan_get_config(unsigned long *addr, unsigned int *irq) { #if defined(CONFIG_PPC_MERGE) || LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27) - /* Use Open Firmware device tree */ - struct device_node *np = NULL; - unsigned int i; - int ret; - - for (i = 0; i < RTCAN_MSCAN_DEVS; i++) { - struct resource r[2] = {}; - - np = of_find_compatible_node(np, NULL, "fsl,mpc5200-mscan"); - if (np == NULL) - np = of_find_compatible_node(np, NULL, "mpc5200-mscan"); - if (np == NULL) - break; - ret = of_address_to_resource(np, 0, &r[0]); - if (ret) - return ret; - of_irq_to_resource(np, 0, &r[1]); - addr[i] = r[0].start; - irq[i] = r[1].start; - rtcan_mscan_count++; - } + /* Use Open Firmware device tree */ + struct device_node *np = NULL; + unsigned int i; + int ret; + + for (i = 0; i < RTCAN_MSCAN_DEVS; i++) { + struct resource r[2] = {}; + + np = of_find_compatible_node(np, NULL, "fsl,mpc5200-mscan"); + if (np == NULL) + np = of_find_compatible_node(np, NULL, "mpc5200-mscan"); + if (np == NULL) + break; + ret = of_address_to_resource(np, 0, &r[0]); + if (ret) + return ret; + of_irq_to_resource(np, 0, &r[1]); + addr[i] = r[0].start; + irq[i] = r[1].start; + rtcan_mscan_count++; + } #else - addr[0] = MSCAN_CAN1_ADDR; - irq[0] = MSCAN_CAN1_IRQ; - addr[1] = MSCAN_CAN2_ADDR; - irq[1] = MSCAN_CAN2_IRQ; - rtcan_mscan_count = 2; + addr[0] = MSCAN_CAN1_ADDR; + irq[0] = MSCAN_CAN1_IRQ; + addr[1] = MSCAN_CAN2_ADDR; + irq[1] = MSCAN_CAN2_IRQ; + rtcan_mscan_count = 2; #endif - return 0; + return 0; } int __init rtcan_mscan_init_one(int idx, unsigned long addr, int irq) { - int ret; - struct rtcan_device *dev; - struct mscan_regs *regs; + int ret; + struct rtcan_device *dev; + struct mscan_regs *regs; - if ((dev = rtcan_dev_alloc(0, 0)) == NULL) { - return -ENOMEM; - } + if ((dev = rtcan_dev_alloc(0, 0)) == NULL) { + return -ENOMEM; + } - dev->ctrl_name = mscan_ctlr_name; - dev->board_name = mscan_board_name; + dev->ctrl_name = mscan_ctlr_name; + dev->board_name = mscan_board_name; - dev->can_sys_clock = mscan_clock; + dev->can_sys_clock = mscan_clock; - dev->base_addr = (unsigned long)ioremap(addr, MSCAN_SIZE); - if (dev->base_addr == 0) { - ret = -ENOMEM; - printk("ERROR! ioremap of %#lx failed\n", addr); - goto out_dev_free; - } + dev->base_addr = (unsigned long)ioremap(addr, MSCAN_SIZE); + if (dev->base_addr == 0) { + ret = -ENOMEM; + printk("ERROR! ioremap of %#lx failed\n", addr); + goto out_dev_free; + } - regs = (struct mscan_regs *)dev->base_addr; + regs = (struct mscan_regs *)dev->base_addr; - /* Enable MSCAN module. */ - regs->canctl1 |= MSCAN_CANE; - udelay(100); + /* Enable MSCAN module. */ + regs->canctl1 |= MSCAN_CANE; + udelay(100); - /* Set dummy state for following call */ - dev->state = CAN_STATE_ACTIVE; + /* Set dummy state for following call */ + dev->state = CAN_STATE_ACTIVE; - /* Enter reset mode */ - rtcan_mscan_mode_stop(dev, NULL); + /* Enter reset mode */ + rtcan_mscan_mode_stop(dev, NULL); - /* Give device an interface name (so that programs using this driver - don't need to know the device ID) */ + /* Give device an interface name (so that programs using this driver + don't need to know the device ID) */ - strncpy(dev->name, RTCAN_DEV_NAME, IFNAMSIZ); + strncpy(dev->name, RTCAN_DEV_NAME, IFNAMSIZ); - dev->hard_start_xmit = rtcan_mscan_start_xmit; - dev->do_set_mode = rtcan_mscan_set_mode; - dev->do_set_bit_time = rtcan_mscan_set_bit_time; + dev->hard_start_xmit = rtcan_mscan_start_xmit; + dev->do_set_mode = rtcan_mscan_set_mode; + dev->do_set_bit_time = rtcan_mscan_set_bit_time; - /* Register IRQ handler and pass device structure as arg */ - ret = rtdm_irq_request(&dev->irq_handle, irq, - rtcan_mscan_interrupt, - 0, RTCAN_DRV_NAME, (void *)dev); - if (ret) { - printk("ERROR! rtdm_irq_request for IRQ %d failed\n", irq); - goto out_iounmap; - } + /* Register IRQ handler and pass device structure as arg */ + ret = rtdm_irq_request(&dev->irq_handle, irq, + rtcan_mscan_interrupt, + 0, RTCAN_DRV_NAME, (void *)dev); + if (ret) { + printk("ERROR! rtdm_irq_request for IRQ %d failed\n", irq); + goto out_iounmap; + } - mscan_chip_config(regs); + mscan_chip_config(regs); - /* Register RTDM device */ - ret = rtcan_dev_register(dev); - if (ret) { - printk(KERN_ERR "ERROR while trying to register RTCAN device!\n"); - goto out_irq_free; - } + /* Register RTDM device */ + ret = rtcan_dev_register(dev); + if (ret) { + printk(KERN_ERR + "ERROR while trying to register RTCAN device!\n"); + goto out_irq_free; + } - rtcan_mscan_create_proc(dev); + rtcan_mscan_create_proc(dev); - /* Remember initialized devices */ - rtcan_mscan_devs[idx] = dev; + /* Remember initialized devices */ + rtcan_mscan_devs[idx] = dev; - printk("%s: %s driver loaded (port %d, base-addr 0x%lx irq %d)\n", - dev->name, RTCAN_DRV_NAME, idx + 1, addr, irq); + printk("%s: %s driver loaded (port %d, base-addr 0x%lx irq %d)\n", + dev->name, RTCAN_DRV_NAME, idx + 1, addr, irq); - return 0; + return 0; out_irq_free: - rtdm_irq_free(&dev->irq_handle); + rtdm_irq_free(&dev->irq_handle); out_iounmap: - /* Disable MSCAN module. */ - regs->canctl1 &= ~MSCAN_CANE; - iounmap((void *)dev->base_addr); + /* Disable MSCAN module. */ + regs->canctl1 &= ~MSCAN_CANE; + iounmap((void *)dev->base_addr); out_dev_free: - rtcan_dev_free(dev); + rtcan_dev_free(dev); - return ret; + return ret; } static void rtcan_mscan_exit(void) { - int i; - struct rtcan_device *dev; + int i; + struct rtcan_device *dev; - for (i = 0; i < rtcan_mscan_count; i++) { + for (i = 0; i < rtcan_mscan_count; i++) { - if ((dev = rtcan_mscan_devs[i]) == NULL) - continue; + if ((dev = rtcan_mscan_devs[i]) == NULL) + continue; - printk("Unloading %s device %s\n", RTCAN_DRV_NAME, dev->name); + printk("Unloading %s device %s\n", RTCAN_DRV_NAME, dev->name); - rtcan_mscan_mode_stop(dev, NULL); - rtdm_irq_free(&dev->irq_handle); - rtcan_mscan_remove_proc(dev); - rtcan_dev_unregister(dev); - iounmap((void *)dev->base_addr); - rtcan_dev_free(dev); - } + rtcan_mscan_mode_stop(dev, NULL); + rtdm_irq_free(&dev->irq_handle); + rtcan_mscan_remove_proc(dev); + rtcan_dev_unregister(dev); + iounmap((void *)dev->base_addr); + rtcan_dev_free(dev); + } } static int __init rtcan_mscan_init(void) { - int i, err; - int unsigned long addr[RTCAN_MSCAN_DEVS]; - int irq[RTCAN_MSCAN_DEVS]; - - if ((err = mscan_get_config(addr, irq))) - return err; - mscan_gpio_config(); - - for (i = 0; i < rtcan_mscan_count; i++) { - if (!port[i]) - continue; - - err = rtcan_mscan_init_one(i, addr[i], irq[i]); - if (err) { - rtcan_mscan_exit(); - return err; + int i, err; + int unsigned long addr[RTCAN_MSCAN_DEVS]; + int irq[RTCAN_MSCAN_DEVS]; + + if ((err = mscan_get_config(addr, irq))) + return err; + mscan_gpio_config(); + + for (i = 0; i < rtcan_mscan_count; i++) { + if (!port[i]) + continue; + + err = rtcan_mscan_init_one(i, addr[i], irq[i]); + if (err) { + rtcan_mscan_exit(); + return err; + } } - } - return 0; + return 0; } module_init(rtcan_mscan_init); diff --git a/ksrc/drivers/can/mscan/rtcan_mscan_proc.c b/ksrc/drivers/can/mscan/rtcan_mscan_proc.c index c4e02da..5671cad 100644 --- a/ksrc/drivers/can/mscan/rtcan_mscan_proc.c +++ b/ksrc/drivers/can/mscan/rtcan_mscan_proc.c @@ -35,104 +35,104 @@ static int rtcan_mscan_proc_regs(char *buf, char **start, off_t offset, int count, int *eof, void *data) { - struct rtcan_device *dev = (struct rtcan_device *)data; - struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; - struct mpc5xxx_gpio *gpio = (struct mpc5xxx_gpio *)MPC5xxx_GPIO; - RTCAN_PROC_PRINT_VARS(80); - - if (!RTCAN_PROC_PRINT("MSCAN registers at %p\n", regs)) - goto done; - if (!RTCAN_PROC_PRINT("canctl0 0x%02x%s%s%s%s%s%s%s%s\n", - regs->canctl0, - (regs->canctl0 & MSCAN_RXFRM) ? " rxfrm" :"", - (regs->canctl0 & MSCAN_RXACT) ? " rxact" :"", - (regs->canctl0 & MSCAN_CSWAI) ? " cswai" :"", - (regs->canctl0 & MSCAN_SYNCH) ? " synch" :"", - (regs->canctl0 & MSCAN_TIME) ? " time" :"", - (regs->canctl0 & MSCAN_WUPE) ? " wupe" :"", - (regs->canctl0 & MSCAN_SLPRQ) ? " slprq" :"", - (regs->canctl0 & MSCAN_INITRQ)? " initrq":"" )) - goto done; - if (!RTCAN_PROC_PRINT("canctl1 0x%02x%s%s%s%s%s%s%s\n", - regs->canctl1, - (regs->canctl1 & MSCAN_CANE) ? " cane" :"", - (regs->canctl1 & MSCAN_CLKSRC)? " clksrc":"", - (regs->canctl1 & MSCAN_LOOPB) ? " loopb" :"", - (regs->canctl1 & MSCAN_LISTEN)? " listen":"", - (regs->canctl1 & MSCAN_WUPM) ? " wump" :"", - (regs->canctl1 & MSCAN_SLPAK) ? " slpak" :"", - (regs->canctl1 & MSCAN_INITAK)? " initak":"")) - goto done; - if (!RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr0 )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr1 )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrflg )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrier )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantflg )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantier )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantarq )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantaak )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantbsel)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidac )) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrxerr)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantxerr)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar0)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar1)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar2)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar3)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr0)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr1)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr2)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr3)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar4)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar5)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar6)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar7)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr4)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr5)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr6)) | - !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr7))) - goto done; - - if (!RTCAN_PROC_PRINT("GPIO registers\n")) - goto done; - if (!RTCAN_PROC_PRINT("port_config 0x%08x %s\n", gpio->port_config, - (gpio->port_config & 0x10000000 ? - "CAN1 on I2C1, CAN2 on TMR0/1 pins": - (gpio->port_config & 0x70) == 0x10 ? - "CAN1/2 on PSC2 pins": "MSCAN1/2 not routed"))) - goto done; - - done: - RTCAN_PROC_PRINT_DONE; + struct rtcan_device *dev = (struct rtcan_device *)data; + struct mscan_regs *regs = (struct mscan_regs *)dev->base_addr; + struct mpc5xxx_gpio *gpio = (struct mpc5xxx_gpio *)MPC5xxx_GPIO; + RTCAN_PROC_PRINT_VARS(80); + + if (!RTCAN_PROC_PRINT("MSCAN registers at %p\n", regs)) + goto done; + if (!RTCAN_PROC_PRINT("canctl0 0x%02x%s%s%s%s%s%s%s%s\n", + regs->canctl0, + (regs->canctl0 & MSCAN_RXFRM) ? " rxfrm" :"", + (regs->canctl0 & MSCAN_RXACT) ? " rxact" :"", + (regs->canctl0 & MSCAN_CSWAI) ? " cswai" :"", + (regs->canctl0 & MSCAN_SYNCH) ? " synch" :"", + (regs->canctl0 & MSCAN_TIME) ? " time" :"", + (regs->canctl0 & MSCAN_WUPE) ? " wupe" :"", + (regs->canctl0 & MSCAN_SLPRQ) ? " slprq" :"", + (regs->canctl0 & MSCAN_INITRQ)? " initrq":"" )) + goto done; + if (!RTCAN_PROC_PRINT("canctl1 0x%02x%s%s%s%s%s%s%s\n", + regs->canctl1, + (regs->canctl1 & MSCAN_CANE) ? " cane" :"", + (regs->canctl1 & MSCAN_CLKSRC)? " clksrc":"", + (regs->canctl1 & MSCAN_LOOPB) ? " loopb" :"", + (regs->canctl1 & MSCAN_LISTEN)? " listen":"", + (regs->canctl1 & MSCAN_WUPM) ? " wump" :"", + (regs->canctl1 & MSCAN_SLPAK) ? " slpak" :"", + (regs->canctl1 & MSCAN_INITAK)? " initak":"")) + goto done; + if (!RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr0 )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canbtr1 )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrflg )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrier )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantflg )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantier )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantarq )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantaak )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantbsel)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidac )) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canrxerr)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(cantxerr)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar0)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar1)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar2)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar3)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr0)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr1)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr2)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr3)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar4)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar5)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar6)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidar7)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr4)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr5)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr6)) | + !RTCAN_PROC_PRINT(MSCAN_REG_ARGS(canidmr7))) + goto done; + + if (!RTCAN_PROC_PRINT("GPIO registers\n")) + goto done; + if (!RTCAN_PROC_PRINT("port_config 0x%08x %s\n", gpio->port_config, + (gpio->port_config & 0x10000000 ? + "CAN1 on I2C1, CAN2 on TMR0/1 pins": + (gpio->port_config & 0x70) == 0x10 ? + "CAN1/2 on PSC2 pins": "MSCAN1/2 not routed"))) + goto done; + +done: + RTCAN_PROC_PRINT_DONE; } int rtcan_mscan_create_proc(struct rtcan_device* dev) { - struct proc_dir_entry *proc_entry; + struct proc_dir_entry *proc_entry; - if (!dev->proc_root) - return -EINVAL; + if (!dev->proc_root) + return -EINVAL; - proc_entry = create_proc_entry("registers", S_IFREG | S_IRUGO | S_IWUSR, - dev->proc_root); - if (!proc_entry) - goto error; - proc_entry->read_proc = rtcan_mscan_proc_regs; - proc_entry->data = dev; + proc_entry = create_proc_entry("registers", S_IFREG | S_IRUGO | S_IWUSR, + dev->proc_root); + if (!proc_entry) + goto error; + proc_entry->read_proc = rtcan_mscan_proc_regs; + proc_entry->data = dev; - return 0; + return 0; - error: - printk("%s: unable to create /proc entries for MSCAN\n", dev->name); - return -1; +error: + printk("%s: unable to create /proc entries for MSCAN\n", dev->name); + return -1; } void rtcan_mscan_remove_proc(struct rtcan_device* dev) { - if (!dev->proc_root) - return; + if (!dev->proc_root) + return; - remove_proc_entry("registers", dev->proc_root); + remove_proc_entry("registers", dev->proc_root); } #else /* !CONFIG_XENO_DRIVERS_CAN_DEBUG */ @@ -143,6 +143,6 @@ void rtcan_mscan_remove_proc(struct rtcan_device* dev) int rtcan_mscan_create_proc(struct rtcan_device* dev) { - return 0; + return 0; } #endif /* CONFIG_XENO_DRIVERS_CAN_DEBUG */ diff --git a/ksrc/drivers/can/mscan/rtcan_mscan_regs.h b/ksrc/drivers/can/mscan/rtcan_mscan_regs.h index e6fd7ed..b4652f5 100644 --- a/ksrc/drivers/can/mscan/rtcan_mscan_regs.h +++ b/ksrc/drivers/can/mscan/rtcan_mscan_regs.h @@ -39,12 +39,12 @@ static inline void __iomem *mpc5xxx_gpio_find_and_map(void) struct device_node *ofn; ofn = of_find_compatible_node(NULL, NULL, "mpc5200-gpio"); if (!ofn) - ofn = of_find_compatible_node(NULL, NULL, "fsl,mpc5200-gpio"); + ofn = of_find_compatible_node(NULL, NULL, "fsl,mpc5200-gpio"); return ofn ? of_iomap(ofn, 0) : NULL; } -#define MPC5xxx_GPIO mpc5xxx_gpio_find_and_map() +#define MPC5xxx_GPIO mpc5xxx_gpio_find_and_map() #else -#define MPC5xxx_GPIO mpc52xx_find_and_map("mpc5200-gpio") +#define MPC5xxx_GPIO mpc52xx_find_and_map("mpc5200-gpio") #endif #define mpc5xxx_gpio mpc52xx_gpio #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10) @@ -63,7 +63,7 @@ static inline void __iomem *mpc5xxx_gpio_find_and_map(void) #define MSCAN_CAN1_ADDR (MSCAN_MBAR + 0x0900) /* MSCAN Module 1 */ #define MSCAN_CAN2_ADDR (MSCAN_MBAR + 0x0980) /* MSCAN Module 2 */ -#define MSCAN_SIZE 0x80 +#define MSCAN_SIZE 0x80 /* MSCAN control register 0 (CANCTL0) bits */ #define MSCAN_RXFRM 0x80 @@ -202,35 +202,37 @@ struct mscan_regs { /* Message type access macros. */ -#define MSCAN_BUF_STD_RTR 0x10 -#define MSCAN_BUF_EXT_RTR 0x01 -#define MSCAN_BUF_EXTENDED 0x08 +#define MSCAN_BUF_STD_RTR 0x10 +#define MSCAN_BUF_EXT_RTR 0x01 +#define MSCAN_BUF_EXTENDED 0x08 -#define MSCAN_IDAM1 0x20 +#define MSCAN_IDAM1 0x20 /* Value for the interrupt enable register */ -#define MSCAN_RIER (MSCAN_OVRIE | \ - MSCAN_RXFIE | \ - MSCAN_WUPIF | \ - MSCAN_CSCIE | \ - MSCAN_RSTATE0 | \ - MSCAN_RSTATE1 | \ - MSCAN_TSTATE0 | \ - MSCAN_TSTATE1) - -#define BTR0_BRP_MASK 0x3f -#define BTR0_SJW_SHIFT 6 -#define BTR0_SJW_MASK (0x3 << BTR0_SJW_SHIFT) - -#define BTR1_TSEG1_MASK 0xf -#define BTR1_TSEG2_SHIFT 4 -#define BTR1_TSEG2_MASK (0x7 << BTR1_TSEG2_SHIFT) -#define BTR1_SAM_SHIFT 7 - -#define BTR0_SET_BRP(brp) (((brp) - 1) & BTR0_BRP_MASK) -#define BTR0_SET_SJW(sjw) ((((sjw) - 1) << BTR0_SJW_SHIFT) & BTR0_SJW_MASK) - -#define BTR1_SET_TSEG1(tseg1) (((tseg1) - 1) & BTR1_TSEG1_MASK) -#define BTR1_SET_TSEG2(tseg2) ((((tseg2) - 1) << BTR1_TSEG2_SHIFT) & BTR1_TSEG2_MASK) -#define BTR1_SET_SAM(sam) (((sam) & 1) << BTR1_SAM_SHIFT) +#define MSCAN_RIER (MSCAN_OVRIE | \ + MSCAN_RXFIE | \ + MSCAN_WUPIF | \ + MSCAN_CSCIE | \ + MSCAN_RSTATE0 | \ + MSCAN_RSTATE1 | \ + MSCAN_TSTATE0 | \ + MSCAN_TSTATE1) + +#define BTR0_BRP_MASK 0x3f +#define BTR0_SJW_SHIFT 6 +#define BTR0_SJW_MASK (0x3 << BTR0_SJW_SHIFT) + +#define BTR1_TSEG1_MASK 0xf +#define BTR1_TSEG2_SHIFT 4 +#define BTR1_TSEG2_MASK (0x7 << BTR1_TSEG2_SHIFT) +#define BTR1_SAM_SHIFT 7 + +#define BTR0_SET_BRP(brp) (((brp) - 1) & BTR0_BRP_MASK) +#define BTR0_SET_SJW(sjw) ((((sjw) - 1) << BTR0_SJW_SHIFT) & \ + BTR0_SJW_MASK) + +#define BTR1_SET_TSEG1(tseg1) (((tseg1) - 1) & BTR1_TSEG1_MASK) +#define BTR1_SET_TSEG2(tseg2) ((((tseg2) - 1) << BTR1_TSEG2_SHIFT) & \ + BTR1_TSEG2_MASK) +#define BTR1_SET_SAM(sam) (((sam) & 1) << BTR1_SAM_SHIFT) #endif /* __RTCAN_MSCAN_REGS_H_ */ _______________________________________________ Xenomai-git mailing list Xenomai-git@gna.org https://mail.gna.org/listinfo/xenomai-git