Merge tag 'linux-can-next-for-5.13-20210330' of... (9c0ee085) · Commits · EulixOS / Software / Kernel

MAINTAINERS

+1 −9

Original line number	Diff line number	Diff line
		@@ -10910,8 +10910,7 @@ T: git git://linuxtv.org/media_tree.git
		F: drivers/media/radio/radio-maxiradio*

		MCAN MMIO DEVICE DRIVER
		M: Dan Murphy <dmurphy@ti.com>
		M: Pankaj Sharma <pankj.sharma@samsung.com>
		M: Chandrasekar Ramakrishnan <rcsekar@samsung.com>
		L: linux-can@vger.kernel.org
		S: Maintained
		F: Documentation/devicetree/bindings/net/can/bosch,m_can.yaml
		@@ -17983,13 +17982,6 @@ L: alsa-devel@alsa-project.org (moderated for non-subscribers)
		S: Odd Fixes
		F: sound/soc/codecs/tas571x*

		TI TCAN4X5X DEVICE DRIVER
		M: Dan Murphy <dmurphy@ti.com>
		L: linux-can@vger.kernel.org
		S: Maintained
		F: Documentation/devicetree/bindings/net/can/tcan4x5x.txt
		F: drivers/net/can/m_can/tcan4x5x*

		TI TRF7970A NFC DRIVER
		M: Mark Greer <mgreer@animalcreek.com>
		L: linux-wireless@vger.kernel.org

drivers/net/can/Kconfig

+1 −1

Original line number	Diff line number	Diff line
		@@ -103,7 +103,7 @@ config CAN_FLEXCAN

		config CAN_GRCAN
		tristate "Aeroflex Gaisler GRCAN and GRHCAN CAN devices"
		depends on OF && HAS_DMA
		depends on OF && HAS_DMA && HAS_IOMEM
		help
		Say Y here if you want to use Aeroflex Gaisler GRCAN or GRHCAN.
		Note that the driver supports little endian, even though little

drivers/net/can/c_can/c_can.c

+77 −76

