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