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

   1// SPDX-License-Identifier: GPL-2.0
   2// Register map access API - SCCB support
   3
   4#include <linux/i2c.h>
   5#include <linux/module.h>
   6#include <linux/regmap.h>
   7
   8#include "internal.h"
   9
  10/**
  11 * sccb_is_available - Check if the adapter supports SCCB protocol
  12 * @adap: I2C adapter
  13 *
  14 * Return true if the I2C adapter is capable of using SCCB helper functions,
  15 * false otherwise.
  16 */
  17static bool sccb_is_available(struct i2c_adapter *adap)
  18{
  19        u32 needed_funcs = I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
  20
  21        /*
  22         * If we ever want support for hardware doing SCCB natively, we will
  23         * introduce a sccb_xfer() callback to struct i2c_algorithm and check
  24         * for it here.
  25         */
  26
  27        return (i2c_get_functionality(adap) & needed_funcs) == needed_funcs;
  28}
  29
  30/**
  31 * regmap_sccb_read - Read data from SCCB slave device
  32 * @context: Device that will be interacted with
  33 * @reg: Register to be read from
  34 * @val: Pointer to store read value
  35 *
  36 * This executes the 2-phase write transmission cycle that is followed by a
  37 * 2-phase read transmission cycle, returning negative errno else zero on
  38 * success.
  39 */
  40static int regmap_sccb_read(void *context, unsigned int reg, unsigned int *val)
  41{
  42        struct device *dev = context;
  43        struct i2c_client *i2c = to_i2c_client(dev);
  44        int ret;
  45        union i2c_smbus_data data;
  46
  47        i2c_lock_bus(i2c->adapter, I2C_LOCK_SEGMENT);
  48
  49        ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
  50                               I2C_SMBUS_WRITE, reg, I2C_SMBUS_BYTE, NULL);
  51        if (ret < 0)
  52                goto out;
  53
  54        ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
  55                               I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data);
  56        if (ret < 0)
  57                goto out;
  58
  59        *val = data.byte;
  60out:
  61        i2c_unlock_bus(i2c->adapter, I2C_LOCK_SEGMENT);
  62
  63        return ret;
  64}
  65
  66/**
  67 * regmap_sccb_write - Write data to SCCB slave device
  68 * @context: Device that will be interacted with
  69 * @reg: Register to write to
  70 * @val: Value to be written
  71 *
  72 * This executes the SCCB 3-phase write transmission cycle, returning negative
  73 * errno else zero on success.
  74 */
  75static int regmap_sccb_write(void *context, unsigned int reg, unsigned int val)
  76{
  77        struct device *dev = context;
  78        struct i2c_client *i2c = to_i2c_client(dev);
  79
  80        return i2c_smbus_write_byte_data(i2c, reg, val);
  81}
  82
  83static struct regmap_bus regmap_sccb_bus = {
  84        .reg_write = regmap_sccb_write,
  85        .reg_read = regmap_sccb_read,
  86};
  87
  88static const struct regmap_bus *regmap_get_sccb_bus(struct i2c_client *i2c,
  89                                        const struct regmap_config *config)
  90{
  91        if (config->val_bits == 8 && config->reg_bits == 8 &&
  92                        sccb_is_available(i2c->adapter))
  93                return &regmap_sccb_bus;
  94
  95        return ERR_PTR(-ENOTSUPP);
  96}
  97
  98struct regmap *__regmap_init_sccb(struct i2c_client *i2c,
  99                                  const struct regmap_config *config,
 100                                  struct lock_class_key *lock_key,
 101                                  const char *lock_name)
 102{
 103        const struct regmap_bus *bus = regmap_get_sccb_bus(i2c, config);
 104
 105        if (IS_ERR(bus))
 106                return ERR_CAST(bus);
 107
 108        return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
 109                             lock_key, lock_name);
 110}
 111EXPORT_SYMBOL_GPL(__regmap_init_sccb);
 112
 113struct regmap *__devm_regmap_init_sccb(struct i2c_client *i2c,
 114                                       const struct regmap_config *config,
 115                                       struct lock_class_key *lock_key,
 116                                       const char *lock_name)
 117{
 118        const struct regmap_bus *bus = regmap_get_sccb_bus(i2c, config);
 119
 120        if (IS_ERR(bus))
 121                return ERR_CAST(bus);
 122
 123        return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
 124                                  lock_key, lock_name);
 125}
 126EXPORT_SYMBOL_GPL(__devm_regmap_init_sccb);
 127
 128MODULE_LICENSE("GPL v2");
 129