LXR linux/drivers/base/regmap/regmap-i2c.c

   1// SPDX-License-Identifier: GPL-2.0
   2//
   3// Register map access API - I2C support
   4//
   5// Copyright 2011 Wolfson Microelectronics plc
   6//
   7// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8
   9#include <linux/regmap.h>
  10#include <linux/i2c.h>
  11#include <linux/module.h>
  12
  13#include "internal.h"
  14
  15static int regmap_smbus_byte_reg_read(void *context, unsigned int reg,
  16                                      unsigned int *val)
  17{
  18        struct device *dev = context;
  19        struct i2c_client *i2c = to_i2c_client(dev);
  20        int ret;
  21
  22        if (reg > 0xff)
  23                return -EINVAL;
  24
  25        ret = i2c_smbus_read_byte_data(i2c, reg);
  26        if (ret < 0)
  27                return ret;
  28
  29        *val = ret;
  30
  31        return 0;
  32}
  33
  34static int regmap_smbus_byte_reg_write(void *context, unsigned int reg,
  35                                       unsigned int val)
  36{
  37        struct device *dev = context;
  38        struct i2c_client *i2c = to_i2c_client(dev);
  39
  40        if (val > 0xff || reg > 0xff)
  41                return -EINVAL;
  42
  43        return i2c_smbus_write_byte_data(i2c, reg, val);
  44}
  45
  46static const struct regmap_bus regmap_smbus_byte = {
  47        .reg_write = regmap_smbus_byte_reg_write,
  48        .reg_read = regmap_smbus_byte_reg_read,
  49};
  50
  51static int regmap_smbus_word_reg_read(void *context, unsigned int reg,
  52                                      unsigned int *val)
  53{
  54        struct device *dev = context;
  55        struct i2c_client *i2c = to_i2c_client(dev);
  56        int ret;
  57
  58        if (reg > 0xff)
  59                return -EINVAL;
  60
  61        ret = i2c_smbus_read_word_data(i2c, reg);
  62        if (ret < 0)
  63                return ret;
  64
  65        *val = ret;
  66
  67        return 0;
  68}
  69
  70static int regmap_smbus_word_reg_write(void *context, unsigned int reg,
  71                                       unsigned int val)
  72{
  73        struct device *dev = context;
  74        struct i2c_client *i2c = to_i2c_client(dev);
  75
  76        if (val > 0xffff || reg > 0xff)
  77                return -EINVAL;
  78
  79        return i2c_smbus_write_word_data(i2c, reg, val);
  80}
  81
  82static const struct regmap_bus regmap_smbus_word = {
  83        .reg_write = regmap_smbus_word_reg_write,
  84        .reg_read = regmap_smbus_word_reg_read,
  85};
  86
  87static int regmap_smbus_word_read_swapped(void *context, unsigned int reg,
  88                                          unsigned int *val)
  89{
  90        struct device *dev = context;
  91        struct i2c_client *i2c = to_i2c_client(dev);
  92        int ret;
  93
  94        if (reg > 0xff)
  95                return -EINVAL;
  96
  97        ret = i2c_smbus_read_word_swapped(i2c, reg);
  98        if (ret < 0)
  99                return ret;
 100
 101        *val = ret;
 102
 103        return 0;
 104}
 105
 106static int regmap_smbus_word_write_swapped(void *context, unsigned int reg,
 107                                           unsigned int val)
 108{
 109        struct device *dev = context;
 110        struct i2c_client *i2c = to_i2c_client(dev);
 111
 112        if (val > 0xffff || reg > 0xff)
 113                return -EINVAL;
 114
 115        return i2c_smbus_write_word_swapped(i2c, reg, val);
 116}
 117
 118static const struct regmap_bus regmap_smbus_word_swapped = {
 119        .reg_write = regmap_smbus_word_write_swapped,
 120        .reg_read = regmap_smbus_word_read_swapped,
 121};
 122
 123static int regmap_i2c_write(void *context, const void *data, size_t count)
 124{
 125        struct device *dev = context;
 126        struct i2c_client *i2c = to_i2c_client(dev);
 127        int ret;
 128
 129        ret = i2c_master_send(i2c, data, count);
 130        if (ret == count)
 131                return 0;
 132        else if (ret < 0)
 133                return ret;
 134        else
 135                return -EIO;
 136}
 137
 138static int regmap_i2c_gather_write(void *context,
 139                                   const void *reg, size_t reg_size,
 140                                   const void *val, size_t val_size)
 141{
 142        struct device *dev = context;
 143        struct i2c_client *i2c = to_i2c_client(dev);
 144        struct i2c_msg xfer[2];
 145        int ret;
 146
 147        /* If the I2C controller can't do a gather tell the core, it
 148         * will substitute in a linear write for us.
 149         */
 150        if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_NOSTART))
 151                return -ENOTSUPP;
 152
 153        xfer[0].addr = i2c->addr;
 154        xfer[0].flags = 0;
 155        xfer[0].len = reg_size;
 156        xfer[0].buf = (void *)reg;
 157
 158        xfer[1].addr = i2c->addr;
 159        xfer[1].flags = I2C_M_NOSTART;
 160        xfer[1].len = val_size;
 161        xfer[1].buf = (void *)val;
 162
 163        ret = i2c_transfer(i2c->adapter, xfer, 2);
 164        if (ret == 2)
 165                return 0;
 166        if (ret < 0)
 167                return ret;
 168        else
 169                return -EIO;
 170}
 171
 172static int regmap_i2c_read(void *context,
 173                           const void *reg, size_t reg_size,
 174                           void *val, size_t val_size)
 175{
 176        struct device *dev = context;
 177        struct i2c_client *i2c = to_i2c_client(dev);
 178        struct i2c_msg xfer[2];
 179        int ret;
 180
 181        xfer[0].addr = i2c->addr;
 182        xfer[0].flags = 0;
 183        xfer[0].len = reg_size;
 184        xfer[0].buf = (void *)reg;
 185
 186        xfer[1].addr = i2c->addr;
 187        xfer[1].flags = I2C_M_RD;
 188        xfer[1].len = val_size;
 189        xfer[1].buf = val;
 190
 191        ret = i2c_transfer(i2c->adapter, xfer, 2);
 192        if (ret == 2)
 193                return 0;
 194        else if (ret < 0)
 195                return ret;
 196        else
 197                return -EIO;
 198}
 199
 200static const struct regmap_bus regmap_i2c = {
 201        .write = regmap_i2c_write,
 202        .gather_write = regmap_i2c_gather_write,
 203        .read = regmap_i2c_read,
 204        .reg_format_endian_default = REGMAP_ENDIAN_BIG,
 205        .val_format_endian_default = REGMAP_ENDIAN_BIG,
 206};
 207
 208static int regmap_i2c_smbus_i2c_write(void *context, const void *data,
 209                                      size_t count)
 210{
 211        struct device *dev = context;
 212        struct i2c_client *i2c = to_i2c_client(dev);
 213
 214        if (count < 1)
 215                return -EINVAL;
 216
 217        --count;
 218        return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count,
 219                                              ((u8 *)data + 1));
 220}
 221
 222static int regmap_i2c_smbus_i2c_read(void *context, const void *reg,
 223                                     size_t reg_size, void *val,
 224                                     size_t val_size)
 225{
 226        struct device *dev = context;
 227        struct i2c_client *i2c = to_i2c_client(dev);
 228        int ret;
 229
 230        if (reg_size != 1 || val_size < 1)
 231                return -EINVAL;
 232
 233        ret = i2c_smbus_read_i2c_block_data(i2c, ((u8 *)reg)[0], val_size, val);
 234        if (ret == val_size)
 235                return 0;
 236        else if (ret < 0)
 237                return ret;
 238        else
 239                return -EIO;
 240}
 241
 242static const struct regmap_bus regmap_i2c_smbus_i2c_block = {
 243        .write = regmap_i2c_smbus_i2c_write,
 244        .read = regmap_i2c_smbus_i2c_read,
 245        .max_raw_read = I2C_SMBUS_BLOCK_MAX,
 246        .max_raw_write = I2C_SMBUS_BLOCK_MAX,
 247};
 248
 249static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c,
 250                                        const struct regmap_config *config)
 251{
 252        if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
 253                return &regmap_i2c;
 254        else if (config->val_bits == 8 && config->reg_bits == 8 &&
 255                 i2c_check_functionality(i2c->adapter,
 256                                         I2C_FUNC_SMBUS_I2C_BLOCK))
 257                return &regmap_i2c_smbus_i2c_block;
 258        else if (config->val_bits == 16 && config->reg_bits == 8 &&
 259                 i2c_check_functionality(i2c->adapter,
 260                                         I2C_FUNC_SMBUS_WORD_DATA))
 261                switch (regmap_get_val_endian(&i2c->dev, NULL, config)) {
 262                case REGMAP_ENDIAN_LITTLE:
 263                        return &regmap_smbus_word;
 264                case REGMAP_ENDIAN_BIG:
 265                        return &regmap_smbus_word_swapped;
 266                default:                /* everything else is not supported */
 267                        break;
 268                }
 269        else if (config->val_bits == 8 && config->reg_bits == 8 &&
 270                 i2c_check_functionality(i2c->adapter,
 271                                         I2C_FUNC_SMBUS_BYTE_DATA))
 272                return &regmap_smbus_byte;
 273
 274        return ERR_PTR(-ENOTSUPP);
 275}
 276
 277struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
 278                                 const struct regmap_config *config,
 279                                 struct lock_class_key *lock_key,
 280                                 const char *lock_name)
 281{
 282        const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
 283
 284        if (IS_ERR(bus))
 285                return ERR_CAST(bus);
 286
 287        return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
 288                             lock_key, lock_name);
 289}
 290EXPORT_SYMBOL_GPL(__regmap_init_i2c);
 291
 292struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
 293                                      const struct regmap_config *config,
 294                                      struct lock_class_key *lock_key,
 295                                      const char *lock_name)
 296{
 297        const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config);
 298
 299        if (IS_ERR(bus))
 300                return ERR_CAST(bus);
 301
 302        return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
 303                                  lock_key, lock_name);
 304}
 305EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
 306
 307MODULE_LICENSE("GPL");
 308