drivers/nvmem/core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * nvmem framework core.
   4  *
   5  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
   6  * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/export.h>
  11 #include <linux/fs.h>
  12 #include <linux/idr.h>
  13 #include <linux/init.h>
  14 #include <linux/kref.h>
  15 #include <linux/module.h>
  16 #include <linux/nvmem-consumer.h>
  17 #include <linux/nvmem-provider.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/of.h>
  20 #include <linux/slab.h>
  21
  22 struct nvmem_device {
  23         struct module           *owner;
  24         struct device           dev;
  25         int                     stride;
  26         int                     word_size;
  27         int                     id;
  28         struct kref             refcnt;
  29         size_t                  size;
  30         bool                    read_only;
  31         bool                    root_only;
  32         int                     flags;
  33         enum nvmem_type         type;
  34         struct bin_attribute    eeprom;
  35         struct device           *base_dev;
  36         struct list_head        cells;
  37         nvmem_reg_read_t        reg_read;
  38         nvmem_reg_write_t       reg_write;
  39         struct gpio_desc        *wp_gpio;
  40         void *priv;
  41 };
  42
  43 #define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
  44
  45 #define FLAG_COMPAT             BIT(0)
  46
  47 struct nvmem_cell {
  48         const char              *name;
  49         int                     offset;
  50         int                     bytes;
  51         int                     bit_offset;
  52         int                     nbits;
  53         struct device_node      *np;
  54         struct nvmem_device     *nvmem;
  55         struct list_head        node;
  56 };
  57
  58 static DEFINE_MUTEX(nvmem_mutex);
  59 static DEFINE_IDA(nvmem_ida);
  60
  61 static DEFINE_MUTEX(nvmem_cell_mutex);
  62 static LIST_HEAD(nvmem_cell_tables);
  63
  64 static DEFINE_MUTEX(nvmem_lookup_mutex);
  65 static LIST_HEAD(nvmem_lookup_list);
  66
  67 static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
  68
  69 static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
  70                           void *val, size_t bytes)
  71 {
  72         if (nvmem->reg_read)
  73                 return nvmem->reg_read(nvmem->priv, offset, val, bytes);
  74
  75         return -EINVAL;
  76 }
  77
  78 static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
  79                            void *val, size_t bytes)
  80 {
  81         int ret;
  82
  83         if (nvmem->reg_write) {
  84                 gpiod_set_value_cansleep(nvmem->wp_gpio, 0);
  85                 ret = nvmem->reg_write(nvmem->priv, offset, val, bytes);
  86                 gpiod_set_value_cansleep(nvmem->wp_gpio, 1);
  87                 return ret;
  88         }
  89
  90         return -EINVAL;
  91 }
  92
  93 #ifdef CONFIG_NVMEM_SYSFS
  94 static const char * const nvmem_type_str[] = {
  95         [NVMEM_TYPE_UNKNOWN] = "Unknown",
  96         [NVMEM_TYPE_EEPROM] = "EEPROM",
  97         [NVMEM_TYPE_OTP] = "OTP",
  98         [NVMEM_TYPE_BATTERY_BACKED] = "Battery backed",
  99 };
 100
 101 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 102 static struct lock_class_key eeprom_lock_key;
 103 #endif
 104
 105 static ssize_t type_show(struct device *dev,
 106                          struct device_attribute *attr, char *buf)
 107 {
 108         struct nvmem_device *nvmem = to_nvmem_device(dev);
 109
 110         return sprintf(buf, "%s\n", nvmem_type_str[nvmem->type]);
 111 }
 112
 113 static DEVICE_ATTR_RO(type);
 114
 115 static struct attribute *nvmem_attrs[] = {
 116         &dev_attr_type.attr,
 117         NULL,
 118 };
 119
 120 static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
 121                                    struct bin_attribute *attr, char *buf,
 122                                    loff_t pos, size_t count)
 123 {
 124         struct device *dev;
 125         struct nvmem_device *nvmem;
 126         int rc;
 127
 128         if (attr->private)
 129                 dev = attr->private;
 130         else
 131                 dev = kobj_to_dev(kobj);
 132         nvmem = to_nvmem_device(dev);
 133
 134         /* Stop the user from reading */
 135         if (pos >= nvmem->size)
 136                 return 0;
 137
 138         if (!IS_ALIGNED(pos, nvmem->stride))
 139                 return -EINVAL;
 140
 141         if (count < nvmem->word_size)
 142                 return -EINVAL;
 143
 144         if (pos + count > nvmem->size)
 145                 count = nvmem->size - pos;
 146
 147         count = round_down(count, nvmem->word_size);
 148
 149         if (!nvmem->reg_read)
 150                 return -EPERM;
 151
 152         rc = nvmem_reg_read(nvmem, pos, buf, count);
 153
 154         if (rc)
 155                 return rc;
 156
 157         return count;
 158 }
 159
 160 static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
 161                                     struct bin_attribute *attr, char *buf,
 162                                     loff_t pos, size_t count)
 163 {
 164         struct device *dev;
 165         struct nvmem_device *nvmem;
 166         int rc;
 167
 168         if (attr->private)
 169                 dev = attr->private;
 170         else
 171                 dev = kobj_to_dev(kobj);
 172         nvmem = to_nvmem_device(dev);
 173
 174         /* Stop the user from writing */
 175         if (pos >= nvmem->size)
 176                 return -EFBIG;
 177
 178         if (!IS_ALIGNED(pos, nvmem->stride))
 179                 return -EINVAL;
 180
 181         if (count < nvmem->word_size)
 182                 return -EINVAL;
 183
 184         if (pos + count > nvmem->size)
 185                 count = nvmem->size - pos;
 186
 187         count = round_down(count, nvmem->word_size);
 188
 189         if (!nvmem->reg_write)
 190                 return -EPERM;
 191
 192         rc = nvmem_reg_write(nvmem, pos, buf, count);
 193
 194         if (rc)
 195                 return rc;
 196
 197         return count;
 198 }
 199
 200 static umode_t nvmem_bin_attr_get_umode(struct nvmem_device *nvmem)
 201 {
 202         umode_t mode = 0400;
 203
 204         if (!nvmem->root_only)
 205                 mode |= 0044;
 206
 207         if (!nvmem->read_only)
 208                 mode |= 0200;
 209
 210         if (!nvmem->reg_write)
 211                 mode &= ~0200;
 212
 213         if (!nvmem->reg_read)
 214                 mode &= ~0444;
 215
 216         return mode;
 217 }
 218
 219 static umode_t nvmem_bin_attr_is_visible(struct kobject *kobj,
 220                                          struct bin_attribute *attr, int i)
 221 {
 222         struct device *dev = kobj_to_dev(kobj);
 223         struct nvmem_device *nvmem = to_nvmem_device(dev);
 224
 225         return nvmem_bin_attr_get_umode(nvmem);
 226 }
 227
 228 /* default read/write permissions */
 229 static struct bin_attribute bin_attr_rw_nvmem = {
 230         .attr   = {
 231                 .name   = "nvmem",
 232                 .mode   = 0644,
 233         },
 234         .read   = bin_attr_nvmem_read,
 235         .write  = bin_attr_nvmem_write,
 236 };
 237
 238 static struct bin_attribute *nvmem_bin_attributes[] = {
 239         &bin_attr_rw_nvmem,
 240         NULL,
 241 };
 242
 243 static const struct attribute_group nvmem_bin_group = {
 244         .bin_attrs      = nvmem_bin_attributes,
 245         .attrs          = nvmem_attrs,
 246         .is_bin_visible = nvmem_bin_attr_is_visible,
 247 };
 248
 249 static const struct attribute_group *nvmem_dev_groups[] = {
 250         &nvmem_bin_group,
 251         NULL,
 252 };
 253
 254 static struct bin_attribute bin_attr_nvmem_eeprom_compat = {
 255         .attr   = {
 256                 .name   = "eeprom",
 257         },
 258         .read   = bin_attr_nvmem_read,
 259         .write  = bin_attr_nvmem_write,
 260 };
 261
 262 /*
 263  * nvmem_setup_compat() - Create an additional binary entry in
 264  * drivers sys directory, to be backwards compatible with the older
 265  * drivers/misc/eeprom drivers.
 266  */
 267 static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
 268                                     const struct nvmem_config *config)
 269 {
 270         int rval;
 271
 272         if (!config->compat)
 273                 return 0;
 274
 275         if (!config->base_dev)
 276                 return -EINVAL;
 277
 278         nvmem->eeprom = bin_attr_nvmem_eeprom_compat;
 279         nvmem->eeprom.attr.mode = nvmem_bin_attr_get_umode(nvmem);
 280         nvmem->eeprom.size = nvmem->size;
 281 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 282         nvmem->eeprom.attr.key = &eeprom_lock_key;
 283 #endif
 284         nvmem->eeprom.private = &nvmem->dev;
 285         nvmem->base_dev = config->base_dev;
 286
 287         rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
 288         if (rval) {
 289                 dev_err(&nvmem->dev,
 290                         "Failed to create eeprom binary file %d\n", rval);
 291                 return rval;
 292         }
 293
 294         nvmem->flags |= FLAG_COMPAT;
 295
 296         return 0;
 297 }
 298
 299 static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
 300                               const struct nvmem_config *config)
 301 {
 302         if (config->compat)
 303                 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
 304 }
 305
 306 #else /* CONFIG_NVMEM_SYSFS */
 307
 308 static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
 309                                     const struct nvmem_config *config)
 310 {
 311         return -ENOSYS;
 312 }
 313 static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
 314                                       const struct nvmem_config *config)
 315 {
 316 }
 317
 318 #endif /* CONFIG_NVMEM_SYSFS */
 319
 320 static void nvmem_release(struct device *dev)
 321 {
 322         struct nvmem_device *nvmem = to_nvmem_device(dev);
 323
 324         ida_free(&nvmem_ida, nvmem->id);
 325         gpiod_put(nvmem->wp_gpio);
 326         kfree(nvmem);
 327 }
 328
 329 static const struct device_type nvmem_provider_type = {
 330         .release        = nvmem_release,
 331 };
 332
 333 static struct bus_type nvmem_bus_type = {
 334         .name           = "nvmem",
 335 };
 336
 337 static void nvmem_cell_drop(struct nvmem_cell *cell)
 338 {
 339         blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
 340         mutex_lock(&nvmem_mutex);
 341         list_del(&cell->node);
 342         mutex_unlock(&nvmem_mutex);
 343         of_node_put(cell->np);
 344         kfree_const(cell->name);
 345         kfree(cell);
 346 }
 347
 348 static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
 349 {
 350         struct nvmem_cell *cell, *p;
 351
 352         list_for_each_entry_safe(cell, p, &nvmem->cells, node)
 353                 nvmem_cell_drop(cell);
 354 }
 355
 356 static void nvmem_cell_add(struct nvmem_cell *cell)
 357 {
 358         mutex_lock(&nvmem_mutex);
 359         list_add_tail(&cell->node, &cell->nvmem->cells);
 360         mutex_unlock(&nvmem_mutex);
 361         blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_ADD, cell);
 362 }
 363
 364 static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
 365                                    const struct nvmem_cell_info *info,
 366                                    struct nvmem_cell *cell)
 367 {
 368         cell->nvmem = nvmem;
 369         cell->offset = info->offset;
 370         cell->bytes = info->bytes;
 371         cell->name = kstrdup_const(info->name, GFP_KERNEL);
 372         if (!cell->name)
 373                 return -ENOMEM;
 374
 375         cell->bit_offset = info->bit_offset;
 376         cell->nbits = info->nbits;
 377
 378         if (cell->nbits)
 379                 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
 380                                            BITS_PER_BYTE);
 381
 382         if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
 383                 dev_err(&nvmem->dev,
 384                         "cell %s unaligned to nvmem stride %d\n",
 385                         cell->name, nvmem->stride);
 386                 return -EINVAL;
 387         }
 388
 389         return 0;
 390 }
 391
 392 /**
 393  * nvmem_add_cells() - Add cell information to an nvmem device
 394  *
 395  * @nvmem: nvmem device to add cells to.
 396  * @info: nvmem cell info to add to the device
 397  * @ncells: number of cells in info
 398  *
 399  * Return: 0 or negative error code on failure.
 400  */
 401 static int nvmem_add_cells(struct nvmem_device *nvmem,
 402                     const struct nvmem_cell_info *info,
 403                     int ncells)
 404 {
 405         struct nvmem_cell **cells;
 406         int i, rval;
 407
 408         cells = kcalloc(ncells, sizeof(*cells), GFP_KERNEL);
 409         if (!cells)
 410                 return -ENOMEM;
 411
 412         for (i = 0; i < ncells; i++) {
 413                 cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
 414                 if (!cells[i]) {
 415                         rval = -ENOMEM;
 416                         goto err;
 417                 }
 418
 419                 rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
 420                 if (rval) {
 421                         kfree(cells[i]);
 422                         goto err;
 423                 }
 424
 425                 nvmem_cell_add(cells[i]);
 426         }
 427
 428         /* remove tmp array */
 429         kfree(cells);
 430
 431         return 0;
 432 err:
 433         while (i--)
 434                 nvmem_cell_drop(cells[i]);
 435
 436         kfree(cells);
 437
 438         return rval;
 439 }
 440
 441 /**
 442  * nvmem_register_notifier() - Register a notifier block for nvmem events.
 443  *
 444  * @nb: notifier block to be called on nvmem events.
 445  *
 446  * Return: 0 on success, negative error number on failure.
 447  */
 448 int nvmem_register_notifier(struct notifier_block *nb)
 449 {
 450         return blocking_notifier_chain_register(&nvmem_notifier, nb);
 451 }
 452 EXPORT_SYMBOL_GPL(nvmem_register_notifier);
 453
 454 /**
 455  * nvmem_unregister_notifier() - Unregister a notifier block for nvmem events.
 456  *
 457  * @nb: notifier block to be unregistered.
 458  *
 459  * Return: 0 on success, negative error number on failure.
 460  */
 461 int nvmem_unregister_notifier(struct notifier_block *nb)
 462 {
 463         return blocking_notifier_chain_unregister(&nvmem_notifier, nb);
 464 }
 465 EXPORT_SYMBOL_GPL(nvmem_unregister_notifier);
 466
 467 static int nvmem_add_cells_from_table(struct nvmem_device *nvmem)
 468 {
 469         const struct nvmem_cell_info *info;
 470         struct nvmem_cell_table *table;
 471         struct nvmem_cell *cell;
 472         int rval = 0, i;
 473
 474         mutex_lock(&nvmem_cell_mutex);
 475         list_for_each_entry(table, &nvmem_cell_tables, node) {
 476                 if (strcmp(nvmem_dev_name(nvmem), table->nvmem_name) == 0) {
 477                         for (i = 0; i < table->ncells; i++) {
 478                                 info = &table->cells[i];
 479
 480                                 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
 481                                 if (!cell) {
 482                                         rval = -ENOMEM;
 483                                         goto out;
 484                                 }
 485
 486                                 rval = nvmem_cell_info_to_nvmem_cell(nvmem,
 487                                                                      info,
 488                                                                      cell);
 489                                 if (rval) {
 490                                         kfree(cell);
 491                                         goto out;
 492                                 }
 493
 494                                 nvmem_cell_add(cell);
 495                         }
 496                 }
 497         }
 498
 499 out:
 500         mutex_unlock(&nvmem_cell_mutex);
 501         return rval;
 502 }
 503
 504 static struct nvmem_cell *
 505 nvmem_find_cell_by_name(struct nvmem_device *nvmem, const char *cell_id)
 506 {
 507         struct nvmem_cell *iter, *cell = NULL;
 508
 509         mutex_lock(&nvmem_mutex);
 510         list_for_each_entry(iter, &nvmem->cells, node) {
 511                 if (strcmp(cell_id, iter->name) == 0) {
 512                         cell = iter;
 513                         break;
 514                 }
 515         }
 516         mutex_unlock(&nvmem_mutex);
 517
 518         return cell;
 519 }
 520
 521 static int nvmem_add_cells_from_of(struct nvmem_device *nvmem)
 522 {
 523         struct device_node *parent, *child;
 524         struct device *dev = &nvmem->dev;
 525         struct nvmem_cell *cell;
 526         const __be32 *addr;
 527         int len;
 528
 529         parent = dev->of_node;
 530
 531         for_each_child_of_node(parent, child) {
 532                 addr = of_get_property(child, "reg", &len);
 533                 if (!addr || (len < 2 * sizeof(u32))) {
 534                         dev_err(dev, "nvmem: invalid reg on %pOF\n", child);
 535                         return -EINVAL;
 536                 }
 537
 538                 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
 539                 if (!cell)
 540                         return -ENOMEM;
 541
 542                 cell->nvmem = nvmem;
 543                 cell->np = of_node_get(child);
 544                 cell->offset = be32_to_cpup(addr++);
 545                 cell->bytes = be32_to_cpup(addr);
 546                 cell->name = kasprintf(GFP_KERNEL, "%pOFn", child);
 547
 548                 addr = of_get_property(child, "bits", &len);
 549                 if (addr && len == (2 * sizeof(u32))) {
 550                         cell->bit_offset = be32_to_cpup(addr++);
 551                         cell->nbits = be32_to_cpup(addr);
 552                 }
 553
 554                 if (cell->nbits)
 555                         cell->bytes = DIV_ROUND_UP(
 556                                         cell->nbits + cell->bit_offset,
 557                                         BITS_PER_BYTE);
 558
 559                 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
 560                         dev_err(dev, "cell %s unaligned to nvmem stride %d\n",
 561                                 cell->name, nvmem->stride);
 562                         /* Cells already added will be freed later. */
 563                         kfree_const(cell->name);
 564                         kfree(cell);
 565                         return -EINVAL;
 566                 }
 567
 568                 nvmem_cell_add(cell);
 569         }
 570
 571         return 0;
 572 }
 573
 574 /**
 575  * nvmem_register() - Register a nvmem device for given nvmem_config.
 576  * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
 577  *
 578  * @config: nvmem device configuration with which nvmem device is created.
 579  *
 580  * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
 581  * on success.
 582  */
 583
 584 struct nvmem_device *nvmem_register(const struct nvmem_config *config)
 585 {
 586         struct nvmem_device *nvmem;
 587         int rval;
 588
 589         if (!config->dev)
 590                 return ERR_PTR(-EINVAL);
 591
 592         if (!config->reg_read && !config->reg_write)
 593                 return ERR_PTR(-EINVAL);
 594
 595         nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
 596         if (!nvmem)
 597                 return ERR_PTR(-ENOMEM);
 598
 599         rval  = ida_alloc(&nvmem_ida, GFP_KERNEL);
 600         if (rval < 0) {
 601                 kfree(nvmem);
 602                 return ERR_PTR(rval);
 603         }
 604
 605         if (config->wp_gpio)
 606                 nvmem->wp_gpio = config->wp_gpio;
 607         else
 608                 nvmem->wp_gpio = gpiod_get_optional(config->dev, "wp",
 609                                                     GPIOD_OUT_HIGH);
 610         if (IS_ERR(nvmem->wp_gpio)) {
 611                 ida_free(&nvmem_ida, nvmem->id);
 612                 rval = PTR_ERR(nvmem->wp_gpio);
 613                 kfree(nvmem);
 614                 return ERR_PTR(rval);
 615         }
 616
 617         kref_init(&nvmem->refcnt);
 618         INIT_LIST_HEAD(&nvmem->cells);
 619
 620         nvmem->id = rval;
 621         nvmem->owner = config->owner;
 622         if (!nvmem->owner && config->dev->driver)
 623                 nvmem->owner = config->dev->driver->owner;
 624         nvmem->stride = config->stride ?: 1;
 625         nvmem->word_size = config->word_size ?: 1;
 626         nvmem->size = config->size;
 627         nvmem->dev.type = &nvmem_provider_type;
 628         nvmem->dev.bus = &nvmem_bus_type;
 629         nvmem->dev.parent = config->dev;
 630         nvmem->root_only = config->root_only;
 631         nvmem->priv = config->priv;
 632         nvmem->type = config->type;
 633         nvmem->reg_read = config->reg_read;
 634         nvmem->reg_write = config->reg_write;
 635         if (!config->no_of_node)
 636                 nvmem->dev.of_node = config->dev->of_node;
 637
 638         switch (config->id) {
 639         case NVMEM_DEVID_NONE:
 640                 dev_set_name(&nvmem->dev, "%s", config->name);
 641                 break;
 642         case NVMEM_DEVID_AUTO:
 643                 dev_set_name(&nvmem->dev, "%s%d", config->name, nvmem->id);
 644                 break;
 645         default:
 646                 dev_set_name(&nvmem->dev, "%s%d",
 647                              config->name ? : "nvmem",
 648                              config->name ? config->id : nvmem->id);
 649                 break;
 650         }
 651
 652         nvmem->read_only = device_property_present(config->dev, "read-only") ||
 653                            config->read_only || !nvmem->reg_write;
 654
 655 #ifdef CONFIG_NVMEM_SYSFS
 656         nvmem->dev.groups = nvmem_dev_groups;
 657 #endif
 658
 659         dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
 660
 661         rval = device_register(&nvmem->dev);
 662         if (rval)
 663                 goto err_put_device;
 664
 665         if (config->compat) {
 666                 rval = nvmem_sysfs_setup_compat(nvmem, config);
 667                 if (rval)
 668                         goto err_device_del;
 669         }
 670
 671         if (config->cells) {
 672                 rval = nvmem_add_cells(nvmem, config->cells, config->ncells);
 673                 if (rval)
 674                         goto err_teardown_compat;
 675         }
 676
 677         rval = nvmem_add_cells_from_table(nvmem);
 678         if (rval)
 679                 goto err_remove_cells;
 680
 681         rval = nvmem_add_cells_from_of(nvmem);
 682         if (rval)
 683                 goto err_remove_cells;
 684
 685         blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
 686
 687         return nvmem;
 688
 689 err_remove_cells:
 690         nvmem_device_remove_all_cells(nvmem);
 691 err_teardown_compat:
 692         if (config->compat)
 693                 nvmem_sysfs_remove_compat(nvmem, config);
 694 err_device_del:
 695         device_del(&nvmem->dev);
 696 err_put_device:
 697         put_device(&nvmem->dev);
 698
 699         return ERR_PTR(rval);
 700 }
 701 EXPORT_SYMBOL_GPL(nvmem_register);
 702
 703 static void nvmem_device_release(struct kref *kref)
 704 {
 705         struct nvmem_device *nvmem;
 706
 707         nvmem = container_of(kref, struct nvmem_device, refcnt);
 708
 709         blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
 710
 711         if (nvmem->flags & FLAG_COMPAT)
 712                 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
 713
 714         nvmem_device_remove_all_cells(nvmem);
 715         device_unregister(&nvmem->dev);
 716 }
 717
 718 /**
 719  * nvmem_unregister() - Unregister previously registered nvmem device
 720  *
 721  * @nvmem: Pointer to previously registered nvmem device.
 722  */
 723 void nvmem_unregister(struct nvmem_device *nvmem)
 724 {
 725         kref_put(&nvmem->refcnt, nvmem_device_release);
 726 }
 727 EXPORT_SYMBOL_GPL(nvmem_unregister);
 728
 729 static void devm_nvmem_release(struct device *dev, void *res)
 730 {
 731         nvmem_unregister(*(struct nvmem_device **)res);
 732 }
 733
 734 /**
 735  * devm_nvmem_register() - Register a managed nvmem device for given
 736  * nvmem_config.
 737  * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
 738  *
 739  * @dev: Device that uses the nvmem device.
 740  * @config: nvmem device configuration with which nvmem device is created.
 741  *
 742  * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
 743  * on success.
 744  */
 745 struct nvmem_device *devm_nvmem_register(struct device *dev,
 746                                          const struct nvmem_config *config)
 747 {
 748         struct nvmem_device **ptr, *nvmem;
 749
 750         ptr = devres_alloc(devm_nvmem_release, sizeof(*ptr), GFP_KERNEL);
 751         if (!ptr)
 752                 return ERR_PTR(-ENOMEM);
 753
 754         nvmem = nvmem_register(config);
 755
 756         if (!IS_ERR(nvmem)) {
 757                 *ptr = nvmem;
 758                 devres_add(dev, ptr);
 759         } else {
 760                 devres_free(ptr);
 761         }
 762
 763         return nvmem;
 764 }
 765 EXPORT_SYMBOL_GPL(devm_nvmem_register);
 766
 767 static int devm_nvmem_match(struct device *dev, void *res, void *data)
 768 {
 769         struct nvmem_device **r = res;
 770
 771         return *r == data;
 772 }
 773
 774 /**
 775  * devm_nvmem_unregister() - Unregister previously registered managed nvmem
 776  * device.
 777  *
 778  * @dev: Device that uses the nvmem device.
 779  * @nvmem: Pointer to previously registered nvmem device.
 780  *
 781  * Return: Will be negative on error or zero on success.
 782  */
 783 int devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem)
 784 {
 785         return devres_release(dev, devm_nvmem_release, devm_nvmem_match, nvmem);
 786 }
 787 EXPORT_SYMBOL(devm_nvmem_unregister);
 788
 789 static struct nvmem_device *__nvmem_device_get(void *data,
 790                         int (*match)(struct device *dev, const void *data))
 791 {
 792         struct nvmem_device *nvmem = NULL;
 793         struct device *dev;
 794
 795         mutex_lock(&nvmem_mutex);
 796         dev = bus_find_device(&nvmem_bus_type, NULL, data, match);
 797         if (dev)
 798                 nvmem = to_nvmem_device(dev);
 799         mutex_unlock(&nvmem_mutex);
 800         if (!nvmem)
 801                 return ERR_PTR(-EPROBE_DEFER);
 802
 803         if (!try_module_get(nvmem->owner)) {
 804                 dev_err(&nvmem->dev,
 805                         "could not increase module refcount for cell %s\n",
 806                         nvmem_dev_name(nvmem));
 807
 808                 put_device(&nvmem->dev);
 809                 return ERR_PTR(-EINVAL);
 810         }
 811
 812         kref_get(&nvmem->refcnt);
 813
 814         return nvmem;
 815 }
 816
 817 static void __nvmem_device_put(struct nvmem_device *nvmem)
 818 {
 819         put_device(&nvmem->dev);
 820         module_put(nvmem->owner);
 821         kref_put(&nvmem->refcnt, nvmem_device_release);
 822 }
 823
 824 #if IS_ENABLED(CONFIG_OF)
 825 /**
 826  * of_nvmem_device_get() - Get nvmem device from a given id
 827  *
 828  * @np: Device tree node that uses the nvmem device.
 829  * @id: nvmem name from nvmem-names property.
 830  *
 831  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
 832  * on success.
 833  */
 834 struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
 835 {
 836
 837         struct device_node *nvmem_np;
 838         struct nvmem_device *nvmem;
 839         int index = 0;
 840
 841         if (id)
 842                 index = of_property_match_string(np, "nvmem-names", id);
 843
 844         nvmem_np = of_parse_phandle(np, "nvmem", index);
 845         if (!nvmem_np)
 846                 return ERR_PTR(-ENOENT);
 847
 848         nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
 849         of_node_put(nvmem_np);
 850         return nvmem;
 851 }
 852 EXPORT_SYMBOL_GPL(of_nvmem_device_get);
 853 #endif
 854
 855 /**
 856  * nvmem_device_get() - Get nvmem device from a given id
 857  *
 858  * @dev: Device that uses the nvmem device.
 859  * @dev_name: name of the requested nvmem device.
 860  *
 861  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
 862  * on success.
 863  */
 864 struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
 865 {
 866         if (dev->of_node) { /* try dt first */
 867                 struct nvmem_device *nvmem;
 868
 869                 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
 870
 871                 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
 872                         return nvmem;
 873
 874         }
 875
 876         return __nvmem_device_get((void *)dev_name, device_match_name);
 877 }
 878 EXPORT_SYMBOL_GPL(nvmem_device_get);
 879
 880 /**
 881  * nvmem_device_find() - Find nvmem device with matching function
 882  *
 883  * @data: Data to pass to match function
 884  * @match: Callback function to check device
 885  *
 886  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
 887  * on success.
 888  */
 889 struct nvmem_device *nvmem_device_find(void *data,
 890                         int (*match)(struct device *dev, const void *data))
 891 {
 892         return __nvmem_device_get(data, match);
 893 }
 894 EXPORT_SYMBOL_GPL(nvmem_device_find);
 895
 896 static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
 897 {
 898         struct nvmem_device **nvmem = res;
 899
 900         if (WARN_ON(!nvmem || !*nvmem))
 901                 return 0;
 902
 903         return *nvmem == data;
 904 }
 905
 906 static void devm_nvmem_device_release(struct device *dev, void *res)
 907 {
 908         nvmem_device_put(*(struct nvmem_device **)res);
 909 }
 910
 911 /**
 912  * devm_nvmem_device_put() - put alredy got nvmem device
 913  *
 914  * @dev: Device that uses the nvmem device.
 915  * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
 916  * that needs to be released.
 917  */
 918 void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
 919 {
 920         int ret;
 921
 922         ret = devres_release(dev, devm_nvmem_device_release,
 923                              devm_nvmem_device_match, nvmem);
 924
 925         WARN_ON(ret);
 926 }
 927 EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
 928
 929 /**
 930  * nvmem_device_put() - put alredy got nvmem device
 931  *
 932  * @nvmem: pointer to nvmem device that needs to be released.
 933  */
 934 void nvmem_device_put(struct nvmem_device *nvmem)
 935 {
 936         __nvmem_device_put(nvmem);
 937 }
 938 EXPORT_SYMBOL_GPL(nvmem_device_put);
 939
 940 /**
 941  * devm_nvmem_device_get() - Get nvmem cell of device form a given id
 942  *
 943  * @dev: Device that requests the nvmem device.
 944  * @id: name id for the requested nvmem device.
 945  *
 946  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
 947  * on success.  The nvmem_cell will be freed by the automatically once the
 948  * device is freed.
 949  */
 950 struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
 951 {
 952         struct nvmem_device **ptr, *nvmem;
 953
 954         ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
 955         if (!ptr)
 956                 return ERR_PTR(-ENOMEM);
 957
 958         nvmem = nvmem_device_get(dev, id);
 959         if (!IS_ERR(nvmem)) {
 960                 *ptr = nvmem;
 961                 devres_add(dev, ptr);
 962         } else {
 963                 devres_free(ptr);
 964         }
 965
 966         return nvmem;
 967 }
 968 EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
 969
 970 static struct nvmem_cell *
 971 nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
 972 {
 973         struct nvmem_cell *cell = ERR_PTR(-ENOENT);
 974         struct nvmem_cell_lookup *lookup;
 975         struct nvmem_device *nvmem;
 976         const char *dev_id;
 977
 978         if (!dev)
 979                 return ERR_PTR(-EINVAL);
 980
 981         dev_id = dev_name(dev);
 982
 983         mutex_lock(&nvmem_lookup_mutex);
 984
 985         list_for_each_entry(lookup, &nvmem_lookup_list, node) {
 986                 if ((strcmp(lookup->dev_id, dev_id) == 0) &&
 987                     (strcmp(lookup->con_id, con_id) == 0)) {
 988                         /* This is the right entry. */
 989                         nvmem = __nvmem_device_get((void *)lookup->nvmem_name,
 990                                                    device_match_name);
 991                         if (IS_ERR(nvmem)) {
 992                                 /* Provider may not be registered yet. */
 993                                 cell = ERR_CAST(nvmem);
 994                                 break;
 995                         }
 996
 997                         cell = nvmem_find_cell_by_name(nvmem,
 998                                                        lookup->cell_name);
 999                         if (!cell) {
1000                                 __nvmem_device_put(nvmem);
1001                                 cell = ERR_PTR(-ENOENT);
1002                         }
1003                         break;
1004                 }
1005         }
1006
1007         mutex_unlock(&nvmem_lookup_mutex);
1008         return cell;
1009 }
1010
1011 #if IS_ENABLED(CONFIG_OF)
1012 static struct nvmem_cell *
1013 nvmem_find_cell_by_node(struct nvmem_device *nvmem, struct device_node *np)
1014 {
1015         struct nvmem_cell *iter, *cell = NULL;
1016
1017         mutex_lock(&nvmem_mutex);
1018         list_for_each_entry(iter, &nvmem->cells, node) {
1019                 if (np == iter->np) {
1020                         cell = iter;
1021                         break;
1022                 }
1023         }
1024         mutex_unlock(&nvmem_mutex);
1025
1026         return cell;
1027 }
1028
1029 /**
1030  * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
1031  *
1032  * @np: Device tree node that uses the nvmem cell.
1033  * @id: nvmem cell name from nvmem-cell-names property, or NULL
1034  *      for the cell at index 0 (the lone cell with no accompanying
1035  *      nvmem-cell-names property).
1036  *
1037  * Return: Will be an ERR_PTR() on error or a valid pointer
1038  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
1039  * nvmem_cell_put().
1040  */
1041 struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
1042 {
1043         struct device_node *cell_np, *nvmem_np;
1044         struct nvmem_device *nvmem;
1045         struct nvmem_cell *cell;
1046         int index = 0;
1047
1048         /* if cell name exists, find index to the name */
1049         if (id)
1050                 index = of_property_match_string(np, "nvmem-cell-names", id);
1051
1052         cell_np = of_parse_phandle(np, "nvmem-cells", index);
1053         if (!cell_np)
1054                 return ERR_PTR(-ENOENT);
1055
1056         nvmem_np = of_get_next_parent(cell_np);
1057         if (!nvmem_np)
1058                 return ERR_PTR(-EINVAL);
1059
1060         nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1061         of_node_put(nvmem_np);
1062         if (IS_ERR(nvmem))
1063                 return ERR_CAST(nvmem);
1064
1065         cell = nvmem_find_cell_by_node(nvmem, cell_np);
1066         if (!cell) {
1067                 __nvmem_device_put(nvmem);
1068                 return ERR_PTR(-ENOENT);
1069         }
1070
1071         return cell;
1072 }
1073 EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
1074 #endif
1075
1076 /**
1077  * nvmem_cell_get() - Get nvmem cell of device form a given cell name
1078  *
1079  * @dev: Device that requests the nvmem cell.
1080  * @id: nvmem cell name to get (this corresponds with the name from the
1081  *      nvmem-cell-names property for DT systems and with the con_id from
1082  *      the lookup entry for non-DT systems).
1083  *
1084  * Return: Will be an ERR_PTR() on error or a valid pointer
1085  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
1086  * nvmem_cell_put().
1087  */
1088 struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id)
1089 {
1090         struct nvmem_cell *cell;
1091
1092         if (dev->of_node) { /* try dt first */
1093                 cell = of_nvmem_cell_get(dev->of_node, id);
1094                 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
1095                         return cell;
1096         }
1097
1098         /* NULL cell id only allowed for device tree; invalid otherwise */
1099         if (!id)
1100                 return ERR_PTR(-EINVAL);
1101
1102         return nvmem_cell_get_from_lookup(dev, id);
1103 }
1104 EXPORT_SYMBOL_GPL(nvmem_cell_get);
1105
1106 static void devm_nvmem_cell_release(struct device *dev, void *res)
1107 {
1108         nvmem_cell_put(*(struct nvmem_cell **)res);
1109 }
1110
1111 /**
1112  * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
1113  *
1114  * @dev: Device that requests the nvmem cell.
1115  * @id: nvmem cell name id to get.
1116  *
1117  * Return: Will be an ERR_PTR() on error or a valid pointer
1118  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
1119  * automatically once the device is freed.
1120  */
1121 struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
1122 {
1123         struct nvmem_cell **ptr, *cell;
1124
1125         ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
1126         if (!ptr)
1127                 return ERR_PTR(-ENOMEM);
1128
1129         cell = nvmem_cell_get(dev, id);
1130         if (!IS_ERR(cell)) {
1131                 *ptr = cell;
1132                 devres_add(dev, ptr);
1133         } else {
1134                 devres_free(ptr);
1135         }
1136
1137         return cell;
1138 }
1139 EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
1140
1141 static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
1142 {
1143         struct nvmem_cell **c = res;
1144
1145         if (WARN_ON(!c || !*c))
1146                 return 0;
1147
1148         return *c == data;
1149 }
1150
1151 /**
1152  * devm_nvmem_cell_put() - Release previously allocated nvmem cell
1153  * from devm_nvmem_cell_get.
1154  *
1155  * @dev: Device that requests the nvmem cell.
1156  * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get().
1157  */
1158 void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
1159 {
1160         int ret;
1161
1162         ret = devres_release(dev, devm_nvmem_cell_release,
1163                                 devm_nvmem_cell_match, cell);
1164
1165         WARN_ON(ret);
1166 }
1167 EXPORT_SYMBOL(devm_nvmem_cell_put);
1168
1169 /**
1170  * nvmem_cell_put() - Release previously allocated nvmem cell.
1171  *
1172  * @cell: Previously allocated nvmem cell by nvmem_cell_get().
1173  */
1174 void nvmem_cell_put(struct nvmem_cell *cell)
1175 {
1176         struct nvmem_device *nvmem = cell->nvmem;
1177
1178         __nvmem_device_put(nvmem);
1179 }
1180 EXPORT_SYMBOL_GPL(nvmem_cell_put);
1181
1182 static void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell, void *buf)
1183 {
1184         u8 *p, *b;
1185         int i, extra, bit_offset = cell->bit_offset;
1186
1187         p = b = buf;
1188         if (bit_offset) {
1189                 /* First shift */
1190                 *b++ >>= bit_offset;
1191
1192                 /* setup rest of the bytes if any */
1193                 for (i = 1; i < cell->bytes; i++) {
1194                         /* Get bits from next byte and shift them towards msb */
1195                         *p |= *b << (BITS_PER_BYTE - bit_offset);
1196
1197                         p = b;
1198                         *b++ >>= bit_offset;
1199                 }
1200         } else {
1201                 /* point to the msb */
1202                 p += cell->bytes - 1;
1203         }
1204
1205         /* result fits in less bytes */
1206         extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);
1207         while (--extra >= 0)
1208                 *p-- = 0;
1209
1210         /* clear msb bits if any leftover in the last byte */
1211         *p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0);
1212 }
1213
1214 static int __nvmem_cell_read(struct nvmem_device *nvmem,
1215                       struct nvmem_cell *cell,
1216                       void *buf, size_t *len)
1217 {
1218         int rc;
1219
1220         rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->bytes);
1221
1222         if (rc)
1223                 return rc;
1224
1225         /* shift bits in-place */
1226         if (cell->bit_offset || cell->nbits)
1227                 nvmem_shift_read_buffer_in_place(cell, buf);
1228
1229         if (len)
1230                 *len = cell->bytes;
1231
1232         return 0;
1233 }
1234
1235 /**
1236  * nvmem_cell_read() - Read a given nvmem cell
1237  *
1238  * @cell: nvmem cell to be read.
1239  * @len: pointer to length of cell which will be populated on successful read;
1240  *       can be NULL.
1241  *
1242  * Return: ERR_PTR() on error or a valid pointer to a buffer on success. The
1243  * buffer should be freed by the consumer with a kfree().
1244  */
1245 void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
1246 {
1247         struct nvmem_device *nvmem = cell->nvmem;
1248         u8 *buf;
1249         int rc;
1250
1251         if (!nvmem)
1252                 return ERR_PTR(-EINVAL);
1253
1254         buf = kzalloc(cell->bytes, GFP_KERNEL);
1255         if (!buf)
1256                 return ERR_PTR(-ENOMEM);
1257
1258         rc = __nvmem_cell_read(nvmem, cell, buf, len);
1259         if (rc) {
1260                 kfree(buf);
1261                 return ERR_PTR(rc);
1262         }
1263
1264         return buf;
1265 }
1266 EXPORT_SYMBOL_GPL(nvmem_cell_read);
1267
1268 static void *nvmem_cell_prepare_write_buffer(struct nvmem_cell *cell,
1269                                              u8 *_buf, int len)
1270 {
1271         struct nvmem_device *nvmem = cell->nvmem;
1272         int i, rc, nbits, bit_offset = cell->bit_offset;
1273         u8 v, *p, *buf, *b, pbyte, pbits;
1274
1275         nbits = cell->nbits;
1276         buf = kzalloc(cell->bytes, GFP_KERNEL);
1277         if (!buf)
1278                 return ERR_PTR(-ENOMEM);
1279
1280         memcpy(buf, _buf, len);
1281         p = b = buf;
1282
1283         if (bit_offset) {
1284                 pbyte = *b;
1285                 *b <<= bit_offset;
1286
1287                 /* setup the first byte with lsb bits from nvmem */
1288                 rc = nvmem_reg_read(nvmem, cell->offset, &v, 1);
1289                 if (rc)
1290                         goto err;
1291                 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1292
1293                 /* setup rest of the byte if any */
1294                 for (i = 1; i < cell->bytes; i++) {
1295                         /* Get last byte bits and shift them towards lsb */
1296                         pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1297                         pbyte = *b;
1298                         p = b;
1299                         *b <<= bit_offset;
1300                         *b++ |= pbits;
1301                 }
1302         }
1303
1304         /* if it's not end on byte boundary */
1305         if ((nbits + bit_offset) % BITS_PER_BYTE) {
1306                 /* setup the last byte with msb bits from nvmem */
1307                 rc = nvmem_reg_read(nvmem,
1308                                     cell->offset + cell->bytes - 1, &v, 1);
1309                 if (rc)
1310                         goto err;
1311                 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1312
1313         }
1314
1315         return buf;
1316 err:
1317         kfree(buf);
1318         return ERR_PTR(rc);
1319 }
1320
1321 /**
1322  * nvmem_cell_write() - Write to a given nvmem cell
1323  *
1324  * @cell: nvmem cell to be written.
1325  * @buf: Buffer to be written.
1326  * @len: length of buffer to be written to nvmem cell.
1327  *
1328  * Return: length of bytes written or negative on failure.
1329  */
1330 int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1331 {
1332         struct nvmem_device *nvmem = cell->nvmem;
1333         int rc;
1334
1335         if (!nvmem || nvmem->read_only ||
1336             (cell->bit_offset == 0 && len != cell->bytes))
1337                 return -EINVAL;
1338
1339         if (cell->bit_offset || cell->nbits) {
1340                 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1341                 if (IS_ERR(buf))
1342                         return PTR_ERR(buf);
1343         }
1344
1345         rc = nvmem_reg_write(nvmem, cell->offset, buf, cell->bytes);
1346
1347         /* free the tmp buffer */
1348         if (cell->bit_offset || cell->nbits)
1349                 kfree(buf);
1350
1351         if (rc)
1352                 return rc;
1353
1354         return len;
1355 }
1356 EXPORT_SYMBOL_GPL(nvmem_cell_write);
1357
1358 static int nvmem_cell_read_common(struct device *dev, const char *cell_id,
1359                                   void *val, size_t count)
1360 {
1361         struct nvmem_cell *cell;
1362         void *buf;
1363         size_t len;
1364
1365         cell = nvmem_cell_get(dev, cell_id);
1366         if (IS_ERR(cell))
1367                 return PTR_ERR(cell);
1368
1369         buf = nvmem_cell_read(cell, &len);
1370         if (IS_ERR(buf)) {
1371                 nvmem_cell_put(cell);
1372                 return PTR_ERR(buf);
1373         }
1374         if (len != count) {
1375                 kfree(buf);
1376                 nvmem_cell_put(cell);
1377                 return -EINVAL;
1378         }
1379         memcpy(val, buf, count);
1380         kfree(buf);
1381         nvmem_cell_put(cell);
1382
1383         return 0;
1384 }
1385
1386 /**
1387  * nvmem_cell_read_u8() - Read a cell value as a u8
1388  *
1389  * @dev: Device that requests the nvmem cell.
1390  * @cell_id: Name of nvmem cell to read.
1391  * @val: pointer to output value.
1392  *
1393  * Return: 0 on success or negative errno.
1394  */
1395 int nvmem_cell_read_u8(struct device *dev, const char *cell_id, u8 *val)
1396 {
1397         return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1398 }
1399 EXPORT_SYMBOL_GPL(nvmem_cell_read_u8);
1400
1401 /**
1402  * nvmem_cell_read_u16() - Read a cell value as a u16
1403  *
1404  * @dev: Device that requests the nvmem cell.
1405  * @cell_id: Name of nvmem cell to read.
1406  * @val: pointer to output value.
1407  *
1408  * Return: 0 on success or negative errno.
1409  */
1410 int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val)
1411 {
1412         return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1413 }
1414 EXPORT_SYMBOL_GPL(nvmem_cell_read_u16);
1415
1416 /**
1417  * nvmem_cell_read_u32() - Read a cell value as a u32
1418  *
1419  * @dev: Device that requests the nvmem cell.
1420  * @cell_id: Name of nvmem cell to read.
1421  * @val: pointer to output value.
1422  *
1423  * Return: 0 on success or negative errno.
1424  */
1425 int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val)
1426 {
1427         return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1428 }
1429 EXPORT_SYMBOL_GPL(nvmem_cell_read_u32);
1430
1431 /**
1432  * nvmem_cell_read_u64() - Read a cell value as a u64
1433  *
1434  * @dev: Device that requests the nvmem cell.
1435  * @cell_id: Name of nvmem cell to read.
1436  * @val: pointer to output value.
1437  *
1438  * Return: 0 on success or negative errno.
1439  */
1440 int nvmem_cell_read_u64(struct device *dev, const char *cell_id, u64 *val)
1441 {
1442         return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1443 }
1444 EXPORT_SYMBOL_GPL(nvmem_cell_read_u64);
1445
1446 /**
1447  * nvmem_device_cell_read() - Read a given nvmem device and cell
1448  *
1449  * @nvmem: nvmem device to read from.
1450  * @info: nvmem cell info to be read.
1451  * @buf: buffer pointer which will be populated on successful read.
1452  *
1453  * Return: length of successful bytes read on success and negative
1454  * error code on error.
1455  */
1456 ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
1457                            struct nvmem_cell_info *info, void *buf)
1458 {
1459         struct nvmem_cell cell;
1460         int rc;
1461         ssize_t len;
1462
1463         if (!nvmem)
1464                 return -EINVAL;
1465
1466         rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1467         if (rc)
1468                 return rc;
1469
1470         rc = __nvmem_cell_read(nvmem, &cell, buf, &len);
1471         if (rc)
1472                 return rc;
1473
1474         return len;
1475 }
1476 EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
1477
1478 /**
1479  * nvmem_device_cell_write() - Write cell to a given nvmem device
1480  *
1481  * @nvmem: nvmem device to be written to.
1482  * @info: nvmem cell info to be written.
1483  * @buf: buffer to be written to cell.
1484  *
1485  * Return: length of bytes written or negative error code on failure.
1486  */
1487 int nvmem_device_cell_write(struct nvmem_device *nvmem,
1488                             struct nvmem_cell_info *info, void *buf)
1489 {
1490         struct nvmem_cell cell;
1491         int rc;
1492
1493         if (!nvmem)
1494                 return -EINVAL;
1495
1496         rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1497         if (rc)
1498                 return rc;
1499
1500         return nvmem_cell_write(&cell, buf, cell.bytes);
1501 }
1502 EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
1503
1504 /**
1505  * nvmem_device_read() - Read from a given nvmem device
1506  *
1507  * @nvmem: nvmem device to read from.
1508  * @offset: offset in nvmem device.
1509  * @bytes: number of bytes to read.
1510  * @buf: buffer pointer which will be populated on successful read.
1511  *
1512  * Return: length of successful bytes read on success and negative
1513  * error code on error.
1514  */
1515 int nvmem_device_read(struct nvmem_device *nvmem,
1516                       unsigned int offset,
1517                       size_t bytes, void *buf)
1518 {
1519         int rc;
1520
1521         if (!nvmem)
1522                 return -EINVAL;
1523
1524         rc = nvmem_reg_read(nvmem, offset, buf, bytes);
1525
1526         if (rc)
1527                 return rc;
1528
1529         return bytes;
1530 }
1531 EXPORT_SYMBOL_GPL(nvmem_device_read);
1532
1533 /**
1534  * nvmem_device_write() - Write cell to a given nvmem device
1535  *
1536  * @nvmem: nvmem device to be written to.
1537  * @offset: offset in nvmem device.
1538  * @bytes: number of bytes to write.
1539  * @buf: buffer to be written.
1540  *
1541  * Return: length of bytes written or negative error code on failure.
1542  */
1543 int nvmem_device_write(struct nvmem_device *nvmem,
1544                        unsigned int offset,
1545                        size_t bytes, void *buf)
1546 {
1547         int rc;
1548
1549         if (!nvmem)
1550                 return -EINVAL;
1551
1552         rc = nvmem_reg_write(nvmem, offset, buf, bytes);
1553
1554         if (rc)
1555                 return rc;
1556
1557
1558         return bytes;
1559 }
1560 EXPORT_SYMBOL_GPL(nvmem_device_write);
1561
1562 /**
1563  * nvmem_add_cell_table() - register a table of cell info entries
1564  *
1565  * @table: table of cell info entries
1566  */
1567 void nvmem_add_cell_table(struct nvmem_cell_table *table)
1568 {
1569         mutex_lock(&nvmem_cell_mutex);
1570         list_add_tail(&table->node, &nvmem_cell_tables);
1571         mutex_unlock(&nvmem_cell_mutex);
1572 }
1573 EXPORT_SYMBOL_GPL(nvmem_add_cell_table);
1574
1575 /**
1576  * nvmem_del_cell_table() - remove a previously registered cell info table
1577  *
1578  * @table: table of cell info entries
1579  */
1580 void nvmem_del_cell_table(struct nvmem_cell_table *table)
1581 {
1582         mutex_lock(&nvmem_cell_mutex);
1583         list_del(&table->node);
1584         mutex_unlock(&nvmem_cell_mutex);
1585 }
1586 EXPORT_SYMBOL_GPL(nvmem_del_cell_table);
1587
1588 /**
1589  * nvmem_add_cell_lookups() - register a list of cell lookup entries
1590  *
1591  * @entries: array of cell lookup entries
1592  * @nentries: number of cell lookup entries in the array
1593  */
1594 void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
1595 {
1596         int i;
1597
1598         mutex_lock(&nvmem_lookup_mutex);
1599         for (i = 0; i < nentries; i++)
1600                 list_add_tail(&entries[i].node, &nvmem_lookup_list);
1601         mutex_unlock(&nvmem_lookup_mutex);
1602 }
1603 EXPORT_SYMBOL_GPL(nvmem_add_cell_lookups);
1604
1605 /**
1606  * nvmem_del_cell_lookups() - remove a list of previously added cell lookup
1607  *                            entries
1608  *
1609  * @entries: array of cell lookup entries
1610  * @nentries: number of cell lookup entries in the array
1611  */
1612 void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
1613 {
1614         int i;
1615
1616         mutex_lock(&nvmem_lookup_mutex);
1617         for (i = 0; i < nentries; i++)
1618                 list_del(&entries[i].node);
1619         mutex_unlock(&nvmem_lookup_mutex);
1620 }
1621 EXPORT_SYMBOL_GPL(nvmem_del_cell_lookups);
1622
1623 /**
1624  * nvmem_dev_name() - Get the name of a given nvmem device.
1625  *
1626  * @nvmem: nvmem device.
1627  *
1628  * Return: name of the nvmem device.
1629  */
1630 const char *nvmem_dev_name(struct nvmem_device *nvmem)
1631 {
1632         return dev_name(&nvmem->dev);
1633 }
1634 EXPORT_SYMBOL_GPL(nvmem_dev_name);
1635
1636 static int __init nvmem_init(void)
1637 {
1638         return bus_register(&nvmem_bus_type);
1639 }
1640
1641 static void __exit nvmem_exit(void)
1642 {
1643         bus_unregister(&nvmem_bus_type);
1644 }
1645
1646 subsys_initcall(nvmem_init);
1647 module_exit(nvmem_exit);
1648
1649 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
1650 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
1651 MODULE_DESCRIPTION("nvmem Driver Core");
1652 MODULE_LICENSE("GPL v2");