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 221 --count; 222 return i2c_smbus_write_i2c_block_data(i2c, ((u8 *)data)[0], count, 223 ((u8 *)data + 1)); 224 } 225 226 static 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 246 static 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 253 static 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 ®map_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 ®map_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 ®map_smbus_word; 268 case REGMAP_ENDIAN_BIG: 269 return ®map_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 ®map_smbus_byte; 277 278 return ERR_PTR(-ENOTSUPP); 279 } 280 281 struct 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 } 294 EXPORT_SYMBOL_GPL(__regmap_init_i2c); 295 296 struct 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 } 309 EXPORT_SYMBOL_GPL(__devm_regmap_init_i2c); 310 311 MODULE_LICENSE("GPL"); 312