drivers/base/regmap/regmap.c

   1 /*
   2  * Register map access API
   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/slab.h>
  14 #include <linux/module.h>
  15 #include <linux/mutex.h>
  16 #include <linux/err.h>
  17
  18 #include <linux/regmap.h>
  19
  20 #define CREATE_TRACE_POINTS
  21 #include <trace/events/regmap.h>
  22
  23 struct regmap;
  24
  25 struct regmap_format {
  26         size_t buf_size;
  27         size_t reg_bytes;
  28         size_t val_bytes;
  29         void (*format_write)(struct regmap *map,
  30                              unsigned int reg, unsigned int val);
  31         void (*format_reg)(void *buf, unsigned int reg);
  32         void (*format_val)(void *buf, unsigned int val);
  33         unsigned int (*parse_val)(void *buf);
  34 };
  35
  36 struct regmap {
  37         struct mutex lock;
  38
  39         struct device *dev; /* Device we do I/O on */
  40         void *work_buf;     /* Scratch buffer used to format I/O */
  41         struct regmap_format format;  /* Buffer format */
  42         const struct regmap_bus *bus;
  43
  44         unsigned int max_register;
  45         bool (*writeable_reg)(struct device *dev, unsigned int reg);
  46         bool (*readable_reg)(struct device *dev, unsigned int reg);
  47         bool (*volatile_reg)(struct device *dev, unsigned int reg);
  48 };
  49
  50 static void regmap_format_4_12_write(struct regmap *map,
  51                                      unsigned int reg, unsigned int val)
  52 {
  53         __be16 *out = map->work_buf;
  54         *out = cpu_to_be16((reg << 12) | val);
  55 }
  56
  57 static void regmap_format_7_9_write(struct regmap *map,
  58                                     unsigned int reg, unsigned int val)
  59 {
  60         __be16 *out = map->work_buf;
  61         *out = cpu_to_be16((reg << 9) | val);
  62 }
  63
  64 static void regmap_format_8(void *buf, unsigned int val)
  65 {
  66         u8 *b = buf;
  67
  68         b[0] = val;
  69 }
  70
  71 static void regmap_format_16(void *buf, unsigned int val)
  72 {
  73         __be16 *b = buf;
  74
  75         b[0] = cpu_to_be16(val);
  76 }
  77
  78 static unsigned int regmap_parse_8(void *buf)
  79 {
  80         u8 *b = buf;
  81
  82         return b[0];
  83 }
  84
  85 static unsigned int regmap_parse_16(void *buf)
  86 {
  87         __be16 *b = buf;
  88
  89         b[0] = be16_to_cpu(b[0]);
  90
  91         return b[0];
  92 }
  93
  94 /**
  95  * regmap_init(): Initialise register map
  96  *
  97  * @dev: Device that will be interacted with
  98  * @bus: Bus-specific callbacks to use with device
  99  * @config: Configuration for register map
 100  *
 101  * The return value will be an ERR_PTR() on error or a valid pointer to
 102  * a struct regmap.  This function should generally not be called
 103  * directly, it should be called by bus-specific init functions.
 104  */
 105 struct regmap *regmap_init(struct device *dev,
 106                            const struct regmap_bus *bus,
 107                            const struct regmap_config *config)
 108 {
 109         struct regmap *map;
 110         int ret = -EINVAL;
 111
 112         if (!bus || !config)
 113                 return NULL;
 114
 115         map = kzalloc(sizeof(*map), GFP_KERNEL);
 116         if (map == NULL) {
 117                 ret = -ENOMEM;
 118                 goto err;
 119         }
 120
 121         mutex_init(&map->lock);
 122         map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
 123         map->format.reg_bytes = config->reg_bits / 8;
 124         map->format.val_bytes = config->val_bits / 8;
 125         map->dev = dev;
 126         map->bus = bus;
 127         map->max_register = config->max_register;
 128         map->writeable_reg = config->writeable_reg;
 129         map->readable_reg = config->readable_reg;
 130         map->volatile_reg = config->volatile_reg;
 131
 132         switch (config->reg_bits) {
 133         case 4:
 134                 switch (config->val_bits) {
 135                 case 12:
 136                         map->format.format_write = regmap_format_4_12_write;
 137                         break;
 138                 default:
 139                         goto err_map;
 140                 }
 141                 break;
 142
 143         case 7:
 144                 switch (config->val_bits) {
 145                 case 9:
 146                         map->format.format_write = regmap_format_7_9_write;
 147                         break;
 148                 default:
 149                         goto err_map;
 150                 }
 151                 break;
 152
 153         case 8:
 154                 map->format.format_reg = regmap_format_8;
 155                 break;
 156
 157         case 16:
 158                 map->format.format_reg = regmap_format_16;
 159                 break;
 160
 161         default:
 162                 goto err_map;
 163         }
 164
 165         switch (config->val_bits) {
 166         case 8:
 167                 map->format.format_val = regmap_format_8;
 168                 map->format.parse_val = regmap_parse_8;
 169                 break;
 170         case 16:
 171                 map->format.format_val = regmap_format_16;
 172                 map->format.parse_val = regmap_parse_16;
 173                 break;
 174         }
 175
 176         if (!map->format.format_write &&
 177             !(map->format.format_reg && map->format.format_val))
 178                 goto err_map;
 179
 180         map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
 181         if (map->work_buf == NULL) {
 182                 ret = -ENOMEM;
 183                 goto err_bus;
 184         }
 185
 186         return map;
 187
 188 err_bus:
 189         module_put(map->bus->owner);
 190 err_map:
 191         kfree(map);
 192 err:
 193         return ERR_PTR(ret);
 194 }
 195 EXPORT_SYMBOL_GPL(regmap_init);
 196
 197 /**
 198  * regmap_exit(): Free a previously allocated register map
 199  */
 200 void regmap_exit(struct regmap *map)
 201 {
 202         kfree(map->work_buf);
 203         module_put(map->bus->owner);
 204         kfree(map);
 205 }
 206 EXPORT_SYMBOL_GPL(regmap_exit);
 207
 208 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
 209                              const void *val, size_t val_len)
 210 {
 211         void *buf;
 212         int ret = -ENOTSUPP;
 213         size_t len;
 214
 215         map->format.format_reg(map->work_buf, reg);
 216
 217         trace_regmap_hw_write_start(map->dev, reg,
 218                                     val_len / map->format.val_bytes);
 219
 220         /* If we're doing a single register write we can probably just
 221          * send the work_buf directly, otherwise try to do a gather
 222          * write.
 223          */
 224         if (val == map->work_buf + map->format.reg_bytes)
 225                 ret = map->bus->write(map->dev, map->work_buf,
 226                                       map->format.reg_bytes + val_len);
 227         else if (map->bus->gather_write)
 228                 ret = map->bus->gather_write(map->dev, map->work_buf,
 229                                              map->format.reg_bytes,
 230                                              val, val_len);
 231
 232         /* If that didn't work fall back on linearising by hand. */
 233         if (ret == -ENOTSUPP) {
 234                 len = map->format.reg_bytes + val_len;
 235                 buf = kmalloc(len, GFP_KERNEL);
 236                 if (!buf)
 237                         return -ENOMEM;
 238
 239                 memcpy(buf, map->work_buf, map->format.reg_bytes);
 240                 memcpy(buf + map->format.reg_bytes, val, val_len);
 241                 ret = map->bus->write(map->dev, buf, len);
 242
 243                 kfree(buf);
 244         }
 245
 246         trace_regmap_hw_write_done(map->dev, reg,
 247                                    val_len / map->format.val_bytes);
 248
 249         return ret;
 250 }
 251
 252 static int _regmap_write(struct regmap *map, unsigned int reg,
 253                          unsigned int val)
 254 {
 255         int ret;
 256         BUG_ON(!map->format.format_write && !map->format.format_val);
 257
 258         trace_regmap_reg_write(map->dev, reg, val);
 259
 260         if (map->format.format_write) {
 261                 map->format.format_write(map, reg, val);
 262
 263                 trace_regmap_hw_write_start(map->dev, reg, 1);
 264
 265                 ret = map->bus->write(map->dev, map->work_buf,
 266                                       map->format.buf_size);
 267
 268                 trace_regmap_hw_write_done(map->dev, reg, 1);
 269
 270                 return ret;
 271         } else {
 272                 map->format.format_val(map->work_buf + map->format.reg_bytes,
 273                                        val);
 274                 return _regmap_raw_write(map, reg,
 275                                          map->work_buf + map->format.reg_bytes,
 276                                          map->format.val_bytes);
 277         }
 278 }
 279
 280 /**
 281  * regmap_write(): Write a value to a single register
 282  *
 283  * @map: Register map to write to
 284  * @reg: Register to write to
 285  * @val: Value to be written
 286  *
 287  * A value of zero will be returned on success, a negative errno will
 288  * be returned in error cases.
 289  */
 290 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
 291 {
 292         int ret;
 293
 294         mutex_lock(&map->lock);
 295
 296         ret = _regmap_write(map, reg, val);
 297
 298         mutex_unlock(&map->lock);
 299
 300         return ret;
 301 }
 302 EXPORT_SYMBOL_GPL(regmap_write);
 303
 304 /**
 305  * regmap_raw_write(): Write raw values to one or more registers
 306  *
 307  * @map: Register map to write to
 308  * @reg: Initial register to write to
 309  * @val: Block of data to be written, laid out for direct transmission to the
 310  *       device
 311  * @val_len: Length of data pointed to by val.
 312  *
 313  * This function is intended to be used for things like firmware
 314  * download where a large block of data needs to be transferred to the
 315  * device.  No formatting will be done on the data provided.
 316  *
 317  * A value of zero will be returned on success, a negative errno will
 318  * be returned in error cases.
 319  */
 320 int regmap_raw_write(struct regmap *map, unsigned int reg,
 321                      const void *val, size_t val_len)
 322 {
 323         int ret;
 324
 325         mutex_lock(&map->lock);
 326
 327         ret = _regmap_raw_write(map, reg, val, val_len);
 328
 329         mutex_unlock(&map->lock);
 330
 331         return ret;
 332 }
 333 EXPORT_SYMBOL_GPL(regmap_raw_write);
 334
 335 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 336                             unsigned int val_len)
 337 {
 338         u8 *u8 = map->work_buf;
 339         int ret;
 340
 341         map->format.format_reg(map->work_buf, reg);
 342
 343         /*
 344          * Some buses flag reads by setting the high bits in the
 345          * register addresss; since it's always the high bits for all
 346          * current formats we can do this here rather than in
 347          * formatting.  This may break if we get interesting formats.
 348          */
 349         if (map->bus->read_flag_mask)
 350                 u8[0] |= map->bus->read_flag_mask;
 351
 352         trace_regmap_hw_read_start(map->dev, reg,
 353                                    val_len / map->format.val_bytes);
 354
 355         ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
 356                              val, val_len);
 357
 358         trace_regmap_hw_read_done(map->dev, reg,
 359                                   val_len / map->format.val_bytes);
 360
 361         return ret;
 362 }
 363
 364 static int _regmap_read(struct regmap *map, unsigned int reg,
 365                         unsigned int *val)
 366 {
 367         int ret;
 368
 369         if (!map->format.parse_val)
 370                 return -EINVAL;
 371
 372         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
 373         if (ret == 0) {
 374                 *val = map->format.parse_val(map->work_buf);
 375                 trace_regmap_reg_read(map->dev, reg, *val);
 376         }
 377
 378         return ret;
 379 }
 380
 381 /**
 382  * regmap_read(): Read a value from a single register
 383  *
 384  * @map: Register map to write to
 385  * @reg: Register to be read from
 386  * @val: Pointer to store read value
 387  *
 388  * A value of zero will be returned on success, a negative errno will
 389  * be returned in error cases.
 390  */
 391 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
 392 {
 393         int ret;
 394
 395         mutex_lock(&map->lock);
 396
 397         ret = _regmap_read(map, reg, val);
 398
 399         mutex_unlock(&map->lock);
 400
 401         return ret;
 402 }
 403 EXPORT_SYMBOL_GPL(regmap_read);
 404
 405 /**
 406  * regmap_raw_read(): Read raw data from the device
 407  *
 408  * @map: Register map to write to
 409  * @reg: First register to be read from
 410  * @val: Pointer to store read value
 411  * @val_len: Size of data to read
 412  *
 413  * A value of zero will be returned on success, a negative errno will
 414  * be returned in error cases.
 415  */
 416 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
 417                     size_t val_len)
 418 {
 419         int ret;
 420
 421         mutex_lock(&map->lock);
 422
 423         ret = _regmap_raw_read(map, reg, val, val_len);
 424
 425         mutex_unlock(&map->lock);
 426
 427         return ret;
 428 }
 429 EXPORT_SYMBOL_GPL(regmap_raw_read);
 430
 431 /**
 432  * regmap_bulk_read(): Read multiple registers from the device
 433  *
 434  * @map: Register map to write to
 435  * @reg: First register to be read from
 436  * @val: Pointer to store read value, in native register size for device
 437  * @val_count: Number of registers to read
 438  *
 439  * A value of zero will be returned on success, a negative errno will
 440  * be returned in error cases.
 441  */
 442 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
 443                      size_t val_count)
 444 {
 445         int ret, i;
 446         size_t val_bytes = map->format.val_bytes;
 447
 448         if (!map->format.parse_val)
 449                 return -EINVAL;
 450
 451         ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
 452         if (ret != 0)
 453                 return ret;
 454
 455         for (i = 0; i < val_count * val_bytes; i += val_bytes)
 456                 map->format.parse_val(val + i);
 457
 458         return 0;
 459 }
 460 EXPORT_SYMBOL_GPL(regmap_bulk_read);
 461
 462 /**
 463  * remap_update_bits: Perform a read/modify/write cycle on the register map
 464  *
 465  * @map: Register map to update
 466  * @reg: Register to update
 467  * @mask: Bitmask to change
 468  * @val: New value for bitmask
 469  *
 470  * Returns zero for success, a negative number on error.
 471  */
 472 int regmap_update_bits(struct regmap *map, unsigned int reg,
 473                        unsigned int mask, unsigned int val)
 474 {
 475         int ret;
 476         unsigned int tmp;
 477
 478         mutex_lock(&map->lock);
 479
 480         ret = _regmap_read(map, reg, &tmp);
 481         if (ret != 0)
 482                 goto out;
 483
 484         tmp &= ~mask;
 485         tmp |= val & mask;
 486
 487         ret = _regmap_write(map, reg, tmp);
 488
 489 out:
 490         mutex_unlock(&map->lock);
 491
 492         return ret;
 493 }
 494 EXPORT_SYMBOL_GPL(regmap_update_bits);