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 19static 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 38static 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 50static struct regmap_bus regmap_smbus_byte = { 51 .reg_write = regmap_smbus_byte_reg_write, 52 .reg_read = regmap_smbus_byte_reg_read, 53}; 54 55static 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 74static 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 86static struct regmap_bus regmap_smbus_word = { 87 .reg_write = regmap_smbus_word_reg_write, 88 .reg_read = regmap_smbus_word_reg_read, 89}; 90 91static 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 110static 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 122static 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 127static 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 142static 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 176static 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 204static 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 212static const struct regmap_bus *regmap_get_i2c_bus(struct i2c_client *i2c, 213 const struct regmap_config *config) 214{ 215 if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) 216 return ®map_i2c; 217 else if (config->val_bits == 16 && config->reg_bits == 8 && 218 i2c_check_functionality(i2c->adapter, 219 I2C_FUNC_SMBUS_WORD_DATA)) 220 switch (regmap_get_val_endian(&i2c->dev, NULL, config)) { 221 case REGMAP_ENDIAN_LITTLE: 222 return ®map_smbus_word; 223 case REGMAP_ENDIAN_BIG: 224 return ®map_smbus_word_swapped; 225 default: /* everything else is not supported */ 226 break; 227 } 228 else if (config->val_bits == 8 && config->reg_bits == 8 && 229 i2c_check_functionality(i2c->adapter, 230 I2C_FUNC_SMBUS_BYTE_DATA)) 231 return ®map_smbus_byte; 232 233 return ERR_PTR(-ENOTSUPP); 234} 235 236/** 237 * regmap_init_i2c(): Initialise register map 238 * 239 * @i2c: Device that will be interacted with 240 * @config: Configuration for register map 241 * 242 * The return value will be an ERR_PTR() on error or a valid pointer to 243 * a struct regmap. 244 */ 245struct regmap *regmap_init_i2c(struct i2c_client *i2c, 246 const struct regmap_config *config) 247{ 248 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 249 250 if (IS_ERR(bus)) 251 return ERR_CAST(bus); 252 253 return regmap_init(&i2c->dev, bus, &i2c->dev, config); 254} 255EXPORT_SYMBOL_GPL(regmap_init_i2c); 256 257/** 258 * devm_regmap_init_i2c(): Initialise managed register map 259 * 260 * @i2c: Device that will be interacted with 261 * @config: Configuration for register map 262 * 263 * The return value will be an ERR_PTR() on error or a valid pointer 264 * to a struct regmap. The regmap will be automatically freed by the 265 * device management code. 266 */ 267struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 268 const struct regmap_config *config) 269{ 270 const struct regmap_bus *bus = regmap_get_i2c_bus(i2c, config); 271 272 if (IS_ERR(bus)) 273 return ERR_CAST(bus); 274 275 return devm_regmap_init(&i2c->dev, bus, &i2c->dev, config); 276} 277EXPORT_SYMBOL_GPL(devm_regmap_init_i2c); 278 279MODULE_LICENSE("GPL"); 280