Commit eb79a267 authored by Marc Kleine-Budde's avatar Marc Kleine-Budde
Browse files

can: mcp251xfd: rename all remaining occurrence to mcp251xfd 

In [1] Geert noted that the autodetect compatible for the mcp25xxfd driver,
which is "microchip,mcp25xxfd" might be too generic and overlap with upcoming,
but incompatible chips.

In the previous patch the autodetect DT compatbile has been renamed to
"microchip,mcp251xfd", this patch changes all non user facing occurrence of
"mcp25xxfd" to "mcp251xfd" and "MCP25XXFD" to "MCP251XFD".

[1] http://lore.kernel.org/r/CAMuHMdVkwGjr6dJuMyhQNqFoJqbh6Ec5V2b5LenCshwpM2SDsQ@mail.gmail.com

Link: https://lore.kernel.org/r/20200930091424.792165-10-mkl@pengutronix.de


Signed-off-by: default avatarMarc Kleine-Budde <mkl@pengutronix.de>
parent f4f77366

drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c

+665 −665

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/can/spi/mcp251xfd/mcp251xfd-crc16.c

+11 −11
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

//

// mcp25xxfd - Microchip MCP25xxFD Family CAN controller driver

// mcp251xfd - Microchip MCP251xFD Family CAN controller driver

//

// Copyright (c) 2020 Pengutronix,

//                    Marc Kleine-Budde <kernel@pengutronix.de>
@@ -20,7 +20,7 @@ 
 *

 * http://lkml.iu.edu/hypermail/linux/kernel/0508.1/1085.html

 */

