// 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;
}