Commit 3b085044 authored by Gene Chen's avatar Gene Chen Committed by Lee Jones
Browse files

mfd: mt6360: Merge different sub-devices I2C read/write 



Merge different sub-devices I2C read/write functions into one Regmap,
because PMIC and LDO part need CRC bits for access protection.

Signed-off-by: default avatarGene Chen <gene_chen@richtek.com>
Signed-off-by: default avatarLee Jones <lee.jones@linaro.org>
parent b042c085

drivers/mfd/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -903,6 +903,7 @@ config MFD_MT6360 
	select MFD_CORE

	select REGMAP_I2C

	select REGMAP_IRQ

	select CRC8

	depends on I2C

	help

	  Say Y here to enable MT6360 PMU/PMIC/LDO functional support.

drivers/mfd/mt6360-core.c

+180 −23
Original line number Diff line number Diff line
@@ -63,6 +63,18 @@ struct mt6360_ddata { 


#define MT6360_CRC8_POLYNOMIAL		0x7



#define MT6360_CRC_I2C_ADDR_SIZE	1

#define MT6360_CRC_REG_ADDR_SIZE	1

/* prealloca read size = i2c device addr + i2c reg addr + val ... + crc8 */

#define MT6360_ALLOC_READ_SIZE(_size)	(_size + 3)

/* prealloca write size = i2c device addr + i2c reg addr + val ... + crc8 + dummy byte */

#define MT6360_ALLOC_WRITE_SIZE(_size)	(_size + 4)

#define MT6360_CRC_PREDATA_OFFSET	(MT6360_CRC_I2C_ADDR_SIZE + MT6360_CRC_REG_ADDR_SIZE)

#define MT6360_CRC_CRC8_SIZE		1

#define MT6360_CRC_DUMMY_BYTE_SIZE	1

#define MT6360_REGMAP_REG_BYTE_SIZE	2

#define I2C_ADDR_XLATE_8BIT(_addr, _rw)	(((_addr & 0x7F) << 1) + _rw)



/* reg 0 -> 0 ~ 7 */

#define MT6360_CHG_TREG_EVT		4

#define MT6360_CHG_AICR_EVT		5
@@ -267,12 +279,6 @@ static const struct regmap_irq_chip mt6360_irq_chip = { 
	.use_ack = true,

};



static const struct regmap_config mt6360_pmu_regmap_config = {

	.reg_bits = 8,

	.val_bits = 8,

	.max_register = MT6360_PMU_MAXREG,

};



static const struct resource mt6360_adc_resources[] = {

	DEFINE_RES_IRQ_NAMED(MT6360_ADC_DONEI, "adc_donei"),

};
@@ -359,10 +365,160 @@ static int mt6360_check_vendor_info(struct mt6360_ddata *ddata) 
}



static const unsigned short mt6360_slave_addr[MT6360_SLAVE_MAX] = {

	MT6360_PMU_SLAVEID,

	MT6360_TCPC_SLAVEID,

	MT6360_PMIC_SLAVEID,

	MT6360_LDO_SLAVEID,

	MT6360_TCPC_SLAVEID,

	MT6360_PMU_SLAVEID,

};



static int mt6360_xlate_pmicldo_addr(u8 *addr, int rw_size)