Original line number	Diff line number	Diff line
		@@ -132,7 +132,6 @@
		/* For the high buffers we clear the interrupt bit and newdat */
		#define IF_COMM_RCV_HIGH (IF_COMM_RCV_LOW \| IF_COMM_CLR_NEWDAT)


		/* Receive setup of message objects */
		#define IF_COMM_RCV_SETUP (IF_COMM_MASK \| IF_COMM_ARB \| IF_COMM_CONTROL)

		@@ -161,9 +160,7 @@

		#define IF_MCONT_TX (IF_MCONT_TXIE \| IF_MCONT_EOB)

		/*
		* Use IF1 for RX and IF2 for TX
		*/
		/* Use IF1 for RX and IF2 for TX */
		#define IF_RX 0
		#define IF_TX 1

		@@ -173,9 +170,6 @@
		/* Wait for ~1 sec for INIT bit */
		#define INIT_WAIT_MS 1000

		/* napi related */
		#define C_CAN_NAPI_WEIGHT C_CAN_MSG_OBJ_RX_NUM

		/* c_can lec values */
		enum c_can_lec_type {
		LEC_NO_ERROR = 0,
		@@ -189,8 +183,7 @@ enum c_can_lec_type {
		LEC_MASK = LEC_UNUSED,
		};

		/*
		* c_can error types:
		/* c_can error types:
		* Bus errors (BUS_OFF, ERROR_WARNING, ERROR_PASSIVE) are supported
		*/
		enum c_can_bus_error_types {
		@@ -253,7 +246,6 @@ static void c_can_obj_update(struct net_device *dev, int iface, u32 cmd, u32 obj
		udelay(1);
		}
		netdev_err(dev, "Updating object timed out\n");

		}

		static inline void c_can_object_get(struct net_device *dev, int iface,
		@@ -268,8 +260,7 @@ static inline void c_can_object_put(struct net_device *dev, int iface,
		c_can_obj_update(dev, iface, cmd \| IF_COMM_WR, obj);
		}

		/*
		* Note: According to documentation clearing TXIE while MSGVAL is set
		/* Note: According to documentation clearing TXIE while MSGVAL is set
		* is not allowed, but works nicely on C/DCAN. And that lowers the I/O
		* load significantly.
		*/
		@@ -285,8 +276,7 @@ static void c_can_inval_msg_object(struct net_device *dev, int iface, int obj)
		{
		struct c_can_priv *priv = netdev_priv(dev);

		priv->write_reg(priv, C_CAN_IFACE(ARB1_REG, iface), 0);
		priv->write_reg(priv, C_CAN_IFACE(ARB2_REG, iface), 0);
		priv->write_reg32(priv, C_CAN_IFACE(ARB1_REG, iface), 0);
		c_can_inval_tx_object(dev, iface, obj);
		}

		@@ -309,12 +299,11 @@ static void c_can_setup_tx_object(struct net_device *dev, int iface,
		if (!rtr)
		arb \|= IF_ARB_TRANSMIT;

		/*
		* If we change the DIR bit, we need to invalidate the buffer
		/* If we change the DIR bit, we need to invalidate the buffer
		* first, i.e. clear the MSGVAL flag in the arbiter.
		*/
		if (rtr != (bool)test_bit(idx, &priv->tx_dir)) {
		u32 obj = idx + C_CAN_MSG_OBJ_TX_FIRST;
		u32 obj = idx + priv->msg_obj_tx_first;

		c_can_inval_msg_object(dev, iface, obj);
		change_bit(idx, &priv->tx_dir);
		@@ -447,18 +436,16 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb,

		if (can_dropped_invalid_skb(dev, skb))
		return NETDEV_TX_OK;
		/*
		* This is not a FIFO. C/D_CAN sends out the buffers
		/* This is not a FIFO. C/D_CAN sends out the buffers
		* prioritized. The lowest buffer number wins.
		*/
		idx = fls(atomic_read(&priv->tx_active));
		obj = idx + C_CAN_MSG_OBJ_TX_FIRST;
		obj = idx + priv->msg_obj_tx_first;

		/* If this is the last buffer, stop the xmit queue */
		if (idx == C_CAN_MSG_OBJ_TX_NUM - 1)
		if (idx == priv->msg_obj_tx_num - 1)
		netif_stop_queue(dev);
		/*
		* Store the message in the interface so we can call
		/* Store the message in the interface so we can call
		* can_put_echo_skb(). We must do this before we enable
		* transmit as we might race against do_tx().
		*/
		@@ -467,7 +454,7 @@ static netdev_tx_t c_can_start_xmit(struct sk_buff *skb,
		can_put_echo_skb(skb, dev, idx, 0);

		/* Update the active bits */
		atomic_add((1 << idx), &priv->tx_active);
		atomic_add(BIT(idx), &priv->tx_active);
		/* Start transmission */
		c_can_object_put(dev, IF_TX, obj, IF_COMM_TX);

		@@ -527,8 +514,7 @@ static int c_can_set_bittiming(struct net_device *dev)
		return c_can_wait_for_ctrl_init(dev, priv, 0);
		}

		/*
		* Configure C_CAN message objects for Tx and Rx purposes:
		/* Configure C_CAN message objects for Tx and Rx purposes:
		* C_CAN provides a total of 32 message objects that can be configured
		* either for Tx or Rx purposes. Here the first 16 message objects are used as
		* a reception FIFO. The end of reception FIFO is signified by the EoB bit
		@@ -538,17 +524,18 @@ static int c_can_set_bittiming(struct net_device *dev)
		*/
		static void c_can_configure_msg_objects(struct net_device *dev)
		{
		struct c_can_priv *priv = netdev_priv(dev);
		int i;

		/* first invalidate all message objects */
		for (i = C_CAN_MSG_OBJ_RX_FIRST; i <= C_CAN_NO_OF_OBJECTS; i++)
		for (i = priv->msg_obj_rx_first; i <= priv->msg_obj_num; i++)
		c_can_inval_msg_object(dev, IF_RX, i);

		/* setup receive message objects */
		for (i = C_CAN_MSG_OBJ_RX_FIRST; i < C_CAN_MSG_OBJ_RX_LAST; i++)
		for (i = priv->msg_obj_rx_first; i < priv->msg_obj_rx_last; i++)
		c_can_setup_receive_object(dev, IF_RX, i, 0, 0, IF_MCONT_RCV);

		c_can_setup_receive_object(dev, IF_RX, C_CAN_MSG_OBJ_RX_LAST, 0, 0,
		c_can_setup_receive_object(dev, IF_RX, priv->msg_obj_rx_last, 0, 0,
		IF_MCONT_RCV_EOB);
		}

		@@ -572,8 +559,7 @@ static int c_can_software_reset(struct net_device *dev)
		return 0;
		}

		/*
		* Configure C_CAN chip:
		/* Configure C_CAN chip:
		* - enable/disable auto-retransmission
		* - set operating mode
		* - configure message objects
		@@ -714,12 +700,21 @@ static void c_can_do_tx(struct net_device *dev)
		struct net_device_stats *stats = &dev->stats;
		u32 idx, obj, pkts = 0, bytes = 0, pend, clr;

		clr = pend = priv->read_reg(priv, C_CAN_INTPND2_REG);
		if (priv->msg_obj_tx_last > 32)
		pend = priv->read_reg32(priv, C_CAN_INTPND3_REG);
		else
		pend = priv->read_reg(priv, C_CAN_INTPND2_REG);
		clr = pend;

		while ((idx = ffs(pend))) {
		idx--;
		pend &= ~(1 << idx);
		obj = idx + C_CAN_MSG_OBJ_TX_FIRST;
		pend &= ~BIT(idx);
		obj = idx + priv->msg_obj_tx_first;

		/* We use IF_RX interface instead of IF_TX because we
		* are called from c_can_poll(), which runs inside
		* NAPI. We are not trasmitting.
		*/
		c_can_inval_tx_object(dev, IF_RX, obj);
		can_get_echo_skb(dev, idx, NULL);
		bytes += priv->dlc[idx];
		@@ -729,7 +724,7 @@ static void c_can_do_tx(struct net_device *dev)
		/* Clear the bits in the tx_active mask */
		atomic_sub(clr, &priv->tx_active);

		if (clr & (1 << (C_CAN_MSG_OBJ_TX_NUM - 1)))
		if (clr & BIT(priv->msg_obj_tx_num - 1))
		netif_wake_queue(dev);

		if (pkts) {
		@@ -739,20 +734,18 @@ static void c_can_do_tx(struct net_device *dev)
		}
		}

		/*
		* If we have a gap in the pending bits, that means we either
		/* If we have a gap in the pending bits, that means we either
		* raced with the hardware or failed to readout all upper
		* objects in the last run due to quota limit.
		*/
		static u32 c_can_adjust_pending(u32 pend)
		static u32 c_can_adjust_pending(u32 pend, u32 rx_mask)
		{
		u32 weight, lasts;

		if (pend == RECEIVE_OBJECT_BITS)
		if (pend == rx_mask)
		return pend;

		/*
		* If the last set bit is larger than the number of pending
		/* If the last set bit is larger than the number of pending
		* bits we have a gap.
		*/
		weight = hweight32(pend);
		@@ -762,13 +755,13 @@ static u32 c_can_adjust_pending(u32 pend)
		if (lasts == weight)
		return pend;

		/*
		* Find the first set bit after the gap. We walk backwards
		/* Find the first set bit after the gap. We walk backwards
		* from the last set bit.
		*/
		for (lasts--; pend & (1 << (lasts - 1)); lasts--);
		for (lasts--; pend & BIT(lasts - 1); lasts--)
		;

		return pend & ~((1 << lasts) - 1);
		return pend & ~GENMASK(lasts - 1, 0);
		}

		static inline void c_can_rx_object_get(struct net_device *dev,
		@@ -803,8 +796,7 @@ static int c_can_read_objects(struct net_device dev, struct c_can_priv priv,
		continue;
		}

		/*
		* This really should not happen, but this covers some
		/* This really should not happen, but this covers some
		* odd HW behaviour. Do not remove that unless you
		* want to brick your machine.
		*/
		@@ -825,19 +817,22 @@ static int c_can_read_objects(struct net_device dev, struct c_can_priv priv,

		static inline u32 c_can_get_pending(struct c_can_priv *priv)
		{
		u32 pend = priv->read_reg(priv, C_CAN_NEWDAT1_REG);
		u32 pend;

		if (priv->msg_obj_rx_last > 16)
		pend = priv->read_reg32(priv, C_CAN_NEWDAT1_REG);
		else
		pend = priv->read_reg(priv, C_CAN_NEWDAT1_REG);

		return pend;
		}

		/*
		* theory of operation:
		/* theory of operation:
		*
		* c_can core saves a received CAN message into the first free message
		* object it finds free (starting with the lowest). Bits NEWDAT and
		* INTPND are set for this message object indicating that a new message
		* has arrived. To work-around this issue, we keep two groups of message
		* objects whose partitioning is defined by C_CAN_MSG_OBJ_RX_SPLIT.
		* has arrived.
		*
		* We clear the newdat bit right away.
		*
		@@ -848,23 +843,16 @@ static int c_can_do_rx_poll(struct net_device *dev, int quota)
		struct c_can_priv *priv = netdev_priv(dev);
		u32 pkts = 0, pend = 0, toread, n;

		/*
		* It is faster to read only one 16bit register. This is only possible
		* for a maximum number of 16 objects.
		*/
		BUILD_BUG_ON_MSG(C_CAN_MSG_OBJ_RX_LAST > 16,
		"Implementation does not support more message objects than 16");

		while (quota > 0) {
		if (!pend) {
		pend = c_can_get_pending(priv);
		if (!pend)
		break;
		/*
		* If the pending field has a gap, handle the
		/* If the pending field has a gap, handle the
		* bits above the gap first.
		*/
		toread = c_can_adjust_pending(pend);
		toread = c_can_adjust_pending(pend,
		priv->msg_obj_rx_mask);
		} else {
		toread = pend;
		}
		@@ -979,8 +967,7 @@ static int c_can_handle_bus_err(struct net_device *dev,
		struct can_frame *cf;
		struct sk_buff *skb;

		/*
		* early exit if no lec update or no error.
		/* early exit if no lec update or no error.
		* no lec update means that no CAN bus event has been detected
		* since CPU wrote 0x7 value to status reg.
		*/
		@@ -999,8 +986,7 @@ static int c_can_handle_bus_err(struct net_device *dev,
		if (unlikely(!skb))
		return 0;

		/*
		* check for 'last error code' which tells us the
		/* check for 'last error code' which tells us the
		* type of the last error to occur on the CAN bus
		*/
		cf->can_id \|= CAN_ERR_PROT \| CAN_ERR_BUSERROR;
		@@ -1049,7 +1035,8 @@ static int c_can_poll(struct napi_struct *napi, int quota)

		/* Only read the status register if a status interrupt was pending */
		if (atomic_xchg(&priv->sie_pending, 0)) {
		priv->last_status = curr = priv->read_reg(priv, C_CAN_STS_REG);
		priv->last_status = priv->read_reg(priv, C_CAN_STS_REG);
		curr = priv->last_status;
		/* Ack status on C_CAN. D_CAN is self clearing */
		if (priv->type != BOSCH_D_CAN)
		priv->write_reg(priv, C_CAN_STS_REG, LEC_UNUSED);
		@@ -1195,17 +1182,31 @@ static int c_can_close(struct net_device *dev)
		return 0;
		}

		struct net_device *alloc_c_can_dev(void)
		struct net_device *alloc_c_can_dev(int msg_obj_num)
		{
		struct net_device *dev;
		struct c_can_priv *priv;
		int msg_obj_tx_num = msg_obj_num / 2;

		dev = alloc_candev(sizeof(struct c_can_priv), C_CAN_MSG_OBJ_TX_NUM);
		dev = alloc_candev(struct_size(priv, dlc, msg_obj_tx_num),
		msg_obj_tx_num);
		if (!dev)
		return NULL;

		priv = netdev_priv(dev);
		netif_napi_add(dev, &priv->napi, c_can_poll, C_CAN_NAPI_WEIGHT);
		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;
		priv->msg_obj_rx_last =
		priv->msg_obj_rx_first + priv->msg_obj_rx_num - 1;
		priv->msg_obj_rx_mask = GENMASK(priv->msg_obj_rx_num - 1, 0);

		priv->msg_obj_tx_num = msg_obj_tx_num;
		priv->msg_obj_tx_first = priv->msg_obj_rx_last + 1;
		priv->msg_obj_tx_last =
		priv->msg_obj_tx_first + priv->msg_obj_tx_num - 1;

		netif_napi_add(dev, &priv->napi, c_can_poll, priv->msg_obj_rx_num);

		priv->dev = dev;
		priv->can.bittiming_const = &c_can_bittiming_const;

drivers/net/can/c_can/c_can.h

+18 −24

Original line number	Diff line number	Diff line
		@@ -22,23 +22,6 @@
		#ifndef C_CAN_H
		#define C_CAN_H

		/* message object split */
		#define C_CAN_NO_OF_OBJECTS 32
		#define C_CAN_MSG_OBJ_RX_NUM 16
		#define C_CAN_MSG_OBJ_TX_NUM 16

		#define C_CAN_MSG_OBJ_RX_FIRST 1
		#define C_CAN_MSG_OBJ_RX_LAST (C_CAN_MSG_OBJ_RX_FIRST + \
		C_CAN_MSG_OBJ_RX_NUM - 1)

		#define C_CAN_MSG_OBJ_TX_FIRST (C_CAN_MSG_OBJ_RX_LAST + 1)
		#define C_CAN_MSG_OBJ_TX_LAST (C_CAN_MSG_OBJ_TX_FIRST + \
		C_CAN_MSG_OBJ_TX_NUM - 1)

		#define C_CAN_MSG_OBJ_RX_SPLIT 9
		#define C_CAN_MSG_RX_LOW_LAST (C_CAN_MSG_OBJ_RX_SPLIT - 1)
		#define RECEIVE_OBJECT_BITS 0x0000ffff

		enum reg {
		C_CAN_CTRL_REG = 0,
		C_CAN_CTRL_EX_REG,
		@@ -76,6 +59,7 @@ enum reg {
		C_CAN_NEWDAT2_REG,
		C_CAN_INTPND1_REG,
		C_CAN_INTPND2_REG,
		C_CAN_INTPND3_REG,
		C_CAN_MSGVAL1_REG,
		C_CAN_MSGVAL2_REG,
		C_CAN_FUNCTION_REG,
		@@ -137,6 +121,7 @@ static const u16 __maybe_unused reg_map_d_can[] = {
		[C_CAN_NEWDAT2_REG] = 0x9E,
		[C_CAN_INTPND1_REG] = 0xB0,
		[C_CAN_INTPND2_REG] = 0xB2,
		[C_CAN_INTPND3_REG] = 0xB4,
		[C_CAN_MSGVAL1_REG] = 0xC4,
		[C_CAN_MSGVAL2_REG] = 0xC6,
		[C_CAN_IF1_COMREQ_REG] = 0x100,
		@@ -176,6 +161,7 @@ struct raminit_bits {

		struct c_can_driver_data {
		enum c_can_dev_id id;
		unsigned int msg_obj_num;

		/* RAMINIT register description. Optional. */
		const struct raminit_bits raminit_bits; / Array of START/DONE bit positions */
		@@ -197,6 +183,14 @@ struct c_can_priv {
		struct napi_struct napi;
		struct net_device *dev;
		struct device *device;
		unsigned int msg_obj_num;
		unsigned int msg_obj_rx_num;
		unsigned int msg_obj_tx_num;
		unsigned int msg_obj_rx_first;
		unsigned int msg_obj_rx_last;
		unsigned int msg_obj_tx_first;
		unsigned int msg_obj_tx_last;
		u32 msg_obj_rx_mask;
		atomic_t tx_active;
		atomic_t sie_pending;
		unsigned long tx_dir;
		@@ -213,10 +207,10 @@ struct c_can_priv {
		void (raminit)(const struct c_can_priv priv, bool enable);
		u32 comm_rcv_high;
		u32 rxmasked;
		u32 dlc[C_CAN_MSG_OBJ_TX_NUM];
		u32 dlc[];
		};

		struct net_device *alloc_c_can_dev(void);
		struct net_device *alloc_c_can_dev(int msg_obj_num);
		void free_c_can_dev(struct net_device *dev);
		int register_c_can_dev(struct net_device *dev);
		void unregister_c_can_dev(struct net_device *dev);

drivers/net/can/c_can/c_can_pci.c

+17 −14

Original line number	Diff line number	Diff line
		@@ -31,6 +31,8 @@ enum c_can_pci_reg_align {
		struct c_can_pci_data {
		/* Specify if is C_CAN or D_CAN */
		enum c_can_dev_id type;
		/* Number of message objects */
		unsigned int msg_obj_num;
		/* Set the register alignment in the memory */
		enum c_can_pci_reg_align reg_align;
		/* Set the frequency */
		@@ -41,8 +43,7 @@ struct c_can_pci_data {
		void (init)(const struct c_can_priv priv, bool enable);
		};

		/*
		* 16-bit c_can registers can be arranged differently in the memory
		/* 16-bit c_can registers can be arranged differently in the memory
		* architecture of different implementations. For example: 16-bit
		* registers can be aligned to a 16-bit boundary or 32-bit boundary etc.
		* Handle the same by providing a common read/write interface.
		@@ -142,14 +143,13 @@ static int c_can_pci_probe(struct pci_dev *pdev,
		pci_resource_len(pdev, c_can_pci_data->bar));
		if (!addr) {
		dev_err(&pdev->dev,
		"device has no PCI memory resources, "
		"failing adapter\n");
		"device has no PCI memory resources, failing adapter\n");
		ret = -ENOMEM;
		goto out_release_regions;
		}

		/* allocate the c_can device */
		dev = alloc_c_can_dev();
		dev = alloc_c_can_dev(c_can_pci_data->msg_obj_num);
		if (!dev) {
		ret = -ENOMEM;
		goto out_iounmap;
		@@ -254,6 +254,7 @@ static void c_can_pci_remove(struct pci_dev *pdev)

		static const struct c_can_pci_data c_can_sta2x11 = {
		.type = BOSCH_C_CAN,
		.msg_obj_num = 32,
		.reg_align = C_CAN_REG_ALIGN_32,
		.freq = 52000000, /* 52 Mhz */
		.bar = 0,
		@@ -261,6 +262,7 @@ static const struct c_can_pci_data c_can_sta2x11= {

		static const struct c_can_pci_data c_can_pch = {
		.type = BOSCH_C_CAN,
		.msg_obj_num = 32,
		.reg_align = C_CAN_REG_32,
		.freq = 50000000, /* 50 MHz */
		.init = c_can_pci_reset_pch,
		@@ -269,7 +271,7 @@ static const struct c_can_pci_data c_can_pch = {

		#define C_CAN_ID(_vend, _dev, _driverdata) { \
		PCI_DEVICE(_vend, _dev), \
		.driver_data = (unsigned long)&_driverdata, \
		.driver_data = (unsigned long)&(_driverdata), \
		}

		static const struct pci_device_id c_can_pci_tbl[] = {
		@@ -279,6 +281,7 @@ static const struct pci_device_id c_can_pci_tbl[] = {
		c_can_pch),
		{},
		};

		static struct pci_driver c_can_pci_driver = {
		.name = KBUILD_MODNAME,
		.id_table = c_can_pci_tbl,