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 19 static 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 38 static 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 50 static struct regmap_bus regmap_smbus_byte = { 51 .reg_write = regmap_smbus_byte_reg_write, 52 .reg_read = regmap_smbus_byte_reg_read, 53 }; 54 55 static 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 74 static 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 86 static struct regmap_bus regmap_smbus_word = { 87 .reg_write = regmap_smbus_word_reg_write, 88 .reg_read = regmap_smbus_word_reg_read, 89 }; 90 91 static 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 110 static 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 122 static 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 127 static 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 142 static 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 176 static 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 204 static 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 212 static 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 if (count >= I2C_SMBUS_BLOCK_MAX) 221 return -E2BIG; 222 223 --count; 224 return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count, 225 ((u8 *)data + 1)); 226 } 227 228 static int regmap_i2c_smbus_i2c_read(void *context, const void *reg, 229 size_t reg_size, void *val, 230 size_t val_size) 231 { 232 struct device *dev = context; 233 struct i2c_client *i2c = to_i2c_client(dev); 234 int ret; 235 236 if (reg_size != 1 || val_size < 1) 237 return -EINVAL; 238 if (val_size >= I2C_SMBUS_BLOCK_MAX) 239 return -E2BIG; 240 241 ret = i2c_smbus_read_i2c_block_data(i2c, ((u8 *)reg)[0], val_size, val); 242 if (ret == val_size) 243 return 0; 244 else if (ret < 0) 245 return ret; 246 else 247 return -EIO; 248 } 249 250 static struct regmap_bus regmap_i2c_smbus_i2c_block = { 251 .write = regmap_i2c_smbus_i2c_write, 252 .read = regmap_i2c_smbus_i2c_read, 253 .max_raw_read = I2C_SMBUS_BLOCK_MAX, 254 .max_raw_write = I2C_SMBUS_BLOCK_MAX, 255 }; 256 257 static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c, 258 const struct regmap_config *config) 259 { 260 if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) 261 return ®map_i2c; 262 else if (config->val_bits == 8 && config->reg_bits == 8 && 263 i2c_check_functionality(i2c->adapter, 264 I2C_FUNC_SMBUS_I2C_BLOCK)) 265 return ®map_i2c_smbus_i2c_block; 266 else if (config->val_bits == 16 && config->reg_bits == 8 && 267 i2c_check_functionality(i2c->adapter, 268 I2C_FUNC_SMBUS_WORD_DATA)) 269 switch (regmap_get_val_endian(&i2c->dev, NULL, config)) { 270 case REGMAP_ENDIAN_LITTLE: 271 return ®map_smbus_word; 272 case REGMAP_ENDIAN_BIG: 273 return ®map_smbus_word_swapped; 274 default: /* everything else is not supported */ 275 break; 276 } 277 else if (config->val_bits == 8 && config->reg_bits == 8 && 278 i2c_check_functionality(i2c->adapter, 279 I2C_FUNC_SMBUS_BYTE_DATA)) 280 return ®map_smbus_byte; 281 282 return ERR_PTR(-ENOTSUPP); 283 } 284 285 struct regmap *__regmap_init_i2c(struct i2c_client *i2c, 286 const struct regmap_config *config, 287 struct lock_class_key *lock_key, 288 const char *lock_name) 289 { 290 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 291 292 if (IS_ERR(bus)) 293 return ERR_CAST(bus); 294 295 return __regmap_init(&i2c->dev, bus, &i2c->dev, config, 296 lock_key, lock_name); 297 } 298 EXPORT_SYMBOL_GPL(__regmap_init_i2c); 299 300 struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c, 301 const struct regmap_config *config, 302 struct lock_class_key *lock_key, 303 const char *lock_name) 304 { 305 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 306 307 if (IS_ERR(bus)) 308 return ERR_CAST(bus); 309 310 return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config, 311 lock_key, lock_name); 312 } 313 EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c); 314 315 MODULE_LICENSE("GPL"); 316