Commit 407dc802 authored by Alexandru Tachici's avatar Alexandru Tachici Committed by Guenter Roeck
Browse files

hwmon: (pmbus/adm1266) Add Block process call 



PmBus devices support Block Write-Block Read Process
Call described in SMBus specification v 2.0 with the
exception that Block writes and reads are permitted to
have up 255 data bytes instead of max 32 bytes (SMBus).

This patch adds Block WR process call support for ADM1266.

Signed-off-by: default avatarAlexandru Tachici <alexandru.tachici@analog.com>
Link: https://lore.kernel.org/r/20200812142055.9213-3-alexandru.tachici@analog.com


Signed-off-by: default avatarGuenter Roeck <linux@roeck-us.net>
parent 9514a228

drivers/hwmon/pmbus/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ config SENSORS_PMBUS 


config SENSORS_ADM1266

	tristate "Analog Devices ADM1266 Sequencer"

	select CRC8

	help

	  If you say yes here you get hardware monitoring support for Analog

	  Devices ADM1266 Cascadable Super Sequencer.

drivers/hwmon/pmbus/adm1266.c

+78 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
 * Copyright 2020 Analog Devices Inc.

 */



#include <linux/crc8.h>

#include <linux/i2c.h>

#include <linux/init.h>

#include <linux/kernel.h>
@@ -13,10 +14,84 @@ 
#include "pmbus.h"

#include <linux/slab.h>



#define ADM1266_PMBUS_BLOCK_MAX		255



struct adm1266_data {

	struct pmbus_driver_info info;

	struct i2c_client *client;

	struct mutex buf_mutex;

	u8 write_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;

	u8 read_buf[ADM1266_PMBUS_BLOCK_MAX + 1] ____cacheline_aligned;

};



DECLARE_CRC8_TABLE(pmbus_crc_table);



/*

 * Different from Block Read as it sends data and waits for the slave to

 * return a value dependent on that data. The protocol is simply a Write Block

 * followed by a Read Block without the Read-Block command field and the

 * Write-Block STOP bit.

 */

static int adm1266_pmbus_block_xfer(struct adm1266_data *data, u8 cmd, u8 w_len, u8 *data_w,

				    u8 *data_r)

{

	struct i2c_client *client = data->client;

	struct i2c_msg msgs[2] = {

		{

			.addr = client->addr,

			.flags = I2C_M_DMA_SAFE,

			.buf = data->write_buf,

			.len = w_len + 2,

		},

		{

			.addr = client->addr,

			.flags = I2C_M_RD | I2C_M_DMA_SAFE,

			.buf = data->read_buf,

			.len = ADM1266_PMBUS_BLOCK_MAX + 2,

		}

	};

	u8 addr;

	u8 crc;

	int ret;



	mutex_lock(&data->buf_mutex);



	msgs[0].buf[0] = cmd;

	msgs[0].buf[1] = w_len;

	memcpy(&msgs[0].buf[2], data_w, w_len);



	ret = i2c_transfer(client->adapter, msgs, 2);

	if (ret != 2) {

		if (ret >= 0)

			ret = -EPROTO;



		mutex_unlock(&data->buf_mutex);



		return ret;

	}



	if (client->flags & I2C_CLIENT_PEC) {

		addr = i2c_8bit_addr_from_msg(&msgs[0]);

		crc = crc8(pmbus_crc_table, &addr, 1, 0);

		crc = crc8(pmbus_crc_table, msgs[0].buf,  msgs[0].len, crc);



		addr = i2c_8bit_addr_from_msg(&msgs[1]);

		crc = crc8(pmbus_crc_table, &addr, 1, crc);

		crc = crc8(pmbus_crc_table, msgs[1].buf,  msgs[1].buf[0] + 1, crc);



		if (crc != msgs[1].buf[msgs[1].buf[0] + 1]) {

			mutex_unlock(&data->buf_mutex);

			return -EBADMSG;

		}

	}



	memcpy(data_r, &msgs[1].buf[1], msgs[1].buf[0]);



	ret = msgs[1].buf[0];

	mutex_unlock(&data->buf_mutex);



	return ret;

}



static int adm1266_probe(struct i2c_client *client)

{
@@ -33,6 +108,9 @@ static int adm1266_probe(struct i2c_client *client) 
	for (i = 0; i < data->info.pages; i++)

		data->info.func[i] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;



	crc8_populate_msb(pmbus_crc_table, 0x7);

	mutex_init(&data->buf_mutex);



	return pmbus_do_probe(client, &data->info);

}