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 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 &regmap_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