static const u16 mcp25xxfd_crc16_table[] = {

static const u16 mcp251xfd_crc16_table[] = {

	0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,

	0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,

	0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
@@ -55,35 +55,35 @@ static const u16 mcp25xxfd_crc16_table[] = { 
	0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202

};



static inline u16 mcp25xxfd_crc16_byte(u16 crc, const u8 data)

static inline u16 mcp251xfd_crc16_byte(u16 crc, const u8 data)

{

	u8 index = (crc >> 8) ^ data;



	return (crc << 8) ^ mcp25xxfd_crc16_table[index];

	return (crc << 8) ^ mcp251xfd_crc16_table[index];

}



static u16 mcp25xxfd_crc16(u16 crc, u8 const *buffer, size_t len)

static u16 mcp251xfd_crc16(u16 crc, u8 const *buffer, size_t len)

{

	while (len--)

		crc = mcp25xxfd_crc16_byte(crc, *buffer++);

		crc = mcp251xfd_crc16_byte(crc, *buffer++);



	return crc;

}



u16 mcp25xxfd_crc16_compute(const void *data, size_t data_size)

u16 mcp251xfd_crc16_compute(const void *data, size_t data_size)

{

	u16 crc = 0xffff;



	return mcp25xxfd_crc16(crc, data, data_size);

	return mcp251xfd_crc16(crc, data, data_size);

}



u16 mcp25xxfd_crc16_compute2(const void *cmd, size_t cmd_size,

u16 mcp251xfd_crc16_compute2(const void *cmd, size_t cmd_size,

			     const void *data, size_t data_size)

{

	u16 crc;



	crc = mcp25xxfd_crc16_compute(cmd, cmd_size);

	crc = mcp25xxfd_crc16(crc, data, data_size);

	crc = mcp251xfd_crc16_compute(cmd, cmd_size);

	crc = mcp251xfd_crc16(crc, data, data_size);



	return crc;

}

drivers/net/can/spi/mcp251xfd/mcp251xfd-regmap.c

+115 −115
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

//

// mcp25xxfd - Microchip MCP25xxFD Family CAN controller driver

// mcp251xfd - Microchip MCP251xFD Family CAN controller driver

//

// Copyright (c) 2019, 2020 Pengutronix,

//                          Marc Kleine-Budde <kernel@pengutronix.de>
@@ -10,10 +10,10 @@ 


#include <asm/unaligned.h>



static const struct regmap_config mcp25xxfd_regmap_crc;

static const struct regmap_config mcp251xfd_regmap_crc;



static int

mcp25xxfd_regmap_nocrc_write(void *context, const void *data, size_t count)

mcp251xfd_regmap_nocrc_write(void *context, const void *data, size_t count)

{

	struct spi_device *spi = context;
@@ -21,13 +21,13 @@ mcp25xxfd_regmap_nocrc_write(void *context, const void *data, size_t count) 
}



static int

mcp25xxfd_regmap_nocrc_gather_write(void *context,

mcp251xfd_regmap_nocrc_gather_write(void *context,

				    const void *reg, size_t reg_len,

				    const void *val, size_t val_len)

{

	struct spi_device *spi = context;

	struct mcp25xxfd_priv *priv = spi_get_drvdata(spi);

	struct mcp25xxfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	struct mcp251xfd_priv *priv = spi_get_drvdata(spi);

	struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	struct spi_transfer xfer[] = {

		{

			.tx_buf = buf_tx,
@@ -37,7 +37,7 @@ mcp25xxfd_regmap_nocrc_gather_write(void *context, 


	BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16));



	if (IS_ENABLED(CONFIG_CAN_MCP25XXFD_SANITY) &&

	if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&

	    reg_len != sizeof(buf_tx->cmd.cmd))

		return -EINVAL;
@@ -47,20 +47,20 @@ mcp25xxfd_regmap_nocrc_gather_write(void *context, 
	return spi_sync_transfer(spi, xfer, ARRAY_SIZE(xfer));

}



static inline bool mcp25xxfd_update_bits_read_reg(unsigned int reg)

static inline bool mcp251xfd_update_bits_read_reg(unsigned int reg)

{

	switch (reg) {

	case MCP25XXFD_REG_INT:

	case MCP25XXFD_REG_TEFCON:

	case MCP25XXFD_REG_FIFOCON(MCP25XXFD_RX_FIFO(0)):

	case MCP25XXFD_REG_FLTCON(0):

	case MCP25XXFD_REG_ECCSTAT:

	case MCP25XXFD_REG_CRC:

	case MCP251XFD_REG_INT:

	case MCP251XFD_REG_TEFCON:

	case MCP251XFD_REG_FIFOCON(MCP251XFD_RX_FIFO(0)):

	case MCP251XFD_REG_FLTCON(0):

	case MCP251XFD_REG_ECCSTAT:

	case MCP251XFD_REG_CRC:

		return false;

	case MCP25XXFD_REG_CON:

	case MCP25XXFD_REG_FIFOSTA(MCP25XXFD_RX_FIFO(0)):

	case MCP25XXFD_REG_OSC:

	case MCP25XXFD_REG_ECCCON:

	case MCP251XFD_REG_CON:

	case MCP251XFD_REG_FIFOSTA(MCP251XFD_RX_FIFO(0)):

	case MCP251XFD_REG_OSC:

	case MCP251XFD_REG_ECCCON:

		return true;

	default:

		WARN(1, "Status of reg 0x%04x unknown.\n", reg);
@@ -70,13 +70,13 @@ static inline bool mcp25xxfd_update_bits_read_reg(unsigned int reg) 
}



static int

mcp25xxfd_regmap_nocrc_update_bits(void *context, unsigned int reg,

mcp251xfd_regmap_nocrc_update_bits(void *context, unsigned int reg,

				   unsigned int mask, unsigned int val)

{

	struct spi_device *spi = context;

	struct mcp25xxfd_priv *priv = spi_get_drvdata(spi);

	struct mcp25xxfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx;

	struct mcp25xxfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	struct mcp251xfd_priv *priv = spi_get_drvdata(spi);

	struct mcp251xfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx;

	struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	__le32 orig_le32 = 0, mask_le32, val_le32, tmp_le32;

	u8 first_byte, last_byte, len;

	int err;
@@ -84,22 +84,22 @@ mcp25xxfd_regmap_nocrc_update_bits(void *context, unsigned int reg, 
	BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16));

	BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16));



	if (IS_ENABLED(CONFIG_CAN_MCP25XXFD_SANITY) &&

	if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&

	    mask == 0)

		return -EINVAL;



	first_byte = mcp25xxfd_first_byte_set(mask);

	last_byte = mcp25xxfd_last_byte_set(mask);

	first_byte = mcp251xfd_first_byte_set(mask);

	last_byte = mcp251xfd_last_byte_set(mask);

	len = last_byte - first_byte + 1;



	if (mcp25xxfd_update_bits_read_reg(reg)) {

	if (mcp251xfd_update_bits_read_reg(reg)) {

		struct spi_transfer xfer[2] = { };

		struct spi_message msg;



		spi_message_init(&msg);

		spi_message_add_tail(&xfer[0], &msg);



		if (priv->devtype_data.quirks & MCP25XXFD_QUIRK_HALF_DUPLEX) {

		if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) {

			xfer[0].tx_buf = buf_tx;

			xfer[0].len = sizeof(buf_tx->cmd);
@@ -111,11 +111,11 @@ mcp25xxfd_regmap_nocrc_update_bits(void *context, unsigned int reg, 
			xfer[0].rx_buf = buf_rx;

			xfer[0].len = sizeof(buf_tx->cmd) + len;



			if (MCP25XXFD_SANITIZE_SPI)

			if (MCP251XFD_SANITIZE_SPI)

				memset(buf_tx->data, 0x0, len);

		}



		mcp25xxfd_spi_cmd_read_nocrc(&buf_tx->cmd, reg + first_byte);

		mcp251xfd_spi_cmd_read_nocrc(&buf_tx->cmd, reg + first_byte);

		err = spi_sync(spi, &msg);

		if (err)

			return err;
@@ -129,21 +129,21 @@ mcp25xxfd_regmap_nocrc_update_bits(void *context, unsigned int reg, 
	tmp_le32 = orig_le32 & ~mask_le32;

	tmp_le32 |= val_le32 & mask_le32;



	mcp25xxfd_spi_cmd_write_nocrc(&buf_tx->cmd, reg + first_byte);

	mcp251xfd_spi_cmd_write_nocrc(&buf_tx->cmd, reg + first_byte);

	memcpy(buf_tx->data, &tmp_le32, len);



	return spi_write(spi, buf_tx, sizeof(buf_tx->cmd) + len);

}



static int

mcp25xxfd_regmap_nocrc_read(void *context,

mcp251xfd_regmap_nocrc_read(void *context,

			    const void *reg, size_t reg_len,

			    void *val_buf, size_t val_len)

{

	struct spi_device *spi = context;

	struct mcp25xxfd_priv *priv = spi_get_drvdata(spi);

	struct mcp25xxfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx;

	struct mcp25xxfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	struct mcp251xfd_priv *priv = spi_get_drvdata(spi);

	struct mcp251xfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx;

	struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx;

	struct spi_transfer xfer[2] = { };

	struct spi_message msg;

	int err;
@@ -151,14 +151,14 @@ mcp25xxfd_regmap_nocrc_read(void *context, 
	BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16));

	BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16));



	if (IS_ENABLED(CONFIG_CAN_MCP25XXFD_SANITY) &&

	if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&

	    reg_len != sizeof(buf_tx->cmd.cmd))

		return -EINVAL;



	spi_message_init(&msg);

	spi_message_add_tail(&xfer[0], &msg);



	if (priv->devtype_data.quirks & MCP25XXFD_QUIRK_HALF_DUPLEX) {

	if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) {

		xfer[0].tx_buf = reg;

		xfer[0].len = sizeof(buf_tx->cmd);
@@ -171,7 +171,7 @@ mcp25xxfd_regmap_nocrc_read(void *context, 
		xfer[0].len = sizeof(buf_tx->cmd) + val_len;



		memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd));

		if (MCP25XXFD_SANITIZE_SPI)

		if (MCP251XFD_SANITIZE_SPI)

			memset(buf_tx->data, 0x0, val_len);

	};
@@ -179,20 +179,20 @@ mcp25xxfd_regmap_nocrc_read(void *context, 
	if (err)

		return err;



	if (!(priv->devtype_data.quirks & MCP25XXFD_QUIRK_HALF_DUPLEX))

	if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX))

		memcpy(val_buf, buf_rx->data, val_len);



	return 0;

}



static int

mcp25xxfd_regmap_crc_gather_write(void *context,

mcp251xfd_regmap_crc_gather_write(void *context,

				  const void *reg_p, size_t reg_len,

				  const void *val, size_t val_len)

{

	struct spi_device *spi = context;

	struct mcp25xxfd_priv *priv = spi_get_drvdata(spi);

	struct mcp25xxfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	struct mcp251xfd_priv *priv = spi_get_drvdata(spi);

	struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	struct spi_transfer xfer[] = {

		{

			.tx_buf = buf_tx,
@@ -205,39 +205,39 @@ mcp25xxfd_regmap_crc_gather_write(void *context, 


	BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8));



	if (IS_ENABLED(CONFIG_CAN_MCP25XXFD_SANITY) &&

	if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&

	    reg_len != sizeof(buf_tx->cmd.cmd) +

	    mcp25xxfd_regmap_crc.pad_bits / BITS_PER_BYTE)

	    mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)

		return -EINVAL;



	mcp25xxfd_spi_cmd_write_crc(&buf_tx->cmd, reg, val_len);

	mcp251xfd_spi_cmd_write_crc(&buf_tx->cmd, reg, val_len);

	memcpy(buf_tx->data, val, val_len);



	crc = mcp25xxfd_crc16_compute(buf_tx, sizeof(buf_tx->cmd) + val_len);

	crc = mcp251xfd_crc16_compute(buf_tx, sizeof(buf_tx->cmd) + val_len);

	put_unaligned_be16(crc, buf_tx->data + val_len);



	return spi_sync_transfer(spi, xfer, ARRAY_SIZE(xfer));

}



static int

mcp25xxfd_regmap_crc_write(void *context,

mcp251xfd_regmap_crc_write(void *context,

			   const void *data, size_t count)

{

	const size_t data_offset = sizeof(__be16) +

		mcp25xxfd_regmap_crc.pad_bits / BITS_PER_BYTE;

		mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE;



	return mcp25xxfd_regmap_crc_gather_write(context,

	return mcp251xfd_regmap_crc_gather_write(context,

						 data, data_offset,

						 data + data_offset,

						 count - data_offset);

}



static int

mcp25xxfd_regmap_crc_read_one(struct mcp25xxfd_priv *priv,

mcp251xfd_regmap_crc_read_one(struct mcp251xfd_priv *priv,

			      struct spi_message *msg, unsigned int data_len)

{

	const struct mcp25xxfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx;

	const struct mcp25xxfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	const struct mcp251xfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx;

	const struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	u16 crc_received, crc_calculated;

	int err;
@@ -249,7 +249,7 @@ mcp25xxfd_regmap_crc_read_one(struct mcp25xxfd_priv *priv, 
		return err;



	crc_received = get_unaligned_be16(buf_rx->data + data_len);

	crc_calculated = mcp25xxfd_crc16_compute2(&buf_tx->cmd,

	crc_calculated = mcp251xfd_crc16_compute2(&buf_tx->cmd,

						  sizeof(buf_tx->cmd),

						  buf_rx->data,

						  data_len);
@@ -260,14 +260,14 @@ mcp25xxfd_regmap_crc_read_one(struct mcp25xxfd_priv *priv, 
}



static int

mcp25xxfd_regmap_crc_read(void *context,

mcp251xfd_regmap_crc_read(void *context,

			  const void *reg_p, size_t reg_len,

			  void *val_buf, size_t val_len)

{

	struct spi_device *spi = context;

	struct mcp25xxfd_priv *priv = spi_get_drvdata(spi);

	struct mcp25xxfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx;

	struct mcp25xxfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	struct mcp251xfd_priv *priv = spi_get_drvdata(spi);

	struct mcp251xfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx;

	struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx;

	struct spi_transfer xfer[2] = { };

	struct spi_message msg;

	u16 reg = *(u16 *)reg_p;
@@ -276,15 +276,15 @@ mcp25xxfd_regmap_crc_read(void *context, 
	BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16) + sizeof(u8));

	BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8));



	if (IS_ENABLED(CONFIG_CAN_MCP25XXFD_SANITY) &&

	if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) &&

	    reg_len != sizeof(buf_tx->cmd.cmd) +

	    mcp25xxfd_regmap_crc.pad_bits / BITS_PER_BYTE)

	    mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE)

		return -EINVAL;



	spi_message_init(&msg);

	spi_message_add_tail(&xfer[0], &msg);



	if (priv->devtype_data.quirks & MCP25XXFD_QUIRK_HALF_DUPLEX) {

	if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) {

		xfer[0].tx_buf = buf_tx;

		xfer[0].len = sizeof(buf_tx->cmd);
@@ -297,21 +297,21 @@ mcp25xxfd_regmap_crc_read(void *context, 
		xfer[0].len = sizeof(buf_tx->cmd) + val_len +

			sizeof(buf_tx->crc);



		if (MCP25XXFD_SANITIZE_SPI)

		if (MCP251XFD_SANITIZE_SPI)

			memset(buf_tx->data, 0x0, val_len +

			       sizeof(buf_tx->crc));

	}



	mcp25xxfd_spi_cmd_read_crc(&buf_tx->cmd, reg, val_len);

	mcp251xfd_spi_cmd_read_crc(&buf_tx->cmd, reg, val_len);



	for (i = 0; i < MCP25XXFD_READ_CRC_RETRIES_MAX; i++) {

		err = mcp25xxfd_regmap_crc_read_one(priv, &msg, val_len);

	for (i = 0; i < MCP251XFD_READ_CRC_RETRIES_MAX; i++) {

		err = mcp251xfd_regmap_crc_read_one(priv, &msg, val_len);

		if (!err)

			goto out;

		if (err != -EBADMSG)

			return err;



		/* MCP25XXFD_REG_OSC is the first ever reg we read from.

		/* MCP251XFD_REG_OSC is the first ever reg we read from.

		 *

		 * The chip may be in deep sleep and this SPI transfer

		 * (i.e. the assertion of the CS) will wake the chip
@@ -325,7 +325,7 @@ mcp25xxfd_regmap_crc_read(void *context, 
		 * to the caller. It will take care of both cases.

		 *

		 */

		if (reg == MCP25XXFD_REG_OSC) {

		if (reg == MCP251XFD_REG_OSC) {

			err = 0;

			goto out;

		}
@@ -350,88 +350,88 @@ mcp25xxfd_regmap_crc_read(void *context, 
	return 0;

}



static const struct regmap_range mcp25xxfd_reg_table_yes_range[] = {

static const struct regmap_range mcp251xfd_reg_table_yes_range[] = {

	regmap_reg_range(0x000, 0x2ec),	/* CAN FD Controller Module SFR */

	regmap_reg_range(0x400, 0xbfc),	/* RAM */

	regmap_reg_range(0xe00, 0xe14),	/* MCP2517/18FD SFR */

};



static const struct regmap_access_table mcp25xxfd_reg_table = {

	.yes_ranges = mcp25xxfd_reg_table_yes_range,

	.n_yes_ranges = ARRAY_SIZE(mcp25xxfd_reg_table_yes_range),

static const struct regmap_access_table mcp251xfd_reg_table = {

	.yes_ranges = mcp251xfd_reg_table_yes_range,

	.n_yes_ranges = ARRAY_SIZE(mcp251xfd_reg_table_yes_range),

};



static const struct regmap_config mcp25xxfd_regmap_nocrc = {

static const struct regmap_config mcp251xfd_regmap_nocrc = {

	.name = "nocrc",

	.reg_bits = 16,

	.reg_stride = 4,

	.pad_bits = 0,

	.val_bits = 32,

	.max_register = 0xffc,

	.wr_table = &mcp25xxfd_reg_table,

	.rd_table = &mcp25xxfd_reg_table,

	.wr_table = &mcp251xfd_reg_table,

	.rd_table = &mcp251xfd_reg_table,

	.cache_type = REGCACHE_NONE,

	.read_flag_mask = (__force unsigned long)

		cpu_to_be16(MCP25XXFD_SPI_INSTRUCTION_READ),

		cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_READ),

	.write_flag_mask = (__force unsigned long)

		cpu_to_be16(MCP25XXFD_SPI_INSTRUCTION_WRITE),

		cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_WRITE),

};



static const struct regmap_bus mcp25xxfd_bus_nocrc = {

	.write = mcp25xxfd_regmap_nocrc_write,

	.gather_write = mcp25xxfd_regmap_nocrc_gather_write,

	.reg_update_bits = mcp25xxfd_regmap_nocrc_update_bits,

	.read = mcp25xxfd_regmap_nocrc_read,

static const struct regmap_bus mcp251xfd_bus_nocrc = {

	.write = mcp251xfd_regmap_nocrc_write,

	.gather_write = mcp251xfd_regmap_nocrc_gather_write,

	.reg_update_bits = mcp251xfd_regmap_nocrc_update_bits,

	.read = mcp251xfd_regmap_nocrc_read,

	.reg_format_endian_default = REGMAP_ENDIAN_BIG,

	.val_format_endian_default = REGMAP_ENDIAN_LITTLE,

	.max_raw_read = sizeof_field(struct mcp25xxfd_map_buf_nocrc, data),

	.max_raw_write = sizeof_field(struct mcp25xxfd_map_buf_nocrc, data),

	.max_raw_read = sizeof_field(struct mcp251xfd_map_buf_nocrc, data),

	.max_raw_write = sizeof_field(struct mcp251xfd_map_buf_nocrc, data),

};



static const struct regmap_config mcp25xxfd_regmap_crc = {

static const struct regmap_config mcp251xfd_regmap_crc = {

	.name = "crc",

	.reg_bits = 16,

	.reg_stride = 4,

	.pad_bits = 16,		/* keep data bits aligned */

	.val_bits = 32,

	.max_register = 0xffc,

	.wr_table = &mcp25xxfd_reg_table,

	.rd_table = &mcp25xxfd_reg_table,

	.wr_table = &mcp251xfd_reg_table,

	.rd_table = &mcp251xfd_reg_table,

	.cache_type = REGCACHE_NONE,

};



static const struct regmap_bus mcp25xxfd_bus_crc = {

	.write = mcp25xxfd_regmap_crc_write,

	.gather_write = mcp25xxfd_regmap_crc_gather_write,

	.read = mcp25xxfd_regmap_crc_read,

static const struct regmap_bus mcp251xfd_bus_crc = {

	.write = mcp251xfd_regmap_crc_write,

	.gather_write = mcp251xfd_regmap_crc_gather_write,

	.read = mcp251xfd_regmap_crc_read,

	.reg_format_endian_default = REGMAP_ENDIAN_NATIVE,

	.val_format_endian_default = REGMAP_ENDIAN_LITTLE,

	.max_raw_read = sizeof_field(struct mcp25xxfd_map_buf_crc, data),

	.max_raw_write = sizeof_field(struct mcp25xxfd_map_buf_crc, data),

	.max_raw_read = sizeof_field(struct mcp251xfd_map_buf_crc, data),

	.max_raw_write = sizeof_field(struct mcp251xfd_map_buf_crc, data),

};



static inline bool

mcp25xxfd_regmap_use_nocrc(struct mcp25xxfd_priv *priv)

mcp251xfd_regmap_use_nocrc(struct mcp251xfd_priv *priv)

{

	return (!(priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_REG)) ||

		(!(priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_RX));

	return (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG)) ||

		(!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX));

}



static inline bool

mcp25xxfd_regmap_use_crc(struct mcp25xxfd_priv *priv)

mcp251xfd_regmap_use_crc(struct mcp251xfd_priv *priv)

{

	return (priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_REG) ||

		(priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_RX);

	return (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG) ||

		(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX);

}



static int

mcp25xxfd_regmap_init_nocrc(struct mcp25xxfd_priv *priv)

mcp251xfd_regmap_init_nocrc(struct mcp251xfd_priv *priv)

{

	if (!priv->map_nocrc) {

		struct regmap *map;



		map = devm_regmap_init(&priv->spi->dev, &mcp25xxfd_bus_nocrc,

				       priv->spi, &mcp25xxfd_regmap_nocrc);

		map = devm_regmap_init(&priv->spi->dev, &mcp251xfd_bus_nocrc,

				       priv->spi, &mcp251xfd_regmap_nocrc);

		if (IS_ERR(map))

			return PTR_ERR(map);
@@ -456,16 +456,16 @@ mcp25xxfd_regmap_init_nocrc(struct mcp25xxfd_priv *priv) 
			return -ENOMEM;

	}



	if (!(priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_REG))

	if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG))

		priv->map_reg = priv->map_nocrc;



	if (!(priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_RX))

	if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX))

		priv->map_rx = priv->map_nocrc;



	return 0;

}



static void mcp25xxfd_regmap_destroy_nocrc(struct mcp25xxfd_priv *priv)

static void mcp251xfd_regmap_destroy_nocrc(struct mcp251xfd_priv *priv)

{

	if (priv->map_buf_nocrc_rx) {

		devm_kfree(&priv->spi->dev, priv->map_buf_nocrc_rx);
@@ -478,13 +478,13 @@ static void mcp25xxfd_regmap_destroy_nocrc(struct mcp25xxfd_priv *priv) 
}



static int

mcp25xxfd_regmap_init_crc(struct mcp25xxfd_priv *priv)

mcp251xfd_regmap_init_crc(struct mcp251xfd_priv *priv)

{

	if (!priv->map_crc) {

		struct regmap *map;



		map = devm_regmap_init(&priv->spi->dev, &mcp25xxfd_bus_crc,

				       priv->spi, &mcp25xxfd_regmap_crc);

		map = devm_regmap_init(&priv->spi->dev, &mcp251xfd_bus_crc,

				       priv->spi, &mcp251xfd_regmap_crc);

		if (IS_ERR(map))

			return PTR_ERR(map);
@@ -509,16 +509,16 @@ mcp25xxfd_regmap_init_crc(struct mcp25xxfd_priv *priv) 
			return -ENOMEM;

	}



	if (priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_REG)

	if (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG)

		priv->map_reg = priv->map_crc;



	if (priv->devtype_data.quirks & MCP25XXFD_QUIRK_CRC_RX)

	if (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX)

		priv->map_rx = priv->map_crc;



	return 0;

}



static void mcp25xxfd_regmap_destroy_crc(struct mcp25xxfd_priv *priv)

static void mcp251xfd_regmap_destroy_crc(struct mcp251xfd_priv *priv)

{

	if (priv->map_buf_crc_rx) {

		devm_kfree(&priv->spi->dev, priv->map_buf_crc_rx);
@@ -530,26 +530,26 @@ static void mcp25xxfd_regmap_destroy_crc(struct mcp25xxfd_priv *priv) 
	}

}



int mcp25xxfd_regmap_init(struct mcp25xxfd_priv *priv)

int mcp251xfd_regmap_init(struct mcp251xfd_priv *priv)

{

	int err;



	if (mcp25xxfd_regmap_use_nocrc(priv)) {

		err = mcp25xxfd_regmap_init_nocrc(priv);

	if (mcp251xfd_regmap_use_nocrc(priv)) {

		err = mcp251xfd_regmap_init_nocrc(priv);



		if (err)

			return err;

	} else {

		mcp25xxfd_regmap_destroy_nocrc(priv);

		mcp251xfd_regmap_destroy_nocrc(priv);

	}



	if (mcp25xxfd_regmap_use_crc(priv)) {

		err = mcp25xxfd_regmap_init_crc(priv);

	if (mcp251xfd_regmap_use_crc(priv)) {

		err = mcp251xfd_regmap_init_crc(priv);



		if (err)

			return err;

	} else {

		mcp25xxfd_regmap_destroy_crc(priv);

		mcp251xfd_regmap_destroy_crc(priv);

	}



	return 0;

drivers/net/can/spi/mcp251xfd/mcp251xfd.h

+486 −486

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE