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 */ 17 static 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 */ 40 static 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; 60 out: 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 */ 75 static 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 83 static const struct regmap_bus regmap_sccb_bus = { 84 .reg_write = regmap_sccb_write, 85 .reg_read = regmap_sccb_read, 86 }; 87 88 static 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 ®map_sccb_bus; 94 95 return ERR_PTR(-ENOTSUPP); 96 } 97 98 struct 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 } 111 EXPORT_SYMBOL_GPL(__regmap_init_sccb); 112 113 struct 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 } 126 EXPORT_SYMBOL_GPL(__devm_regmap_init_sccb); 127 128 MODULE_LICENSE("GPL v2"); 129