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

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