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