From 8b922b1546a9b0f4fa2eeb692e1a304bfc0df5c7 Mon Sep 17 00:00:00 2001 From: Sebastien Lorquet Date: Wed, 22 Jun 2016 07:36:49 -0600 Subject: [PATCH] Enforce STM32L4 naming convention --- arch/arm/src/stm32l4/stm32l4_can.c | 486 +++++++++++++++-------------- 1 file changed, 259 insertions(+), 227 deletions(-) diff --git a/arch/arm/src/stm32l4/stm32l4_can.c b/arch/arm/src/stm32l4/stm32l4_can.c index 4d239c2fc3..c7808c8895 100644 --- a/arch/arm/src/stm32l4/stm32l4_can.c +++ b/arch/arm/src/stm32l4/stm32l4_can.c @@ -107,52 +107,66 @@ struct stm32l4_can_s /* CAN Register access */ -static uint32_t can_getreg(FAR struct stm32l4_can_s *priv, int offset); -static uint32_t can_getfreg(FAR struct stm32l4_can_s *priv, int offset); -static void can_putreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value); -static void can_putfreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value); +static uint32_t stm32l4_cangetreg(FAR struct stm32l4_can_s *priv, + int offset); +static uint32_t stm32l4_cangetfreg(FAR struct stm32l4_can_s *priv, + int offset); +static void stm32l4_canputreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value); +static void stm32l4_canputfreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value); #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static void can_dumpctrlregs(FAR struct stm32l4_can_s *priv, FAR const char *msg); -static void can_dumpmbregs(FAR struct stm32l4_can_s *priv, FAR const char *msg); -static void can_dumpfiltregs(FAR struct stm32l4_can_s *priv, FAR const char *msg); +static void stm32l4_candumpctrlregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg); +static void stm32l4_candumpmbregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg); +static void stm32l4_candumpfiltregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg); #else -# define can_dumpctrlregs(priv,msg) -# define can_dumpmbregs(priv,msg) -# define can_dumpfiltregs(priv,msg) +# define stm32l4_candumpctrlregs(priv,msg) +# define stm32l4_candumpmbregs(priv,msg) +# define stm32l4_candumpfiltregs(priv,msg) #endif /* CAN driver methods */ -static void can_reset(FAR struct can_dev_s *dev); -static int can_setup(FAR struct can_dev_s *dev); -static void can_shutdown(FAR struct can_dev_s *dev); -static void can_rxint(FAR struct can_dev_s *dev, bool enable); -static void can_txint(FAR struct can_dev_s *dev, bool enable); -static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg); -static int can_remoterequest(FAR struct can_dev_s *dev, uint16_t id); -static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg); -static bool can_txready(FAR struct can_dev_s *dev); -static bool can_txempty(FAR struct can_dev_s *dev); +static void stm32l4_canreset(FAR struct can_dev_s *dev); +static int stm32l4_cansetup(FAR struct can_dev_s *dev); +static void stm32l4_canshutdown(FAR struct can_dev_s *dev); +static void stm32l4_canrxint(FAR struct can_dev_s *dev, bool enable); +static void stm32l4_cantxint(FAR struct can_dev_s *dev, bool enable); +static int stm32l4_canioctl(FAR struct can_dev_s *dev, int cmd, + unsigned long arg); +static int stm32l4_canremoterequest(FAR struct can_dev_s *dev, + uint16_t id); +static int stm32l4_cansend(FAR struct can_dev_s *dev, + FAR struct can_msg_s *msg); +static bool stm32l4_cantxready(FAR struct can_dev_s *dev); +static bool stm32l4_cantxempty(FAR struct can_dev_s *dev); /* CAN interrupt handling */ -static int can_rx0interrupt(int irq, FAR void *context); -static int can_txinterrupt(int irq, FAR void *context); +static int stm32l4_canrx0interrupt(int irq, FAR void *context); +static int stm32l4_cantxinterrupt(int irq, FAR void *context); /* Initialization */ -static int can_enterinitmode(FAR struct stm32l4_can_s *priv); -static int can_exitinitmode(FAR struct stm32l4_can_s *priv); -static int can_bittiming(FAR struct stm32l4_can_s *priv); -static int can_cellinit(FAR struct stm32l4_can_s *priv); -static int can_filterinit(FAR struct stm32l4_can_s *priv); +static int stm32l4_canenterinitmode(FAR struct stm32l4_can_s *priv); +static int stm32l4_canexitinitmode(FAR struct stm32l4_can_s *priv); +static int stm32l4_canbittiming(FAR struct stm32l4_can_s *priv); +static int stm32l4_cancellinit(FAR struct stm32l4_can_s *priv); +static int stm32l4_canfilterinit(FAR struct stm32l4_can_s *priv); /* Filtering (todo) */ -static int stm32l4_can_addextfilter(FAR struct stm32l4_can_s *priv, FAR struct canioc_extfilter_s *arg); -static int stm32l4_can_delextfilter(FAR struct stm32l4_can_s *priv, int arg); -static int stm32l4_can_addstdfilter(FAR struct stm32l4_can_s *priv, FAR struct canioc_stdfilter_s *arg); -static int stm32l4_can_delstdfilter(FAR struct stm32l4_can_s *priv, int arg); +static int stm32l4_canaddextfilter(FAR struct stm32l4_can_s *priv, + FAR struct canioc_extfilter_s *arg); +static int stm32l4_candelextfilter(FAR struct stm32l4_can_s *priv, + int arg); +static int stm32l4_canaddstdfilter(FAR struct stm32l4_can_s *priv, + FAR struct canioc_stdfilter_s *arg); +static int stm32l4_candelstdfilter(FAR struct stm32l4_can_s *priv, + int arg); /**************************************************************************** * Private Data @@ -160,16 +174,16 @@ static int stm32l4_can_delstdfilter(FAR struct stm32l4_can_s *priv, int arg); static const struct can_ops_s g_canops = { - .co_reset = can_reset, - .co_setup = can_setup, - .co_shutdown = can_shutdown, - .co_rxint = can_rxint, - .co_txint = can_txint, - .co_ioctl = can_ioctl, - .co_remoterequest = can_remoterequest, - .co_send = can_send, - .co_txready = can_txready, - .co_txempty = can_txempty, + .co_reset = stm32l4_canreset, + .co_setup = stm32l4_cansetup, + .co_shutdown = stm32l4_canshutdown, + .co_rxint = stm32l4_canrxint, + .co_txint = stm32l4_cantxint, + .co_ioctl = stm32l4_canioctl, + .co_remoterequest = stm32l4_canremoterequest, + .co_send = stm32l4_cansend, + .co_txready = stm32l4_cantxready, + .co_txempty = stm32l4_cantxempty, }; #ifdef CONFIG_STM32L4_CAN1 @@ -196,8 +210,8 @@ static struct can_dev_s g_can1dev = ****************************************************************************/ /**************************************************************************** - * Name: can_getreg - * Name: can_getfreg + * Name: stm32l4_cangetreg + * Name: stm32l4_cangetfreg * * Description: * Read the value of a CAN register or filter block register. @@ -211,7 +225,7 @@ static struct can_dev_s g_can1dev = ****************************************************************************/ #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static uint32_t can_vgetreg(uint32_t addr) +static uint32_t stm32l4_canvgetreg(uint32_t addr) { static uint32_t prevaddr = 0; static uint32_t preval = 0; @@ -264,23 +278,23 @@ static uint32_t can_vgetreg(uint32_t addr) return val; } -static uint32_t can_getreg(FAR struct stm32l4_can_s *priv, int offset) +static uint32_t stm32l4_cangetreg(FAR struct stm32l4_can_s *priv, int offset) { - return can_vgetreg(priv->base + offset); + return stm32l4_canvgetreg(priv->base + offset); } -static uint32_t can_getfreg(FAR struct stm32l4_can_s *priv, int offset) +static uint32_t stm32l4_cangetfreg(FAR struct stm32l4_can_s *priv, int offset) { - return can_vgetreg(priv->fbase + offset); + return stm32l4_canvgetreg(priv->fbase + offset); } #else -static uint32_t can_getreg(FAR struct stm32l4_can_s *priv, int offset) +static uint32_t stm32l4_cangetreg(FAR struct stm32l4_can_s *priv, int offset) { return getreg32(priv->base + offset); } -static uint32_t can_getfreg(FAR struct stm32l4_can_s *priv, int offset) +static uint32_t stm32l4_cangetfreg(FAR struct stm32l4_can_s *priv, int offset) { return getreg32(priv->fbase + offset); } @@ -288,8 +302,8 @@ static uint32_t can_getfreg(FAR struct stm32l4_can_s *priv, int offset) #endif /**************************************************************************** - * Name: can_putreg - * Name: can_putfreg + * Name: stm32l4_canputreg + * Name: stm32l4_canputfreg * * Description: * Set the value of a CAN register or filter block register. @@ -305,7 +319,7 @@ static uint32_t can_getfreg(FAR struct stm32l4_can_s *priv, int offset) ****************************************************************************/ #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static void can_vputreg(uint32_t addr, uint32_t value) +static void stm32l4_canvputreg(uint32_t addr, uint32_t value) { /* Show the register value being written */ @@ -316,30 +330,34 @@ static void can_vputreg(uint32_t addr, uint32_t value) putreg32(value, addr); } -static void can_putreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value) +static void stm32l4_canputreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value) { - can_vputreg(priv->base + offset, value); + stm32l4_canvputreg(priv->base + offset, value); } -static void can_putfreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value) +static void stm32l4_canputfreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value) { - can_vputreg(priv->fbase + offset, value); + stm32l4_canvputreg(priv->fbase + offset, value); } #else -static void can_putreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value) +static void stm32l4_canputreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value) { putreg32(value, priv->base + offset); } -static void can_putfreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t value) +static void stm32l4_canputfreg(FAR struct stm32l4_can_s *priv, int offset, + uint32_t value) { putreg32(value, priv->fbase + offset); } #endif /**************************************************************************** - * Name: can_dumpctrlregs + * Name: stm32l4_candumpctrlregs * * Description: * Dump the contents of all CAN control registers @@ -353,7 +371,8 @@ static void can_putfreg(FAR struct stm32l4_can_s *priv, int offset, uint32_t val ****************************************************************************/ #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static void can_dumpctrlregs(FAR struct stm32l4_can_s *priv, FAR const char *msg) +static void stm32l4_candumpctrlregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg) { if (msg) { @@ -383,7 +402,7 @@ static void can_dumpctrlregs(FAR struct stm32l4_can_s *priv, FAR const char *msg #endif /**************************************************************************** - * Name: can_dumpmbregs + * Name: stm32l4_candumpmbregs * * Description: * Dump the contents of all CAN mailbox registers @@ -397,7 +416,8 @@ static void can_dumpctrlregs(FAR struct stm32l4_can_s *priv, FAR const char *msg ****************************************************************************/ #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static void can_dumpmbregs(FAR struct stm32l4_can_s *priv, FAR const char *msg) +static void stm32l4_candumpmbregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg) { if (msg) { @@ -443,7 +463,7 @@ static void can_dumpmbregs(FAR struct stm32l4_can_s *priv, FAR const char *msg) #endif /**************************************************************************** - * Name: can_dumpfiltregs + * Name: stm32l4_candumpfiltregs * * Description: * Dump the contents of all CAN filter registers @@ -457,7 +477,8 @@ static void can_dumpmbregs(FAR struct stm32l4_can_s *priv, FAR const char *msg) ****************************************************************************/ #ifdef CONFIG_STM32L4_CAN_REGDEBUG -static void can_dumpfiltregs(FAR struct stm32l4_can_s *priv, FAR const char *msg) +static void stm32l4_candumpfiltregs(FAR struct stm32l4_can_s *priv, + FAR const char *msg) { int i; @@ -487,11 +508,11 @@ static void can_dumpfiltregs(FAR struct stm32l4_can_s *priv, FAR const char *msg #endif /**************************************************************************** - * Name: can_reset + * Name: stm32l4_canreset * * Description: * Reset the CAN device. Called early to initialize the hardware. This - * function is called, before can_setup() and on error conditions. + * function is called, before stm32l4_cansetup() and on error conditions. * * Input Parameters: * dev - An instance of the "upper half" can driver state structure. @@ -501,7 +522,7 @@ static void can_dumpfiltregs(FAR struct stm32l4_can_s *priv, FAR const char *msg * ****************************************************************************/ -static void can_reset(FAR struct can_dev_s *dev) +static void stm32l4_canreset(FAR struct can_dev_s *dev) { FAR struct stm32l4_can_s *priv = dev->cd_priv; uint32_t regval; @@ -524,8 +545,8 @@ static void can_reset(FAR struct can_dev_s *dev) return; } - /* Disable interrupts momentary to stop any ongoing CAN event processing and - * to prevent any concurrent access to the AHB1RSTR1 register. + /* Disable interrupts momentary to stop any ongoing CAN event processing + * and to prevent any concurrent access to the AHB1RSTR1 register. */ flags = enter_critical_section(); @@ -542,7 +563,7 @@ static void can_reset(FAR struct can_dev_s *dev) } /**************************************************************************** - * Name: can_setup + * Name: stm32l4_cansetup * * Description: * Configure the CAN. This method is called the first time that the CAN @@ -558,49 +579,56 @@ static void can_reset(FAR struct can_dev_s *dev) * ****************************************************************************/ -static int can_setup(FAR struct can_dev_s *dev) +static int stm32l4_cansetup(FAR struct can_dev_s *dev) { FAR struct stm32l4_can_s *priv = dev->cd_priv; int ret; - caninfo("CAN%d RX0 irq: %d TX irq: %d\n", priv->port, priv->canrx0, priv->cantx); + caninfo("CAN%d RX0 irq: %d TX irq: %d\n", + priv->port, priv->canrx0, priv->cantx); /* CAN cell initialization */ - ret = can_cellinit(priv); + ret = stm32l4_cancellinit(priv); if (ret < 0) { - canerr("ERROR: CAN%d cell initialization failed: %d\n", priv->port, ret); + canerr("ERROR: CAN%d cell initialization failed: %d\n", + priv->port, ret); return ret; } - can_dumpctrlregs(priv, "After cell initialization"); - can_dumpmbregs(priv, NULL); + stm32l4_candumpctrlregs(priv, "After cell initialization"); + stm32l4_candumpmbregs(priv, NULL); /* CAN filter initialization */ - ret = can_filterinit(priv); + ret = stm32l4_canfilterinit(priv); if (ret < 0) { - canerr("ERROR: CAN%d filter initialization failed: %d\n", priv->port, ret); + canerr("ERROR: CAN%d filter initialization failed: %d\n", + priv->port, ret); return ret; } - can_dumpfiltregs(priv, "After filter initialization"); + stm32l4_candumpfiltregs(priv, "After filter initialization"); - /* Attach the CAN RX FIFO 0 interrupt and TX interrupts. The others are not used */ + /* Attach the CAN RX FIFO 0 interrupt and TX interrupts. The others are + * not used. + */ - ret = irq_attach(priv->canrx0, can_rx0interrupt); + ret = irq_attach(priv->canrx0, stm32l4_canrx0interrupt); if (ret < 0) { - canerr("ERROR: Failed to attach CAN%d RX0 IRQ (%d)", priv->port, priv->canrx0); + canerr("ERROR: Failed to attach CAN%d RX0 IRQ (%d)", + priv->port, priv->canrx0); return ret; } - ret = irq_attach(priv->cantx, can_txinterrupt); + ret = irq_attach(priv->cantx, stm32l4_cantxinterrupt); if (ret < 0) { - canerr("ERROR: Failed to attach CAN%d TX IRQ (%d)", priv->port, priv->cantx); + canerr("ERROR: Failed to attach CAN%d TX IRQ (%d)", + priv->port, priv->cantx); return ret; } @@ -615,7 +643,7 @@ static int can_setup(FAR struct can_dev_s *dev) } /**************************************************************************** - * Name: can_shutdown + * Name: stm32l4_canshutdown * * Description: * Disable the CAN. This method is called when the CAN device is closed. @@ -629,7 +657,7 @@ static int can_setup(FAR struct can_dev_s *dev) * ****************************************************************************/ -static void can_shutdown(FAR struct can_dev_s *dev) +static void stm32l4_canshutdown(FAR struct can_dev_s *dev) { FAR struct stm32l4_can_s *priv = dev->cd_priv; @@ -647,11 +675,11 @@ static void can_shutdown(FAR struct can_dev_s *dev) /* And reset the hardware */ - can_reset(dev); + stm32l4_canreset(dev); } /**************************************************************************** - * Name: can_rxint + * Name: stm32l4_canrxint * * Description: * Call to enable or disable RX interrupts. @@ -664,7 +692,7 @@ static void can_shutdown(FAR struct can_dev_s *dev) * ****************************************************************************/ -static void can_rxint(FAR struct can_dev_s *dev, bool enable) +static void stm32l4_canrxint(FAR struct can_dev_s *dev, bool enable) { FAR struct stm32l4_can_s *priv = dev->cd_priv; uint32_t regval; @@ -673,7 +701,7 @@ static void can_rxint(FAR struct can_dev_s *dev, bool enable) /* Enable/disable the FIFO 0 message pending interrupt */ - regval = can_getreg(priv, STM32L4_CAN_IER_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_IER_OFFSET); if (enable) { regval |= CAN_IER_FMPIE0; @@ -683,11 +711,11 @@ static void can_rxint(FAR struct can_dev_s *dev, bool enable) regval &= ~CAN_IER_FMPIE0; } - can_putreg(priv, STM32L4_CAN_IER_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_IER_OFFSET, regval); } /**************************************************************************** - * Name: can_txint + * Name: stm32l4_cantxint * * Description: * Call to enable or disable TX interrupts. @@ -700,7 +728,7 @@ static void can_rxint(FAR struct can_dev_s *dev, bool enable) * ****************************************************************************/ -static void can_txint(FAR struct can_dev_s *dev, bool enable) +static void stm32l4_cantxint(FAR struct can_dev_s *dev, bool enable) { FAR struct stm32l4_can_s *priv = dev->cd_priv; uint32_t regval; @@ -711,14 +739,14 @@ static void can_txint(FAR struct can_dev_s *dev, bool enable) if (!enable) { - regval = can_getreg(priv, STM32L4_CAN_IER_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_IER_OFFSET); regval &= ~CAN_IER_TMEIE; - can_putreg(priv, STM32L4_CAN_IER_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_IER_OFFSET, regval); } } /**************************************************************************** - * Name: can_ioctl + * Name: stm32l4_canioctl * * Description: * All ioctl calls will be routed through this method @@ -731,7 +759,8 @@ static void can_txint(FAR struct can_dev_s *dev, bool enable) * ****************************************************************************/ -static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) +static int stm32l4_canioctl(FAR struct can_dev_s *dev, int cmd, + unsigned long arg) { FAR struct stm32l4_can_s *priv; int ret = -ENOTTY; @@ -748,11 +777,11 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) /* CANIOC_GET_BITTIMING: * Description: Return the current bit timing settings * Argument: A pointer to a write-able instance of struct - * canioc_bittiming_s in which current bit timing values - * will be returned. - * Returned Value: Zero (OK) is returned on success. Otherwise -1 (ERROR) - * is returned with the errno variable set to indicate the - * nature of the error. + * canioc_bittiming_s in which current bit timing + * values will be returned. + * Returned Value: Zero (OK) is returned on success. Otherwise -1 + * (ERROR) is returned with the errno variable set + * to indicate the nature of the error. * Dependencies: None */ @@ -764,7 +793,7 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) uint32_t brp; DEBUGASSERT(bt != NULL); - regval = can_getreg(priv, STM32L4_CAN_BTR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_BTR_OFFSET); bt->bt_sjw = ((regval & CAN_BTR_SJW_MASK) >> CAN_BTR_SJW_SHIFT) + 1; bt->bt_tseg1 = ((regval & CAN_BTR_TS1_MASK) >> CAN_BTR_TS1_SHIFT) + 1; bt->bt_tseg2 = ((regval & CAN_BTR_TS2_MASK) >> CAN_BTR_TS2_SHIFT) + 1; @@ -779,18 +808,18 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) /* CANIOC_SET_BITTIMING: * Description: Set new current bit timing values * Argument: A pointer to a read-able instance of struct - * canioc_bittiming_s in which the new bit timing values - * are provided. - * Returned Value: Zero (OK) is returned on success. Otherwise -1 (ERROR) - * is returned with the errno variable set to indicate the - * nature of the error. + * canioc_bittiming_s in which the new bit timing + * valuesare provided. + * Returned Value: Zero (OK) is returned on success. Otherwise -1 + * (ERROR)is returned with the errno variable set + * to indicate thenature of the error. * Dependencies: None * * REVISIT: There is probably a limitation here: If there are multiple - * threads trying to send CAN packets, when one of these threads reconfigures - * the bitrate, the MCAN hardware will be reset and the context of operation - * will be lost. Hence, this IOCTL can only safely be executed in quiescent - * time periods. + * threads trying to send CAN packets, when one of these threads + * reconfigures the bitrate, the MCAN hardware will be reset and the + * context of operation will be lost. Hence, this IOCTL can only safely + * be executed in quiescent time periods. */ case CANIOC_SET_BITTIMING: @@ -798,7 +827,7 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) FAR const struct canioc_bittiming_s *bt = (FAR const struct canioc_bittiming_s *)arg; uint32_t brp; - uint32_t can_bit_quanta; + uint32_t stm32l4_canbit_quanta; uint32_t tmp; DEBUGASSERT(bt != NULL); @@ -814,9 +843,9 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) /* This value is dynamic as requested by user */ - can_bit_quanta = bt->bt_tseg1 + bt->bt_tseg2 + 1; + stm32l4_canbit_quanta = bt->bt_tseg1 + bt->bt_tseg2 + 1; - if (tmp < can_bit_quanta) + if (tmp < stm32l4_canbit_quanta) { #if 0 /* At the smallest brp value (1), there are already too few @@ -845,14 +874,14 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) #endif } - /* Otherwise, nquanta is can_bit_quanta, ts1 and ts2 are provided - * by the user and we calculate brp to achieve can_bit_quanta - * quanta in the bit time + /* Otherwise, nquanta is stm32l4_canbit_quanta, ts1 and ts2 are + * provided by the user and we calculate brp to achieve + * stm32l4_canbit_quanta quanta in the bit times */ else { - brp = (tmp + (can_bit_quanta/2)) / can_bit_quanta; + brp = (tmp + (stm32l4_canbit_quanta/2)) / stm32l4_canbit_quanta; DEBUGASSERT(brp >= 1 && brp <= CAN_BTR_BRP_MAX); } @@ -878,14 +907,14 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) * No registers are changed. */ - ret = can_enterinitmode(priv); + ret = stm32l4_canenterinitmode(priv); if (ret != 0) { break; } - can_putreg(priv, STM32L4_CAN_BTR_OFFSET, tmp); - ret = can_exitinitmode(priv); + stm32l4_canputreg(priv, STM32L4_CAN_BTR_OFFSET, tmp); + ret = stm32l4_canexitinitmode(priv); if (ret == 0) { @@ -907,23 +936,24 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) case CANIOC_ADD_EXTFILTER: { DEBUGASSERT(arg != 0); - ret = stm32l4_can_addextfilter(priv, (FAR struct canioc_extfilter_s *)arg); + ret = stm32l4_canaddextfilter(priv, (FAR struct canioc_extfilter_s *)arg); } break; /* CANIOC_DEL_EXTFILTER: - * Description: Remove an address filter for a standard 29 bit address. + * Description: Remove an address filter for a standard 29 bit + * address. * Argument: The filter index previously returned by the * CANIOC_ADD_EXTFILTER command - * Returned Value: Zero (OK) is returned on success. Otherwise -1 (ERROR) - * is returned with the errno variable set to indicate the - * nature of the error. + * Returned Value: Zero (OK) is returned on success. Otherwise -1 + * (ERROR)is returned with the errno variable set + * to indicate the nature of the error. */ case CANIOC_DEL_EXTFILTER: { DEBUGASSERT(arg <= priv->config->nextfilters); - ret = stm32l4_can_delextfilter(priv, (int)arg); + ret = stm32l4_candelextfilter(priv, (int)arg); } break; #endif @@ -940,23 +970,24 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) case CANIOC_ADD_STDFILTER: { DEBUGASSERT(arg != 0); - ret = stm32l4_can_addstdfilter(priv, (FAR struct canioc_stdfilter_s *)arg); + ret = stm32l4_canaddstdfilter(priv, (FAR struct canioc_stdfilter_s *)arg); } break; /* CANIOC_DEL_STDFILTER: - * Description: Remove an address filter for a standard 11 bit address. + * Description: Remove an address filter for a standard 11 bit + * address. * Argument: The filter index previously returned by the * CANIOC_ADD_STDFILTER command - * Returned Value: Zero (OK) is returned on success. Otherwise -1 (ERROR) - * is returned with the errno variable set to indicate the - * nature of the error. + * Returned Value: Zero (OK) is returned on success. Otherwise -1 + * (ERROR) is returned with the errno variable set + * to indicate the nature of the error. */ case CANIOC_DEL_STDFILTER: { DEBUGASSERT(arg <= priv->config->nstdfilters); - ret = stm32l4_can_delstdfilter(priv, (int)arg); + ret = stm32l4_candelstdfilter(priv, (int)arg); } break; @@ -971,7 +1002,7 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) } /**************************************************************************** - * Name: can_remoterequest + * Name: stm32l4_canremoterequest * * Description: * Send a remote request @@ -984,14 +1015,14 @@ static int can_ioctl(FAR struct can_dev_s *dev, int cmd, unsigned long arg) * ****************************************************************************/ -static int can_remoterequest(FAR struct can_dev_s *dev, uint16_t id) +static int stm32l4_canremoterequest(FAR struct can_dev_s *dev, uint16_t id) { #warning "Remote request not implemented" return -ENOSYS; } /**************************************************************************** - * Name: can_send + * Name: stm32l4_cansend * * Description: * Send one can message. @@ -1013,7 +1044,8 @@ static int can_remoterequest(FAR struct can_dev_s *dev, uint16_t id) * ****************************************************************************/ -static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) +static int stm32l4_cansend(FAR struct can_dev_s *dev, + FAR struct can_msg_s *msg) { FAR struct stm32l4_can_s *priv = dev->cd_priv; FAR uint8_t *ptr; @@ -1027,7 +1059,7 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) /* Select one empty transmit mailbox */ - regval = can_getreg(priv, STM32L4_CAN_TSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TSR_OFFSET); if ((regval & CAN_TSR_TME0) != 0 && (regval & CAN_TSR_RQCP0) == 0) { txmb = 0; @@ -1048,9 +1080,10 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) /* Clear TXRQ, RTR, IDE, EXID, and STID fields */ - regval = can_getreg(priv, STM32L4_CAN_TIR_OFFSET(txmb)); - regval &= ~(CAN_TIR_TXRQ | CAN_TIR_RTR | CAN_TIR_IDE | CAN_TIR_EXID_MASK | CAN_TIR_STID_MASK); - can_putreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TIR_OFFSET(txmb)); + regval &= ~(CAN_TIR_TXRQ | CAN_TIR_RTR | CAN_TIR_IDE | CAN_TIR_EXID_MASK | + CAN_TIR_STID_MASK); + stm32l4_canputreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); /* Set up the ID, standard 11-bit or extended 29-bit. */ @@ -1070,15 +1103,15 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) regval &= ~CAN_TIR_STID_MASK; regval |= (uint32_t)msg->cm_hdr.ch_id << CAN_TIR_STID_SHIFT; #endif - can_putreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); + stm32l4_canputreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); /* Set up the DLC */ dlc = msg->cm_hdr.ch_dlc; - regval = can_getreg(priv, STM32L4_CAN_TDTR_OFFSET(txmb)); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TDTR_OFFSET(txmb)); regval &= ~(CAN_TDTR_DLC_MASK | CAN_TDTR_TGT); regval |= (uint32_t)dlc << CAN_TDTR_DLC_SHIFT; - can_putreg(priv, STM32L4_CAN_TDTR_OFFSET(txmb), regval); + stm32l4_canputreg(priv, STM32L4_CAN_TDTR_OFFSET(txmb), regval); /* Set up the data fields */ @@ -1109,7 +1142,7 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) } } - can_putreg(priv, STM32L4_CAN_TDLR_OFFSET(txmb), regval); + stm32l4_canputreg(priv, STM32L4_CAN_TDLR_OFFSET(txmb), regval); regval = 0; if (dlc > 4) @@ -1136,26 +1169,26 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) } } - can_putreg(priv, STM32L4_CAN_TDHR_OFFSET(txmb), regval); + stm32l4_canputreg(priv, STM32L4_CAN_TDHR_OFFSET(txmb), regval); /* Enable the transmit mailbox empty interrupt (may already be enabled) */ - regval = can_getreg(priv, STM32L4_CAN_IER_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_IER_OFFSET); regval |= CAN_IER_TMEIE; - can_putreg(priv, STM32L4_CAN_IER_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_IER_OFFSET, regval); /* Request transmission */ - regval = can_getreg(priv, STM32L4_CAN_TIR_OFFSET(txmb)); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TIR_OFFSET(txmb)); regval |= CAN_TIR_TXRQ; /* Transmit Mailbox Request */ - can_putreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); + stm32l4_canputreg(priv, STM32L4_CAN_TIR_OFFSET(txmb), regval); - can_dumpmbregs(priv, "After send"); + stm32l4_candumpmbregs(priv, "After send"); return OK; } /**************************************************************************** - * Name: can_txready + * Name: stm32l4_cantxready * * Description: * Return true if the CAN hardware can accept another TX message. @@ -1168,14 +1201,14 @@ static int can_send(FAR struct can_dev_s *dev, FAR struct can_msg_s *msg) * ****************************************************************************/ -static bool can_txready(FAR struct can_dev_s *dev) +static bool stm32l4_cantxready(FAR struct can_dev_s *dev) { FAR struct stm32l4_can_s *priv = dev->cd_priv; uint32_t regval; /* Return true if any mailbox is available */ - regval = can_getreg(priv, STM32L4_CAN_TSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TSR_OFFSET); caninfo("CAN%d TSR: %08x\n", priv->port, regval); if ((regval & CAN_ALL_MAILBOXES) != 0) @@ -1187,7 +1220,7 @@ static bool can_txready(FAR struct can_dev_s *dev) } /**************************************************************************** - * Name: can_txempty + * Name: stm32l4_cantxempty * * Description: * Return true if all message have been sent. If for example, the CAN @@ -1204,14 +1237,14 @@ static bool can_txready(FAR struct can_dev_s *dev) * ****************************************************************************/ -static bool can_txempty(FAR struct can_dev_s *dev) +static bool stm32l4_cantxempty(FAR struct can_dev_s *dev) { FAR struct stm32l4_can_s *priv = dev->cd_priv; uint32_t regval; /* Return true if all mailboxes are available */ - regval = can_getreg(priv, STM32L4_CAN_TSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TSR_OFFSET); caninfo("CAN%d TSR: %08x\n", priv->port, regval); if ((regval & CAN_ALL_MAILBOXES) == CAN_ALL_MAILBOXES) @@ -1223,7 +1256,7 @@ static bool can_txempty(FAR struct can_dev_s *dev) } /**************************************************************************** - * Name: can_rx0interrupt + * Name: stm32l4_canrx0interrupt * * Description: * CAN RX FIFO 0 interrupt handler @@ -1237,7 +1270,7 @@ static bool can_txempty(FAR struct can_dev_s *dev) * ****************************************************************************/ -static int can_rx0interrupt(int irq, FAR void *context) +static int stm32l4_canrx0interrupt(int irq, FAR void *context) { FAR struct can_dev_s *dev = NULL; FAR struct stm32l4_can_s *priv; @@ -1252,7 +1285,7 @@ static int can_rx0interrupt(int irq, FAR void *context) /* Verify that a message is pending in FIFO 0 */ - regval = can_getreg(priv, STM32L4_CAN_RF0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RF0R_OFFSET); npending = (regval & CAN_RFR_FMP_MASK) >> CAN_RFR_FMP_SHIFT; if (npending < 1) { @@ -1260,11 +1293,11 @@ static int can_rx0interrupt(int irq, FAR void *context) return OK; } - can_dumpmbregs(priv, "RX0 interrupt"); + stm32l4_candumpmbregs(priv, "RX0 interrupt"); /* Get the CAN identifier. */ - regval = can_getreg(priv, STM32L4_CAN_RI0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RI0R_OFFSET); #ifdef CONFIG_CAN_EXTID if ((regval & CAN_RIR_IDE) != 0) @@ -1301,18 +1334,18 @@ static int can_rx0interrupt(int irq, FAR void *context) /* Get the DLC */ - regval = can_getreg(priv, STM32L4_CAN_RDT0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RDT0R_OFFSET); hdr.ch_dlc = (regval & CAN_RDTR_DLC_MASK) >> CAN_RDTR_DLC_SHIFT; /* Save the message data */ - regval = can_getreg(priv, STM32L4_CAN_RDL0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RDL0R_OFFSET); data[0] = (regval & CAN_RDLR_DATA0_MASK) >> CAN_RDLR_DATA0_SHIFT; data[1] = (regval & CAN_RDLR_DATA1_MASK) >> CAN_RDLR_DATA1_SHIFT; data[2] = (regval & CAN_RDLR_DATA2_MASK) >> CAN_RDLR_DATA2_SHIFT; data[3] = (regval & CAN_RDLR_DATA3_MASK) >> CAN_RDLR_DATA3_SHIFT; - regval = can_getreg(priv, STM32L4_CAN_RDH0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RDH0R_OFFSET); data[4] = (regval & CAN_RDHR_DATA4_MASK) >> CAN_RDHR_DATA4_SHIFT; data[5] = (regval & CAN_RDHR_DATA5_MASK) >> CAN_RDHR_DATA5_SHIFT; data[6] = (regval & CAN_RDHR_DATA6_MASK) >> CAN_RDHR_DATA6_SHIFT; @@ -1327,14 +1360,14 @@ static int can_rx0interrupt(int irq, FAR void *context) #ifndef CONFIG_CAN_EXTID errout: #endif - regval = can_getreg(priv, STM32L4_CAN_RF0R_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_RF0R_OFFSET); regval |= CAN_RFR_RFOM; - can_putreg(priv, STM32L4_CAN_RF0R_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_RF0R_OFFSET, regval); return ret; } /**************************************************************************** - * Name: can_txinterrupt + * Name: stm32l4_cantxinterrupt * * Description: * CAN TX mailbox complete interrupt handler @@ -1348,7 +1381,7 @@ errout: * ****************************************************************************/ -static int can_txinterrupt(int irq, FAR void *context) +static int stm32l4_cantxinterrupt(int irq, FAR void *context) { FAR struct can_dev_s *dev = NULL; FAR struct stm32l4_can_s *priv; @@ -1359,7 +1392,7 @@ static int can_txinterrupt(int irq, FAR void *context) /* Get the transmit status */ - regval = can_getreg(priv, STM32L4_CAN_TSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_TSR_OFFSET); /* Check for RQCP0: Request completed mailbox 0 */ @@ -1369,7 +1402,7 @@ static int can_txinterrupt(int irq, FAR void *context) * ALST0 and TERR0) for Mailbox 0. */ - can_putreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP0); + stm32l4_canputreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP0); /* Check for errors */ @@ -1389,7 +1422,7 @@ static int can_txinterrupt(int irq, FAR void *context) * ALST1 and TERR1) for Mailbox 1. */ - can_putreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP1); + stm32l4_canputreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP1); /* Check for errors */ @@ -1409,7 +1442,7 @@ static int can_txinterrupt(int irq, FAR void *context) * ALST2 and TERR2) for Mailbox 2. */ - can_putreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP2); + stm32l4_canputreg(priv, STM32L4_CAN_TSR_OFFSET, CAN_TSR_RQCP2); /* Check for errors */ @@ -1425,7 +1458,7 @@ static int can_txinterrupt(int irq, FAR void *context) } /**************************************************************************** - * Name: can_bittiming + * Name: stm32l4_canbittiming * * Description: * Set the CAN bit timing register (BTR) based on the configured BAUD. @@ -1481,7 +1514,7 @@ static int can_txinterrupt(int irq, FAR void *context) * ****************************************************************************/ -static int can_bittiming(FAR struct stm32l4_can_s *priv) +static int stm32l4_canbittiming(FAR struct stm32l4_can_s *priv) { uint32_t tmp; uint32_t brp; @@ -1561,12 +1594,12 @@ static int can_bittiming(FAR struct stm32l4_can_s *priv) tmp |= CAN_BTR_LBKM; #endif - can_putreg(priv, STM32L4_CAN_BTR_OFFSET, tmp); + stm32l4_canputreg(priv, STM32L4_CAN_BTR_OFFSET, tmp); return OK; } /**************************************************************************** - * Name: can_enterinitmode + * Name: stm32l4_canenterinitmode * * Description: * Put the CAN cell in Initialization mode. This only disconnects the CAN @@ -1581,25 +1614,24 @@ static int can_bittiming(FAR struct stm32l4_can_s *priv) * ****************************************************************************/ -static int can_enterinitmode(FAR struct stm32l4_can_s *priv) +static int stm32l4_canenterinitmode(FAR struct stm32l4_can_s *priv) { uint32_t regval; volatile uint32_t timeout; - int ret; caninfo("CAN%d\n", priv->port); /* Enter initialization mode */ - regval = can_getreg(priv, STM32L4_CAN_MCR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MCR_OFFSET); regval |= CAN_MCR_INRQ; - can_putreg(priv, STM32L4_CAN_MCR_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_MCR_OFFSET, regval); /* Wait until initialization mode is acknowledged */ for (timeout = INAK_TIMEOUT; timeout > 0; timeout--) { - regval = can_getreg(priv, STM32L4_CAN_MSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MSR_OFFSET); if ((regval & CAN_MSR_INAK) != 0) { /* We are in initialization mode */ @@ -1620,7 +1652,7 @@ static int can_enterinitmode(FAR struct stm32l4_can_s *priv) } /**************************************************************************** - * Name: can_exitinitmode + * Name: stm32l4_canexitinitmode * * Description: * Put the CAN cell out of the Initialization mode (to Normal mode) @@ -1633,22 +1665,22 @@ static int can_enterinitmode(FAR struct stm32l4_can_s *priv) * ****************************************************************************/ -static int can_exitinitmode(FAR struct stm32l4_can_s *priv) +static int stm32l4_canexitinitmode(FAR struct stm32l4_can_s *priv) { uint32_t regval; volatile uint32_t timeout; /* Exit Initialization mode, enter Normal mode */ - regval = can_getreg(priv, STM32L4_CAN_MCR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MCR_OFFSET); regval &= ~CAN_MCR_INRQ; - can_putreg(priv, STM32L4_CAN_MCR_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_MCR_OFFSET, regval); /* Wait until the initialization mode exit is acknowledged */ for (timeout = INAK_TIMEOUT; timeout > 0; timeout--) { - regval = can_getreg(priv, STM32L4_CAN_MSR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MSR_OFFSET); if ((regval & CAN_MSR_INAK) == 0) { /* We are out of initialization mode */ @@ -1669,7 +1701,7 @@ static int can_exitinitmode(FAR struct stm32l4_can_s *priv) } /**************************************************************************** - * Name: can_cellinit + * Name: stm32l4_cancellinit * * Description: * CAN cell initialization @@ -1682,7 +1714,7 @@ static int can_exitinitmode(FAR struct stm32l4_can_s *priv) * ****************************************************************************/ -static int can_cellinit(FAR struct stm32l4_can_s *priv) +static int stm32l4_cancellinit(FAR struct stm32l4_can_s *priv) { uint32_t regval; int ret; @@ -1691,16 +1723,16 @@ static int can_cellinit(FAR struct stm32l4_can_s *priv) /* Exit from sleep mode */ - regval = can_getreg(priv, STM32L4_CAN_MCR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MCR_OFFSET); regval &= ~CAN_MCR_SLEEP; - can_putreg(priv, STM32L4_CAN_MCR_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_MCR_OFFSET, regval); /* Configure CAN behavior. Priority driven request order, not message ID. */ regval |= CAN_MCR_TXFP; - can_putreg(priv, STM32L4_CAN_MCR_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_MCR_OFFSET, regval); - ret = can_enterinitmode(priv); + ret = stm32l4_canenterinitmode(priv); if(ret != 0) { return ret; @@ -1716,25 +1748,25 @@ static int can_cellinit(FAR struct stm32l4_can_s *priv) * - Transmit FIFO priority */ - regval = can_getreg(priv, STM32L4_CAN_MCR_OFFSET); + regval = stm32l4_cangetreg(priv, STM32L4_CAN_MCR_OFFSET); regval &= ~(CAN_MCR_TXFP | CAN_MCR_RFLM | CAN_MCR_NART | CAN_MCR_AWUM | CAN_MCR_ABOM | CAN_MCR_TTCM); - can_putreg(priv, STM32L4_CAN_MCR_OFFSET, regval); + stm32l4_canputreg(priv, STM32L4_CAN_MCR_OFFSET, regval); /* Configure bit timing. */ - ret = can_bittiming(priv); + ret = stm32l4_canbittiming(priv); if (ret < 0) { canerr("ERROR: Failed to set bit timing: %d\n", ret); return ret; } - return can_exitinitmode(priv); + return stm32l4_canexitinitmode(priv); } /**************************************************************************** - * Name: can_filterinit + * Name: stm32l4_canfilterinit * * Description: * CAN filter initialization. CAN filters are not currently used by this @@ -1765,7 +1797,7 @@ static int can_cellinit(FAR struct stm32l4_can_s *priv) * ****************************************************************************/ -static int can_filterinit(FAR struct stm32l4_can_s *priv) +static int stm32l4_canfilterinit(FAR struct stm32l4_can_s *priv) { uint32_t regval; uint32_t bitmask; @@ -1778,57 +1810,57 @@ static int can_filterinit(FAR struct stm32l4_can_s *priv) /* Enter filter initialization mode */ - regval = can_getfreg(priv, STM32L4_CAN_FMR_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FMR_OFFSET); regval |= CAN_FMR_FINIT; - can_putfreg(priv, STM32L4_CAN_FMR_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FMR_OFFSET, regval); /* Disable the filter */ - regval = can_getfreg(priv, STM32L4_CAN_FA1R_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FA1R_OFFSET); regval &= ~bitmask; - can_putfreg(priv, STM32L4_CAN_FA1R_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FA1R_OFFSET, regval); /* Select the 32-bit scale for the filter */ - regval = can_getfreg(priv, STM32L4_CAN_FS1R_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FS1R_OFFSET); regval |= bitmask; - can_putfreg(priv, STM32L4_CAN_FS1R_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FS1R_OFFSET, regval); /* There are 14 or 28 filter banks (depending) on the device. Each filter bank is * composed of two 32-bit registers, CAN_FiR: */ - can_putfreg(priv, STM32L4_CAN_FIR_OFFSET(priv->filter, 1), 0); - can_putfreg(priv, STM32L4_CAN_FIR_OFFSET(priv->filter, 2), 0); + stm32l4_canputfreg(priv, STM32L4_CAN_FIR_OFFSET(priv->filter, 1), 0); + stm32l4_canputfreg(priv, STM32L4_CAN_FIR_OFFSET(priv->filter, 2), 0); /* Set Id/Mask mode for the filter */ - regval = can_getfreg(priv, STM32L4_CAN_FM1R_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FM1R_OFFSET); regval &= ~bitmask; - can_putfreg(priv, STM32L4_CAN_FM1R_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FM1R_OFFSET, regval); /* Assign FIFO 0 for the filter */ - regval = can_getfreg(priv, STM32L4_CAN_FFA1R_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FFA1R_OFFSET); regval &= ~bitmask; - can_putfreg(priv, STM32L4_CAN_FFA1R_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FFA1R_OFFSET, regval); /* Enable the filter */ - regval = can_getfreg(priv, STM32L4_CAN_FA1R_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FA1R_OFFSET); regval |= bitmask; - can_putfreg(priv, STM32L4_CAN_FA1R_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FA1R_OFFSET, regval); /* Exit filter initialization mode */ - regval = can_getfreg(priv, STM32L4_CAN_FMR_OFFSET); + regval = stm32l4_cangetfreg(priv, STM32L4_CAN_FMR_OFFSET); regval &= ~CAN_FMR_FINIT; - can_putfreg(priv, STM32L4_CAN_FMR_OFFSET, regval); + stm32l4_canputfreg(priv, STM32L4_CAN_FMR_OFFSET, regval); return OK; } /**************************************************************************** - * Name: stm32l4_can_addextfilter + * Name: stm32l4_canaddextfilter * * Description: * Add a filter for extended CAN IDs @@ -1844,14 +1876,14 @@ static int can_filterinit(FAR struct stm32l4_can_s *priv) * ****************************************************************************/ -static int stm32l4_can_addextfilter(FAR struct stm32l4_can_s *priv, - FAR struct canioc_extfilter_s *arg) +static int stm32l4_canaddextfilter(FAR struct stm32l4_can_s *priv, + FAR struct canioc_extfilter_s *arg) { return -ENOTTY; } /**************************************************************************** - * Name: stm32l4_can_delextfilter + * Name: stm32l4_candelextfilter * * Description: * Remove a filter for extended CAN IDs @@ -1868,13 +1900,13 @@ static int stm32l4_can_addextfilter(FAR struct stm32l4_can_s *priv, * ****************************************************************************/ -static int stm32l4_can_delextfilter(FAR struct stm32l4_can_s *priv, int arg) +static int stm32l4_candelextfilter(FAR struct stm32l4_can_s *priv, int arg) { return -ENOTTY; } /**************************************************************************** - * Name: stm32l4_can_addextfilter + * Name: stm32l4_canaddextfilter * * Description: * Add a filter for standard CAN IDs @@ -1890,14 +1922,14 @@ static int stm32l4_can_delextfilter(FAR struct stm32l4_can_s *priv, int arg) * ****************************************************************************/ -static int stm32l4_can_addstdfilter(FAR struct stm32l4_can_s *priv, - FAR struct canioc_stdfilter_s *arg) +static int stm32l4_canaddstdfilter(FAR struct stm32l4_can_s *priv, + FAR struct canioc_stdfilter_s *arg) { return -ENOTTY; } /**************************************************************************** - * Name: stm32l4_can_delstdfilter + * Name: stm32l4_candelstdfilter * * Description: * Remove a filter for standard CAN IDs @@ -1914,7 +1946,7 @@ static int stm32l4_can_addstdfilter(FAR struct stm32l4_can_s *priv, * ****************************************************************************/ -static int stm32l4_can_delstdfilter(FAR struct stm32l4_can_s *priv, int arg) +static int stm32l4_candelstdfilter(FAR struct stm32l4_can_s *priv, int arg) { return -ENOTTY; }