Contributors: 1
Author Tokens Token Proportion Commits Commit Proportion
Martin Tůma 656 100.00% 1 100.00%
Total 656 1 


// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2021-2023 Digiteq Automotive
 *     author: Martin Tuma <martin.tuma@digiteqautomotive.com>
 *
 * The i2c module unifies the I2C access to the serializes/deserializes. The I2C
 * chips on the GMSL module use 16b addressing, the FPDL3 chips use standard
 * 8b addressing.
 */

#include "mgb4_i2c.h"

static int read_r16(struct i2c_client *client, u16 reg, u8 *val, int len)
{
	int ret;
	u8 buf[2];
	struct i2c_msg msg[2] = {
		{
			.addr = client->addr,
			.flags = 0,
			.len = 2,
			.buf = buf,
		}, {
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = len,
			.buf = val,
		}
	};

	buf[0] = (reg >> 8) & 0xff;
	buf[1] = (reg >> 0) & 0xff;

	ret = i2c_transfer(client->adapter, msg, 2);
	if (ret < 0)
		return ret;
	else if (ret != 2)
		return -EREMOTEIO;
	else
		return 0;
}

static int write_r16(struct i2c_client *client, u16 reg, const u8 *val, int len)
{
	int ret;
	u8 buf[4];
	struct i2c_msg msg[1] = {
		{
			.addr = client->addr,
			.flags = 0,
			.len = 2 + len,
			.buf = buf,
		}
	};

	if (2 + len > sizeof(buf))
		return -EINVAL;

	buf[0] = (reg >> 8) & 0xff;
	buf[1] = (reg >> 0) & 0xff;
	memcpy(&buf[2], val, len);

	ret = i2c_transfer(client->adapter, msg, 1);
	if (ret < 0)
		return ret;
	else if (ret != 1)
		return -EREMOTEIO;
	else
		return 0;
}

int mgb4_i2c_init(struct mgb4_i2c_client *client, struct i2c_adapter *adap,
		  struct i2c_board_info const *info, int addr_size)
{
	client->client = i2c_new_client_device(adap, info);
	if (IS_ERR(client->client))
		return PTR_ERR(client->client);

	client->addr_size = addr_size;

	return 0;
}

void mgb4_i2c_free(struct mgb4_i2c_client *client)
{
	i2c_unregister_device(client->client);
}

s32 mgb4_i2c_read_byte(struct mgb4_i2c_client *client, u16 reg)
{
	int ret;
	u8 b;

	if (client->addr_size == 8)
		return i2c_smbus_read_byte_data(client->client, reg);

	ret = read_r16(client->client, reg, &b, 1);
	if (ret < 0)
		return ret;

	return (s32)b;
}

s32 mgb4_i2c_write_byte(struct mgb4_i2c_client *client, u16 reg, u8 val)
{
	if (client->addr_size == 8)
		return i2c_smbus_write_byte_data(client->client, reg, val);
	else
		return write_r16(client->client, reg, &val, 1);
}

s32 mgb4_i2c_mask_byte(struct mgb4_i2c_client *client, u16 reg, u8 mask, u8 val)
{
	s32 ret;

	if (mask != 0xFF) {
		ret = mgb4_i2c_read_byte(client, reg);
		if (ret < 0)
			return ret;
		val |= (u8)ret & ~mask;
	}

	return mgb4_i2c_write_byte(client, reg, val);
}

int mgb4_i2c_configure(struct mgb4_i2c_client *client,
		       const struct mgb4_i2c_kv *values, size_t count)
{
	size_t i;
	s32 res;

	for (i = 0; i < count; i++) {
		res = mgb4_i2c_mask_byte(client, values[i].reg, values[i].mask,
					 values[i].val);
		if (res < 0)
			return res;
	}

	return 0;
}