{

	/* Address is already in encoded [5:0] */

	*addr &= MT6360_ADDRESS_MASK;



	switch (rw_size) {

	case 1:

		*addr |= MT6360_DATA_SIZE_1_BYTE;

		break;

	case 2:

		*addr |= MT6360_DATA_SIZE_2_BYTES;

		break;

	case 3:

		*addr |= MT6360_DATA_SIZE_3_BYTES;

		break;

	case 4:

		*addr |= MT6360_DATA_SIZE_4_BYTES;

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



static int mt6360_regmap_read(void *context, const void *reg, size_t reg_size,

			      void *val, size_t val_size)

{

	struct mt6360_ddata *ddata = context;

	u8 bank = *(u8 *)reg;

	u8 reg_addr = *(u8 *)(reg + 1);

	struct i2c_client *i2c = ddata->i2c[bank];

	bool crc_needed = false;

	u8 *buf;

	int buf_len = MT6360_ALLOC_READ_SIZE(val_size);

	int read_size = val_size;

	u8 crc;

	int ret;



	if (bank == MT6360_SLAVE_PMIC || bank == MT6360_SLAVE_LDO) {

		crc_needed = true;

		ret = mt6360_xlate_pmicldo_addr(&reg_addr, val_size);

		if (ret < 0)

			return ret;

		read_size += MT6360_CRC_CRC8_SIZE;

	}



	buf = kzalloc(buf_len, GFP_KERNEL);

	if (!buf)

		return -ENOMEM;



	buf[0] = I2C_ADDR_XLATE_8BIT(i2c->addr, I2C_SMBUS_READ);

	buf[1] = reg_addr;



	ret = i2c_smbus_read_i2c_block_data(i2c, reg_addr, read_size,

					    buf + MT6360_CRC_PREDATA_OFFSET);

	if (ret < 0)

		goto out;

	else if (ret != read_size) {

		ret = -EIO;

		goto out;

	}



	if (crc_needed) {

		crc = crc8(ddata->crc8_tbl, buf, val_size + MT6360_CRC_PREDATA_OFFSET, 0);

		if (crc != buf[val_size + MT6360_CRC_PREDATA_OFFSET]) {

			ret = -EIO;

			goto out;

		}

	}



	memcpy(val, buf + MT6360_CRC_PREDATA_OFFSET, val_size);

out:

	kfree(buf);

	return (ret < 0) ? ret : 0;

}



static int mt6360_regmap_write(void *context, const void *val, size_t val_size)

{

	struct mt6360_ddata *ddata = context;

	u8 bank = *(u8 *)val;

	u8 reg_addr = *(u8 *)(val + 1);

	struct i2c_client *i2c = ddata->i2c[bank];

	bool crc_needed = false;

	u8 *buf;

	int buf_len = MT6360_ALLOC_WRITE_SIZE(val_size);

	int write_size = val_size - MT6360_REGMAP_REG_BYTE_SIZE;

	int ret;



	if (bank == MT6360_SLAVE_PMIC || bank == MT6360_SLAVE_LDO) {

		crc_needed = true;

		ret = mt6360_xlate_pmicldo_addr(&reg_addr, val_size - MT6360_REGMAP_REG_BYTE_SIZE);

		if (ret < 0)

			return ret;

	}



	buf = kzalloc(buf_len, GFP_KERNEL);

	if (!buf)

		return -ENOMEM;



	buf[0] = I2C_ADDR_XLATE_8BIT(i2c->addr, I2C_SMBUS_WRITE);

	buf[1] = reg_addr;

	memcpy(buf + MT6360_CRC_PREDATA_OFFSET, val + MT6360_REGMAP_REG_BYTE_SIZE, write_size);



	if (crc_needed) {

		buf[val_size] = crc8(ddata->crc8_tbl, buf, val_size, 0);

		write_size += (MT6360_CRC_CRC8_SIZE + MT6360_CRC_DUMMY_BYTE_SIZE);

	}



	ret = i2c_smbus_write_i2c_block_data(i2c, reg_addr, write_size,

					     buf + MT6360_CRC_PREDATA_OFFSET);



	kfree(buf);

	return ret;

}



static const struct regmap_bus mt6360_regmap_bus = {

	.read		= mt6360_regmap_read,

	.write		= mt6360_regmap_write,



	/* Due to PMIC and LDO CRC access size limit */

	.max_raw_read	= 4,

	.max_raw_write	= 4,

};



static bool mt6360_is_readwrite_reg(struct device *dev, unsigned int reg)

{

	switch (reg) {

	case MT6360_REG_TCPCSTART ... MT6360_REG_TCPCEND:

		fallthrough;

	case MT6360_REG_PMICSTART ... MT6360_REG_PMICEND:

		fallthrough;

	case MT6360_REG_LDOSTART ... MT6360_REG_LDOEND:

		fallthrough;

	case MT6360_REG_PMUSTART ... MT6360_REG_PMUEND:

		return true;

	}



	return false;

}



static const struct regmap_config mt6360_regmap_config = {

	.reg_bits		= 16,

	.val_bits		= 8,

	.reg_format_endian	= REGMAP_ENDIAN_BIG,

	.max_register		= MT6360_REG_PMUEND,

	.writeable_reg		= mt6360_is_readwrite_reg,

	.readable_reg		= mt6360_is_readwrite_reg,

};



static int mt6360_probe(struct i2c_client *client)
@@ -377,7 +533,22 @@ static int mt6360_probe(struct i2c_client *client) 
	ddata->dev = &client->dev;

	i2c_set_clientdata(client, ddata);



	ddata->regmap = devm_regmap_init_i2c(client, &mt6360_pmu_regmap_config);

	for (i = 0; i < MT6360_SLAVE_MAX - 1; i++) {

		ddata->i2c[i] = devm_i2c_new_dummy_device(&client->dev,

							  client->adapter,

							  mt6360_slave_addr[i]);

		if (IS_ERR(ddata->i2c[i])) {

			dev_err(&client->dev,

				"Failed to get new dummy I2C device for address 0x%x",

				mt6360_slave_addr[i]);

			return PTR_ERR(ddata->i2c[i]);

		}

	}

	ddata->i2c[MT6360_SLAVE_MAX - 1] = client;



	crc8_populate_msb(ddata->crc8_tbl, MT6360_CRC8_POLYNOMIAL);

	ddata->regmap = devm_regmap_init(ddata->dev, &mt6360_regmap_bus, ddata,

					 &mt6360_regmap_config);

	if (IS_ERR(ddata->regmap)) {

		dev_err(&client->dev, "Failed to register regmap\n");

		return PTR_ERR(ddata->regmap);
@@ -395,20 +566,6 @@ static int mt6360_probe(struct i2c_client *client) 
		return ret;

	}



	ddata->i2c[0] = client;

	for (i = 1; i < MT6360_SLAVE_MAX; i++) {

		ddata->i2c[i] = devm_i2c_new_dummy_device(&client->dev,

							client->adapter,

							mt6360_slave_addr[i]);

		if (IS_ERR(ddata->i2c[i])) {

			dev_err(&client->dev,

				"Failed to get new dummy I2C device for address 0x%x",

				mt6360_slave_addr[i]);

			return PTR_ERR(ddata->i2c[i]);

		}

		i2c_set_clientdata(ddata->i2c[i], ddata);

	}



	ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_AUTO,

				   mt6360_devs, ARRAY_SIZE(mt6360_devs), NULL,

				   0, regmap_irq_get_domain(ddata->irq_data));