Quelle  regmap-i2c.c   Sprache: unbekannt

// SPDX-License-Identifier: GPL-2.0
//
// Register map access API - I2C support
//
// Copyright 2011 Wolfson Microelectronics plc
//
// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>

#include <linux/regmap.h>
#include <linux/i2c.h>
#include <linux/module.h>

#include "internal.h"

static int regmap_smbus_byte_reg_read(void *context, unsigned int reg,
          unsigned int *val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret;

 if (reg > 0xff)
  return -EINVAL;

 ret = i2c_smbus_read_byte_data(i2c, reg);
 if (ret < 0)
  return ret;

 *val = ret;

 return 0;
}

static int regmap_smbus_byte_reg_write(void *context, unsigned int reg,
           unsigned int val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);

 if (val > 0xff || reg > 0xff)
  return -EINVAL;

 return i2c_smbus_write_byte_data(i2c, reg, val);
}

static const struct regmap_bus regmap_smbus_byte = {
 .reg_write = regmap_smbus_byte_reg_write,
 .reg_read = regmap_smbus_byte_reg_read,
};

static int regmap_smbus_word_reg_read(void *context, unsigned int reg,
          unsigned int *val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret;

 if (reg > 0xff)
  return -EINVAL;

 ret = i2c_smbus_read_word_data(i2c, reg);
 if (ret < 0)
  return ret;

 *val = ret;

 return 0;
}

static int regmap_smbus_word_reg_write(void *context, unsigned int reg,
           unsigned int val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);

 if (val > 0xffff || reg > 0xff)
  return -EINVAL;

 return i2c_smbus_write_word_data(i2c, reg, val);
}

static const struct regmap_bus regmap_smbus_word = {
 .reg_write = regmap_smbus_word_reg_write,
 .reg_read = regmap_smbus_word_reg_read,
};

static int regmap_smbus_word_read_swapped(void *context, unsigned int reg,
       unsigned int *val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret;

 if (reg > 0xff)
  return -EINVAL;

 ret = i2c_smbus_read_word_swapped(i2c, reg);
 if (ret < 0)
  return ret;

 *val = ret;

 return 0;
}

static int regmap_smbus_word_write_swapped(void *context, unsigned int reg,
        unsigned int val)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);

 if (val > 0xffff || reg > 0xff)
  return -EINVAL;

 return i2c_smbus_write_word_swapped(i2c, reg, val);
}

static const struct regmap_bus regmap_smbus_word_swapped = {
 .reg_write = regmap_smbus_word_write_swapped,
 .reg_read = regmap_smbus_word_read_swapped,
};

static int regmap_i2c_write(void *context, const void *data, size_t count)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret;

 ret = i2c_master_send(i2c, data, count);
 if (ret == count)
  return 0;
 else if (ret < 0)
  return ret;
 else
  return -EIO;
}

static int regmap_i2c_gather_write(void *context,
       const void *reg, size_t reg_size,
       const void *val, size_t val_size)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 struct i2c_msg xfer[2];
 int ret;

 /* If the I2C controller can't do a gather tell the core, it
 * will substitute in a linear write for us.
 */
 if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_NOSTART))
  return -ENOTSUPP;

 xfer[0].addr = i2c->addr;
 xfer[0].flags = 0;
 xfer[0].len = reg_size;
 xfer[0].buf = (void *)reg;

 xfer[1].addr = i2c->addr;
 xfer[1].flags = I2C_M_NOSTART;
 xfer[1].len = val_size;
 xfer[1].buf = (void *)val;

 ret = i2c_transfer(i2c->adapter, xfer, 2);
 if (ret == 2)
  return 0;
 if (ret < 0)
  return ret;
 else
  return -EIO;
}

static int regmap_i2c_read(void *context,
      const void *reg, size_t reg_size,
      void *val, size_t val_size)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 struct i2c_msg xfer[2];
 int ret;

 xfer[0].addr = i2c->addr;
 xfer[0].flags = 0;
 xfer[0].len = reg_size;
 xfer[0].buf = (void *)reg;

 xfer[1].addr = i2c->addr;
 xfer[1].flags = I2C_M_RD;
 xfer[1].len = val_size;
 xfer[1].buf = val;

 ret = i2c_transfer(i2c->adapter, xfer, 2);
 if (ret == 2)
  return 0;
 else if (ret < 0)
  return ret;
 else
  return -EIO;
}

static const struct regmap_bus regmap_i2c = {
 .write = regmap_i2c_write,
 .gather_write = regmap_i2c_gather_write,
 .read = regmap_i2c_read,
 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
 .val_format_endian_default = REGMAP_ENDIAN_BIG,
};

static int regmap_i2c_smbus_i2c_write(void *context, const void *data,
          size_t count)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);

 if (count < 1)
  return -EINVAL;

 --count;
 return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count,
           ((u8 *)data + 1));
}

static int regmap_i2c_smbus_i2c_read(void *context, const void *reg,
         size_t reg_size, void *val,
         size_t val_size)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret;

 if (reg_size != 1 || val_size < 1)
  return -EINVAL;

 ret = i2c_smbus_read_i2c_block_data(i2c, ((u8 *)reg)[0], val_size, val);
 if (ret == val_size)
  return 0;
 else if (ret < 0)
  return ret;
 else
  return -EIO;
}

