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
  15 static 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
  34 static 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
  46 static struct regmap_bus regmap_smbus_byte = {
  47         .reg_write = regmap_smbus_byte_reg_write,
  48         .reg_read = regmap_smbus_byte_reg_read,
  49 };
  50
  51 static 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
  70 static 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
  82 static struct regmap_bus regmap_smbus_word = {
  83         .reg_write = regmap_smbus_word_reg_write,
  84         .reg_read = regmap_smbus_word_reg_read,
  85 };
  86
  87 static 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
 106 static 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
 118 static 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
 123 static 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
 138 static 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
 172 static 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
 200 static 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
 208 static 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
 222 static 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
 242 static 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
 249 static 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
 277 struct 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 }
 290 EXPORT_SYMBOL_GPL(__regmap_init_i2c);
 291
 292 struct 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 }
 305 EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c);
 306
 307 MODULE_LICENSE("GPL");