| Message ID | 20210725161150.11801-5-dariobin@libero.it |
|---|---|
| State | New |
| Headers | show |
| Series | can: c_can: cache frames to operate as a true FIFO | expand |
On 25.07.2021 18:11:50, Dario Binacchi wrote: > As reported by a comment in the c_can_start_xmit() this was not a FIFO. > C/D_CAN controller sends out the buffers prioritized so that the lowest > buffer number wins. > > What did c_can_start_xmit() do if head was less tail in the tx ring ? It > waited until all the frames queued in the FIFO was actually transmitted > by the controller before accepting a new CAN frame to transmit, even if > the FIFO was not full, to ensure that the messages were transmitted in > the order in which they were loaded. > > By storing the frames in the FIFO without requiring its transmission, we > will be able to use the full size of the FIFO even in cases such as the > one described above. The transmission interrupt will trigger their > transmission only when all the messages previously loaded but stored in > less priority positions of the buffers have been transmitted. > > Suggested-by: Gianluca Falavigna <gianluca.falavigna@inwind.it> > Signed-off-by: Dario Binacchi <dariobin@libero.it> > > --- > > drivers/net/can/c_can/c_can.h | 6 +++++ > drivers/net/can/c_can/c_can_main.c | 42 +++++++++++++++++------------- > 2 files changed, 30 insertions(+), 18 deletions(-) > > diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h > index 8fe7e2138620..fc499a70b797 100644 > --- a/drivers/net/can/c_can/c_can.h > +++ b/drivers/net/can/c_can/c_can.h > +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > +{ > + return ring->obj_num - (ring->head - ring->tail); > +} > + > #endif /* C_CAN_H */ > diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c > index 451ac9a9586a..4c061fef002c 100644 > --- a/drivers/net/can/c_can/c_can_main.c > +++ b/drivers/net/can/c_can/c_can_main.c > @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, > c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); > } > > -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > -{ > - u8 head = c_can_get_tx_head(ring); > - u8 tail = c_can_get_tx_tail(ring); > - > - /* This is not a FIFO. C/D_CAN sends out the buffers > - * prioritized. The lowest buffer number wins. > - */ > - if (head < tail) > - return 0; > - > - return ring->obj_num - head; > -} > - Can you move that change into patch 3? Marc -- Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung West/Dortmund | Phone: +49-231-2826-924 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
On 25.07.2021 18:11:50, Dario Binacchi wrote: > diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h > index 8fe7e2138620..fc499a70b797 100644 > --- a/drivers/net/can/c_can/c_can.h > +++ b/drivers/net/can/c_can/c_can.h > @@ -200,6 +200,7 @@ struct c_can_priv { > atomic_t sie_pending; > unsigned long tx_dir; > int last_status; > + spinlock_t tx_lock; What does the spin lock protect? > struct c_can_tx_ring tx; > u16 (*read_reg)(const struct c_can_priv *priv, enum reg index); > void (*write_reg)(const struct c_can_priv *priv, enum reg index, u16 val); > @@ -236,4 +237,9 @@ static inline u8 c_can_get_tx_tail(const struct c_can_tx_ring *ring) > return ring->tail & (ring->obj_num - 1); > } > > +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > +{ > + return ring->obj_num - (ring->head - ring->tail); > +} > + > #endif /* C_CAN_H */ > diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c > index 451ac9a9586a..4c061fef002c 100644 > --- a/drivers/net/can/c_can/c_can_main.c > +++ b/drivers/net/can/c_can/c_can_main.c > @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, > c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); > } > > -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > -{ > - u8 head = c_can_get_tx_head(ring); > - u8 tail = c_can_get_tx_tail(ring); > - > - /* This is not a FIFO. C/D_CAN sends out the buffers > - * prioritized. The lowest buffer number wins. > - */ > - if (head < tail) > - return 0; > - > - return ring->obj_num - head; > -} > - > static bool c_can_tx_busy(const struct c_can_priv *priv, > const struct c_can_tx_ring *tx_ring) > { > @@ -470,7 +456,7 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > struct can_frame *frame = (struct can_frame *)skb->data; > struct c_can_priv *priv = netdev_priv(dev); > struct c_can_tx_ring *tx_ring = &priv->tx; > - u32 idx, obj; > + u32 idx, obj, cmd = IF_COMM_TX; > > if (can_dropped_invalid_skb(dev, skb)) > return NETDEV_TX_OK; > @@ -483,7 +469,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > if (c_can_get_tx_free(tx_ring) == 0) > netif_stop_queue(dev); > > - obj = idx + priv->msg_obj_tx_first; > + spin_lock_bh(&priv->tx_lock); What does the spin_lock protect? The ndo_start_xmit function is properly serialized by the networking core. Otherwise the patch looks good! Marc -- Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung West/Dortmund | Phone: +49-231-2826-924 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
Hi Marc, > Il 04/08/2021 11:34 Marc Kleine-Budde <mkl@pengutronix.de> ha scritto: > > > On 25.07.2021 18:11:50, Dario Binacchi wrote: > > As reported by a comment in the c_can_start_xmit() this was not a FIFO. > > C/D_CAN controller sends out the buffers prioritized so that the lowest > > buffer number wins. > > > > What did c_can_start_xmit() do if head was less tail in the tx ring ? It > > waited until all the frames queued in the FIFO was actually transmitted > > by the controller before accepting a new CAN frame to transmit, even if > > the FIFO was not full, to ensure that the messages were transmitted in > > the order in which they were loaded. > > > > By storing the frames in the FIFO without requiring its transmission, we > > will be able to use the full size of the FIFO even in cases such as the > > one described above. The transmission interrupt will trigger their > > transmission only when all the messages previously loaded but stored in > > less priority positions of the buffers have been transmitted. > > > > Suggested-by: Gianluca Falavigna <gianluca.falavigna@inwind.it> > > Signed-off-by: Dario Binacchi <dariobin@libero.it> > > > > --- > > > > drivers/net/can/c_can/c_can.h | 6 +++++ > > drivers/net/can/c_can/c_can_main.c | 42 +++++++++++++++++------------- > > 2 files changed, 30 insertions(+), 18 deletions(-) > > > > diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h > > index 8fe7e2138620..fc499a70b797 100644 > > --- a/drivers/net/can/c_can/c_can.h > > +++ b/drivers/net/can/c_can/c_can.h > > +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > +{ > > + return ring->obj_num - (ring->head - ring->tail); > > +} > > + > > #endif /* C_CAN_H */ > > diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c > > index 451ac9a9586a..4c061fef002c 100644 > > --- a/drivers/net/can/c_can/c_can_main.c > > +++ b/drivers/net/can/c_can/c_can_main.c > > @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, > > c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); > > } > > > > -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > -{ > > - u8 head = c_can_get_tx_head(ring); > > - u8 tail = c_can_get_tx_tail(ring); > > - > > - /* This is not a FIFO. C/D_CAN sends out the buffers > > - * prioritized. The lowest buffer number wins. > > - */ > > - if (head < tail) > > - return 0; > > - > > - return ring->obj_num - head; > > -} > > - > > Can you move that change into patch 3? Patch 3 adds the ring transmission algorithm without compromising the message transmission order. This is not a FIFO. C/D_CAN controller sends out the buffers prioritized. The lowest buffer number wins, so moving the change into patch 3 may not guarantee the transmission order. In patch 3, however, I will move c_can_get_tx_free() from c_can_main.c to c_can.h, so that in patch 4 it will be clearer how the routine has changed. Thanks and regards, Dario > > Marc > > -- > Pengutronix e.K. | Marc Kleine-Budde | > Embedded Linux | https://www.pengutronix.de | > Vertretung West/Dortmund | Phone: +49-231-2826-924 | > Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
Hi Marc, > Il 04/08/2021 11:45 Marc Kleine-Budde <mkl@pengutronix.de> ha scritto: > > > On 25.07.2021 18:11:50, Dario Binacchi wrote: > > diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h > > index 8fe7e2138620..fc499a70b797 100644 > > --- a/drivers/net/can/c_can/c_can.h > > +++ b/drivers/net/can/c_can/c_can.h > > @@ -200,6 +200,7 @@ struct c_can_priv { > > atomic_t sie_pending; > > unsigned long tx_dir; > > int last_status; > > + spinlock_t tx_lock; > > What does the spin lock protect? > > > struct c_can_tx_ring tx; > > u16 (*read_reg)(const struct c_can_priv *priv, enum reg index); > > void (*write_reg)(const struct c_can_priv *priv, enum reg index, u16 val); > > @@ -236,4 +237,9 @@ static inline u8 c_can_get_tx_tail(const struct c_can_tx_ring *ring) > > return ring->tail & (ring->obj_num - 1); > > } > > > > +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > +{ > > + return ring->obj_num - (ring->head - ring->tail); > > +} > > + > > #endif /* C_CAN_H */ > > diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c > > index 451ac9a9586a..4c061fef002c 100644 > > --- a/drivers/net/can/c_can/c_can_main.c > > +++ b/drivers/net/can/c_can/c_can_main.c > > @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, > > c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); > > } > > > > -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > -{ > > - u8 head = c_can_get_tx_head(ring); > > - u8 tail = c_can_get_tx_tail(ring); > > - > > - /* This is not a FIFO. C/D_CAN sends out the buffers > > - * prioritized. The lowest buffer number wins. > > - */ > > - if (head < tail) > > - return 0; > > - > > - return ring->obj_num - head; > > -} > > - > > static bool c_can_tx_busy(const struct c_can_priv *priv, > > const struct c_can_tx_ring *tx_ring) > > { > > @@ -470,7 +456,7 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > > struct can_frame *frame = (struct can_frame *)skb->data; > > struct c_can_priv *priv = netdev_priv(dev); > > struct c_can_tx_ring *tx_ring = &priv->tx; > > - u32 idx, obj; > > + u32 idx, obj, cmd = IF_COMM_TX; > > > > if (can_dropped_invalid_skb(dev, skb)) > > return NETDEV_TX_OK; > > @@ -483,7 +469,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > > if (c_can_get_tx_free(tx_ring) == 0) > > netif_stop_queue(dev); > > > > - obj = idx + priv->msg_obj_tx_first; > > + spin_lock_bh(&priv->tx_lock); > > What does the spin_lock protect? The ndo_start_xmit function is properly > serialized by the networking core. > The spin_lock protects the access to the IF_TX interface. Enabling the transmission of cached messages occur inside interrupt and the use of the IF_RX interface, which would avoid the use of the spinlock, has not been validated by the tests. Thanks and regards, Dario > Otherwise the patch looks good! > > Marc > > -- > Pengutronix e.K. | Marc Kleine-Budde | > Embedded Linux | https://www.pengutronix.de | > Vertretung West/Dortmund | Phone: +49-231-2826-924 | > Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
On 05.08.2021 22:12:18, Dario Binacchi wrote: > > > diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h > > > index 8fe7e2138620..fc499a70b797 100644 > > > --- a/drivers/net/can/c_can/c_can.h > > > +++ b/drivers/net/can/c_can/c_can.h > > > +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > > +{ > > > + return ring->obj_num - (ring->head - ring->tail); > > > +} > > > + > > > #endif /* C_CAN_H */ > > > diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c > > > index 451ac9a9586a..4c061fef002c 100644 > > > --- a/drivers/net/can/c_can/c_can_main.c > > > +++ b/drivers/net/can/c_can/c_can_main.c > > > @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, > > > c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); > > > } > > > > > > -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) > > > -{ > > > - u8 head = c_can_get_tx_head(ring); > > > - u8 tail = c_can_get_tx_tail(ring); > > > - > > > - /* This is not a FIFO. C/D_CAN sends out the buffers > > > - * prioritized. The lowest buffer number wins. > > > - */ > > > - if (head < tail) > > > - return 0; > > > - > > > - return ring->obj_num - head; > > > -} > > > - > > > > Can you move that change into patch 3? > > Patch 3 adds the ring transmission algorithm without compromising the > message transmission order. This is not a FIFO. Right, thanks! > C/D_CAN controller sends out the buffers prioritized. The lowest > buffer number wins, so moving the change into patch 3 may not > guarantee the transmission order. In patch 3, however, I will move > c_can_get_tx_free() from c_can_main.c to c_can.h, so that in patch 4 > it will be clearer how the routine has changed. The updated patch looks much nicer now, thanks! Marc -- Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung West/Dortmund | Phone: +49-231-2826-924 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
On 05.08.2021 22:16:06, Dario Binacchi wrote: > > > --- a/drivers/net/can/c_can/c_can.h > > > +++ b/drivers/net/can/c_can/c_can.h > > > @@ -200,6 +200,7 @@ struct c_can_priv { > > > atomic_t sie_pending; > > > unsigned long tx_dir; > > > int last_status; > > > + spinlock_t tx_lock; > > > > What does the spin lock protect? [...] > > > @@ -483,7 +469,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > > > if (c_can_get_tx_free(tx_ring) == 0) > > > netif_stop_queue(dev); > > > > > > - obj = idx + priv->msg_obj_tx_first; > > > + spin_lock_bh(&priv->tx_lock); > > > > What does the spin_lock protect? The ndo_start_xmit function is properly > > serialized by the networking core. > > > > The spin_lock protects the access to the IF_TX interface. How? You only use the spin_lock in c_can_start_xmit(), but not anywhere else. > Enabling the transmission of cached messages occur inside interrupt The call chain is c_can_poll() -> c_can_do_tx(), and c_can_poll() is called from NAPI, which is not the IRQ handler. > and the use of the IF_RX interface, which would avoid the use of the > spinlock, has not been validated by the tests. What do you mean be has not been validated? The driver already uses IF_RX to avoid concurrent access in c_can_do_tx() for c_can_inval_tx_object() [1], why not use IF_RX for c_can_object_put(), too? [1] https://lore.kernel.org/r/20210302215435.18286-4-dariobin@libero.it Marc -- Pengutronix e.K. | Marc Kleine-Budde | Embedded Linux | https://www.pengutronix.de | Vertretung West/Dortmund | Phone: +49-231-2826-924 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
> Il 06/08/2021 11:25 Marc Kleine-Budde <mkl@pengutronix.de> ha scritto: > > > On 05.08.2021 22:16:06, Dario Binacchi wrote: > > > > --- a/drivers/net/can/c_can/c_can.h > > > > +++ b/drivers/net/can/c_can/c_can.h > > > > @@ -200,6 +200,7 @@ struct c_can_priv { > > > > atomic_t sie_pending; > > > > unsigned long tx_dir; > > > > int last_status; > > > > + spinlock_t tx_lock; > > > > > > What does the spin lock protect? > [...] > > > > @@ -483,7 +469,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, > > > > if (c_can_get_tx_free(tx_ring) == 0) > > > > netif_stop_queue(dev); > > > > > > > > - obj = idx + priv->msg_obj_tx_first; > > > > + spin_lock_bh(&priv->tx_lock); > > > > > > What does the spin_lock protect? The ndo_start_xmit function is properly > > > serialized by the networking core. > > > > > > > The spin_lock protects the access to the IF_TX interface. > > How? You only use the spin_lock in c_can_start_xmit(), but not anywhere > else. > > > Enabling the transmission of cached messages occur inside interrupt > > The call chain is c_can_poll() -> c_can_do_tx(), and c_can_poll() is > called from NAPI, which is not the IRQ handler. > > > and the use of the IF_RX interface, which would avoid the use of the > > spinlock, has not been validated by the tests. > > What do you mean be has not been validated? It's been a while since I submitted the series and I certainly got confused. > > The driver already uses IF_RX to avoid concurrent access in > c_can_do_tx() for c_can_inval_tx_object() [1], why not use IF_RX for > c_can_object_put(), too? > > [1] https://lore.kernel.org/r/20210302215435.18286-4-dariobin@libero.it Right! Thanks and Regards, Dario > > Marc > > -- > Pengutronix e.K. | Marc Kleine-Budde | > Embedded Linux | https://www.pengutronix.de | > Vertretung West/Dortmund | Phone: +49-231-2826-924 | > Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
diff --git a/drivers/net/can/c_can/c_can.h b/drivers/net/can/c_can/c_can.h index 8fe7e2138620..fc499a70b797 100644 --- a/drivers/net/can/c_can/c_can.h +++ b/drivers/net/can/c_can/c_can.h @@ -200,6 +200,7 @@ struct c_can_priv { atomic_t sie_pending; unsigned long tx_dir; int last_status; + spinlock_t tx_lock; struct c_can_tx_ring tx; u16 (*read_reg)(const struct c_can_priv *priv, enum reg index); void (*write_reg)(const struct c_can_priv *priv, enum reg index, u16 val); @@ -236,4 +237,9 @@ static inline u8 c_can_get_tx_tail(const struct c_can_tx_ring *ring) return ring->tail & (ring->obj_num - 1); } +static inline u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) +{ + return ring->obj_num - (ring->head - ring->tail); +} + #endif /* C_CAN_H */ diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c index 451ac9a9586a..4c061fef002c 100644 --- a/drivers/net/can/c_can/c_can_main.c +++ b/drivers/net/can/c_can/c_can_main.c @@ -427,20 +427,6 @@ static void c_can_setup_receive_object(struct net_device *dev, int iface, c_can_object_put(dev, iface, obj, IF_COMM_RCV_SETUP); } -static u8 c_can_get_tx_free(const struct c_can_tx_ring *ring) -{ - u8 head = c_can_get_tx_head(ring); - u8 tail = c_can_get_tx_tail(ring); - - /* This is not a FIFO. C/D_CAN sends out the buffers - * prioritized. The lowest buffer number wins. - */ - if (head < tail) - return 0; - - return ring->obj_num - head; -} - static bool c_can_tx_busy(const struct c_can_priv *priv, const struct c_can_tx_ring *tx_ring) { @@ -470,7 +456,7 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, struct can_frame *frame = (struct can_frame *)skb->data; struct c_can_priv *priv = netdev_priv(dev); struct c_can_tx_ring *tx_ring = &priv->tx; - u32 idx, obj; + u32 idx, obj, cmd = IF_COMM_TX; if (can_dropped_invalid_skb(dev, skb)) return NETDEV_TX_OK; @@ -483,7 +469,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, if (c_can_get_tx_free(tx_ring) == 0) netif_stop_queue(dev); - obj = idx + priv->msg_obj_tx_first; + spin_lock_bh(&priv->tx_lock); + if (idx < c_can_get_tx_tail(tx_ring)) + cmd &= ~IF_COMM_TXRQST; /* Cache the message */ + else + spin_unlock_bh(&priv->tx_lock); /* Store the message in the interface so we can call * can_put_echo_skb(). We must do this before we enable @@ -492,9 +482,11 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb, c_can_setup_tx_object(dev, IF_TX, frame, idx); priv->dlc[idx] = frame->len; can_put_echo_skb(skb, dev, idx, 0); + obj = idx + priv->msg_obj_tx_first; + c_can_object_put(dev, IF_TX, obj, cmd); - /* Start transmission */ - c_can_object_put(dev, IF_TX, obj, IF_COMM_TX); + if (spin_is_locked(&priv->tx_lock)) + spin_unlock_bh(&priv->tx_lock); return NETDEV_TX_OK; } @@ -739,6 +731,7 @@ static void c_can_do_tx(struct net_device *dev) struct c_can_tx_ring *tx_ring = &priv->tx; struct net_device_stats *stats = &dev->stats; u32 idx, obj, pkts = 0, bytes = 0, pend; + u8 tail; if (priv->msg_obj_tx_last > 32) pend = priv->read_reg32(priv, C_CAN_INTPND3_REG); @@ -775,6 +768,18 @@ static void c_can_do_tx(struct net_device *dev) stats->tx_bytes += bytes; stats->tx_packets += pkts; can_led_event(dev, CAN_LED_EVENT_TX); + + tail = c_can_get_tx_tail(tx_ring); + + if (tail == 0) { + u8 head = c_can_get_tx_head(tx_ring); + + /* Start transmission for all cached messages */ + for (idx = tail; idx < head; idx++) { + obj = idx + priv->msg_obj_tx_first; + c_can_object_put(dev, IF_TX, obj, IF_COMM_TXRQST); + } + } } /* If we have a gap in the pending bits, that means we either @@ -1237,6 +1242,7 @@ struct net_device *alloc_c_can_dev(int msg_obj_num) return NULL; priv = netdev_priv(dev); + spin_lock_init(&priv->tx_lock); priv->msg_obj_num = msg_obj_num; priv->msg_obj_rx_num = msg_obj_num - msg_obj_tx_num; priv->msg_obj_rx_first = 1;
As reported by a comment in the c_can_start_xmit() this was not a FIFO. C/D_CAN controller sends out the buffers prioritized so that the lowest buffer number wins. What did c_can_start_xmit() do if head was less tail in the tx ring ? It waited until all the frames queued in the FIFO was actually transmitted by the controller before accepting a new CAN frame to transmit, even if the FIFO was not full, to ensure that the messages were transmitted in the order in which they were loaded. By storing the frames in the FIFO without requiring its transmission, we will be able to use the full size of the FIFO even in cases such as the one described above. The transmission interrupt will trigger their transmission only when all the messages previously loaded but stored in less priority positions of the buffers have been transmitted. Suggested-by: Gianluca Falavigna <gianluca.falavigna@inwind.it> Signed-off-by: Dario Binacchi <dariobin@libero.it> --- drivers/net/can/c_can/c_can.h | 6 +++++ drivers/net/can/c_can/c_can_main.c | 42 +++++++++++++++++------------- 2 files changed, 30 insertions(+), 18 deletions(-)