static const struct regmap_bus regmap_i2c_smbus_i2c_block = {
 .write = regmap_i2c_smbus_i2c_write,
 .read = regmap_i2c_smbus_i2c_read,
 .max_raw_read = I2C_SMBUS_BLOCK_MAX - 1,
 .max_raw_write = I2C_SMBUS_BLOCK_MAX - 1,
};

static int regmap_i2c_smbus_i2c_write_reg16(void *context, const void *data,
          size_t count)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);

 if (count < 2)
  return -EINVAL;

 count--;
 return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count,
           (u8 *)data + 1);
}

static int regmap_i2c_smbus_i2c_read_reg16(void *context, const void *reg,
         size_t reg_size, void *val,
         size_t val_size)
{
 struct device *dev = context;
 struct i2c_client *i2c = to_i2c_client(dev);
 int ret, count, len = val_size;

 if (reg_size != 2)
  return -EINVAL;

 ret = i2c_smbus_write_byte_data(i2c, ((u16 *)reg)[0] & 0xff,
     ((u16 *)reg)[0] >> 8);
 if (ret < 0)
  return ret;

 count = 0;
 do {
  /* Current Address Read */
  ret = i2c_smbus_read_byte(i2c);
  if (ret < 0)
   break;

  *((u8 *)val++) = ret;
  count++;
  len--;
 } while (len > 0);

 if (count == val_size)
  return 0;
 else if (ret < 0)
  return ret;
 else
  return -EIO;
}

static const struct regmap_bus regmap_i2c_smbus_i2c_block_reg16 = {
 .write = regmap_i2c_smbus_i2c_write_reg16,
 .read = regmap_i2c_smbus_i2c_read_reg16,
 .max_raw_read = I2C_SMBUS_BLOCK_MAX - 2,
 .max_raw_write = I2C_SMBUS_BLOCK_MAX - 2,
};

static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
     const struct regmap_config *config)
{
 const struct i2c_adapter_quirks *quirks;
 const struct regmap_bus *bus = NULL;
 struct regmap_bus *ret_bus;
 u16 max_read = 0, max_write = 0;

 if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
  bus = ®map_i2c;
 else if (config->val_bits == 8 && config->reg_bits == 8 &&
   i2c_check_functionality(i2c->adapter,
      I2C_FUNC_SMBUS_I2C_BLOCK))
  bus = ®map_i2c_smbus_i2c_block;
 else if (config->val_bits == 8 && config->reg_bits == 16 &&
  i2c_check_functionality(i2c->adapter,
     I2C_FUNC_SMBUS_I2C_BLOCK))
  bus = ®map_i2c_smbus_i2c_block_reg16;
 else if (config->val_bits == 16 && config->reg_bits == 8 &&
   i2c_check_functionality(i2c->adapter,
      I2C_FUNC_SMBUS_WORD_DATA))
  switch (regmap_get_val_endian(&i2c->dev, NULL, config)) {
  case REGMAP_ENDIAN_LITTLE:
   bus = ®map_smbus_word;
   break;
  case REGMAP_ENDIAN_BIG:
   bus = ®map_smbus_word_swapped;
   break;
  default:  /* everything else is not supported */
   break;
  }
 else if (config->val_bits == 8 && config->reg_bits == 8 &&
   i2c_check_functionality(i2c->adapter,
      I2C_FUNC_SMBUS_BYTE_DATA))
  bus = ®map_smbus_byte;

 if (!bus)
  return ERR_PTR(-ENOTSUPP);

 quirks = i2c->adapter->quirks;
 if (quirks) {
  if (quirks->max_read_len &&
      (bus->max_raw_read == 0 || bus->max_raw_read > quirks->max_read_len))
   max_read = quirks->max_read_len;

  if (quirks->max_write_len &&
      (bus->max_raw_write == 0 || bus->max_raw_write > quirks->max_write_len))
   max_write = quirks->max_write_len -
    (config->reg_bits + config->pad_bits) / BITS_PER_BYTE;

  if (max_read || max_write) {
   ret_bus = kmemdup(bus, sizeof(*bus), GFP_KERNEL);
   if (!ret_bus)
    return ERR_PTR(-ENOMEM);
   ret_bus->free_on_exit = true;
   ret_bus->max_raw_read = max_read;
   ret_bus->max_raw_write = max_write;
   bus = ret_bus;
  }
 }

 return bus;
}

struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
     const struct regmap_config *config,
     struct lock_class_key *lock_key,
     const char *lock_name)
{
 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);

 if (IS_ERR(bus))
  return ERR_CAST(bus);

 return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
        lock_key, lock_name);
}
EXPORT_SYMBOL_GPL(__regmap_init_i2c);

struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
          const struct regmap_config *config,
          struct lock_class_key *lock_key,
          const char *lock_name)
{
 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);

 if (IS_ERR(bus))
  return ERR_CAST(bus);

 return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
      lock_key, lock_name);
}
EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);

MODULE_DESCRIPTION("Register map access API - I2C support");
MODULE_LICENSE("GPL");