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