drivers/nvmem/core.c

   1 /*
   2  * nvmem framework core.
   3  *
   4  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
   5  * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 and
   9  * only version 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/device.h>
  18 #include <linux/export.h>
  19 #include <linux/fs.h>
  20 #include <linux/idr.h>
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/nvmem-consumer.h>
  24 #include <linux/nvmem-provider.h>
  25 #include <linux/of.h>
  26 #include <linux/regmap.h>
  27 #include <linux/slab.h>
  28
  29 struct nvmem_device {
  30         const char              *name;
  31         struct regmap           *regmap;
  32         struct module           *owner;
  33         struct device           dev;
  34         int                     stride;
  35         int                     word_size;
  36         int                     ncells;
  37         int                     id;
  38         int                     users;
  39         size_t                  size;
  40         bool                    read_only;
  41         int                     flags;
  42         struct bin_attribute    eeprom;
  43         struct device           *base_dev;
  44 };
  45
  46 #define FLAG_COMPAT             BIT(0)
  47
  48 struct nvmem_cell {
  49         const char              *name;
  50         int                     offset;
  51         int                     bytes;
  52         int                     bit_offset;
  53         int                     nbits;
  54         struct nvmem_device     *nvmem;
  55         struct list_head        node;
  56 };
  57
  58 static DEFINE_MUTEX(nvmem_mutex);
  59 static DEFINE_IDA(nvmem_ida);
  60
  61 static LIST_HEAD(nvmem_cells);
  62 static DEFINE_MUTEX(nvmem_cells_mutex);
  63
  64 #ifdef CONFIG_DEBUG_LOCK_ALLOC
  65 static struct lock_class_key eeprom_lock_key;
  66 #endif
  67
  68 #define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
  69
  70 static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
  71                                     struct bin_attribute *attr,
  72                                     char *buf, loff_t pos, size_t count)
  73 {
  74         struct device *dev;
  75         struct nvmem_device *nvmem;
  76         int rc;
  77
  78         if (attr->private)
  79                 dev = attr->private;
  80         else
  81                 dev = container_of(kobj, struct device, kobj);
  82         nvmem = to_nvmem_device(dev);
  83
  84         /* Stop the user from reading */
  85         if (pos >= nvmem->size)
  86                 return 0;
  87
  88         if (count < nvmem->word_size)
  89                 return -EINVAL;
  90
  91         if (pos + count > nvmem->size)
  92                 count = nvmem->size - pos;
  93
  94         count = round_down(count, nvmem->word_size);
  95
  96         rc = regmap_raw_read(nvmem->regmap, pos, buf, count);
  97
  98         if (IS_ERR_VALUE(rc))
  99                 return rc;
 100
 101         return count;
 102 }
 103
 104 static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
 105                                      struct bin_attribute *attr,
 106                                      char *buf, loff_t pos, size_t count)
 107 {
 108         struct device *dev;
 109         struct nvmem_device *nvmem;
 110         int rc;
 111
 112         if (attr->private)
 113                 dev = attr->private;
 114         else
 115                 dev = container_of(kobj, struct device, kobj);
 116         nvmem = to_nvmem_device(dev);
 117
 118         /* Stop the user from writing */
 119         if (pos >= nvmem->size)
 120                 return 0;
 121
 122         if (count < nvmem->word_size)
 123                 return -EINVAL;
 124
 125         if (pos + count > nvmem->size)
 126                 count = nvmem->size - pos;
 127
 128         count = round_down(count, nvmem->word_size);
 129
 130         rc = regmap_raw_write(nvmem->regmap, pos, buf, count);
 131
 132         if (IS_ERR_VALUE(rc))
 133                 return rc;
 134
 135         return count;
 136 }
 137
 138 /* default read/write permissions */
 139 static struct bin_attribute bin_attr_rw_nvmem = {
 140         .attr   = {
 141                 .name   = "nvmem",
 142                 .mode   = S_IWUSR | S_IRUGO,
 143         },
 144         .read   = bin_attr_nvmem_read,
 145         .write  = bin_attr_nvmem_write,
 146 };
 147
 148 static struct bin_attribute *nvmem_bin_rw_attributes[] = {
 149         &bin_attr_rw_nvmem,
 150         NULL,
 151 };
 152
 153 static const struct attribute_group nvmem_bin_rw_group = {
 154         .bin_attrs      = nvmem_bin_rw_attributes,
 155 };
 156
 157 static const struct attribute_group *nvmem_rw_dev_groups[] = {
 158         &nvmem_bin_rw_group,
 159         NULL,
 160 };
 161
 162 /* read only permission */
 163 static struct bin_attribute bin_attr_ro_nvmem = {
 164         .attr   = {
 165                 .name   = "nvmem",
 166                 .mode   = S_IRUGO,
 167         },
 168         .read   = bin_attr_nvmem_read,
 169 };
 170
 171 static struct bin_attribute *nvmem_bin_ro_attributes[] = {
 172         &bin_attr_ro_nvmem,
 173         NULL,
 174 };
 175
 176 static const struct attribute_group nvmem_bin_ro_group = {
 177         .bin_attrs      = nvmem_bin_ro_attributes,
 178 };
 179
 180 static const struct attribute_group *nvmem_ro_dev_groups[] = {
 181         &nvmem_bin_ro_group,
 182         NULL,
 183 };
 184
 185 /* default read/write permissions, root only */
 186 static struct bin_attribute bin_attr_rw_root_nvmem = {
 187         .attr   = {
 188                 .name   = "nvmem",
 189                 .mode   = S_IWUSR | S_IRUSR,
 190         },
 191         .read   = bin_attr_nvmem_read,
 192         .write  = bin_attr_nvmem_write,
 193 };
 194
 195 static struct bin_attribute *nvmem_bin_rw_root_attributes[] = {
 196         &bin_attr_rw_root_nvmem,
 197         NULL,
 198 };
 199
 200 static const struct attribute_group nvmem_bin_rw_root_group = {
 201         .bin_attrs      = nvmem_bin_rw_root_attributes,
 202 };
 203
 204 static const struct attribute_group *nvmem_rw_root_dev_groups[] = {
 205         &nvmem_bin_rw_root_group,
 206         NULL,
 207 };
 208
 209 /* read only permission, root only */
 210 static struct bin_attribute bin_attr_ro_root_nvmem = {
 211         .attr   = {
 212                 .name   = "nvmem",
 213                 .mode   = S_IRUSR,
 214         },
 215         .read   = bin_attr_nvmem_read,
 216 };
 217
 218 static struct bin_attribute *nvmem_bin_ro_root_attributes[] = {
 219         &bin_attr_ro_root_nvmem,
 220         NULL,
 221 };
 222
 223 static const struct attribute_group nvmem_bin_ro_root_group = {
 224         .bin_attrs      = nvmem_bin_ro_root_attributes,
 225 };
 226
 227 static const struct attribute_group *nvmem_ro_root_dev_groups[] = {
 228         &nvmem_bin_ro_root_group,
 229         NULL,
 230 };
 231
 232 static void nvmem_release(struct device *dev)
 233 {
 234         struct nvmem_device *nvmem = to_nvmem_device(dev);
 235
 236         ida_simple_remove(&nvmem_ida, nvmem->id);
 237         kfree(nvmem);
 238 }
 239
 240 static const struct device_type nvmem_provider_type = {
 241         .release        = nvmem_release,
 242 };
 243
 244 static struct bus_type nvmem_bus_type = {
 245         .name           = "nvmem",
 246 };
 247
 248 static int of_nvmem_match(struct device *dev, void *nvmem_np)
 249 {
 250         return dev->of_node == nvmem_np;
 251 }
 252
 253 static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
 254 {
 255         struct device *d;
 256
 257         if (!nvmem_np)
 258                 return NULL;
 259
 260         d = bus_find_device(&nvmem_bus_type, NULL, nvmem_np, of_nvmem_match);
 261
 262         if (!d)
 263                 return NULL;
 264
 265         return to_nvmem_device(d);
 266 }
 267
 268 static struct nvmem_cell *nvmem_find_cell(const char *cell_id)
 269 {
 270         struct nvmem_cell *p;
 271
 272         list_for_each_entry(p, &nvmem_cells, node)
 273                 if (p && !strcmp(p->name, cell_id))
 274                         return p;
 275
 276         return NULL;
 277 }
 278
 279 static void nvmem_cell_drop(struct nvmem_cell *cell)
 280 {
 281         mutex_lock(&nvmem_cells_mutex);
 282         list_del(&cell->node);
 283         mutex_unlock(&nvmem_cells_mutex);
 284         kfree(cell);
 285 }
 286
 287 static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
 288 {
 289         struct nvmem_cell *cell;
 290         struct list_head *p, *n;
 291
 292         list_for_each_safe(p, n, &nvmem_cells) {
 293                 cell = list_entry(p, struct nvmem_cell, node);
 294                 if (cell->nvmem == nvmem)
 295                         nvmem_cell_drop(cell);
 296         }
 297 }
 298
 299 static void nvmem_cell_add(struct nvmem_cell *cell)
 300 {
 301         mutex_lock(&nvmem_cells_mutex);
 302         list_add_tail(&cell->node, &nvmem_cells);
 303         mutex_unlock(&nvmem_cells_mutex);
 304 }
 305
 306 static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
 307                                    const struct nvmem_cell_info *info,
 308                                    struct nvmem_cell *cell)
 309 {
 310         cell->nvmem = nvmem;
 311         cell->offset = info->offset;
 312         cell->bytes = info->bytes;
 313         cell->name = info->name;
 314
 315         cell->bit_offset = info->bit_offset;
 316         cell->nbits = info->nbits;
 317
 318         if (cell->nbits)
 319                 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
 320                                            BITS_PER_BYTE);
 321
 322         if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
 323                 dev_err(&nvmem->dev,
 324                         "cell %s unaligned to nvmem stride %d\n",
 325                         cell->name, nvmem->stride);
 326                 return -EINVAL;
 327         }
 328
 329         return 0;
 330 }
 331
 332 static int nvmem_add_cells(struct nvmem_device *nvmem,
 333                            const struct nvmem_config *cfg)
 334 {
 335         struct nvmem_cell **cells;
 336         const struct nvmem_cell_info *info = cfg->cells;
 337         int i, rval;
 338
 339         cells = kcalloc(cfg->ncells, sizeof(*cells), GFP_KERNEL);
 340         if (!cells)
 341                 return -ENOMEM;
 342
 343         for (i = 0; i < cfg->ncells; i++) {
 344                 cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
 345                 if (!cells[i]) {
 346                         rval = -ENOMEM;
 347                         goto err;
 348                 }
 349
 350                 rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
 351                 if (IS_ERR_VALUE(rval)) {
 352                         kfree(cells[i]);
 353                         goto err;
 354                 }
 355
 356                 nvmem_cell_add(cells[i]);
 357         }
 358
 359         nvmem->ncells = cfg->ncells;
 360         /* remove tmp array */
 361         kfree(cells);
 362
 363         return 0;
 364 err:
 365         while (i--)
 366                 nvmem_cell_drop(cells[i]);
 367
 368         kfree(cells);
 369
 370         return rval;
 371 }
 372
 373 /*
 374  * nvmem_setup_compat() - Create an additional binary entry in
 375  * drivers sys directory, to be backwards compatible with the older
 376  * drivers/misc/eeprom drivers.
 377  */
 378 static int nvmem_setup_compat(struct nvmem_device *nvmem,
 379                               const struct nvmem_config *config)
 380 {
 381         int rval;
 382
 383         if (!config->base_dev)
 384                 return -EINVAL;
 385
 386         if (nvmem->read_only)
 387                 nvmem->eeprom = bin_attr_ro_root_nvmem;
 388         else
 389                 nvmem->eeprom = bin_attr_rw_root_nvmem;
 390         nvmem->eeprom.attr.name = "eeprom";
 391         nvmem->eeprom.size = nvmem->size;
 392 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 393         nvmem->eeprom.attr.key = &eeprom_lock_key;
 394 #endif
 395         nvmem->eeprom.private = &nvmem->dev;
 396         nvmem->base_dev = config->base_dev;
 397
 398         rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
 399         if (rval) {
 400                 dev_err(&nvmem->dev,
 401                         "Failed to create eeprom binary file %d\n", rval);
 402                 return rval;
 403         }
 404
 405         nvmem->flags |= FLAG_COMPAT;
 406
 407         return 0;
 408 }
 409
 410 /**
 411  * nvmem_register() - Register a nvmem device for given nvmem_config.
 412  * Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
 413  *
 414  * @config: nvmem device configuration with which nvmem device is created.
 415  *
 416  * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
 417  * on success.
 418  */
 419
 420 struct nvmem_device *nvmem_register(const struct nvmem_config *config)
 421 {
 422         struct nvmem_device *nvmem;
 423         struct device_node *np;
 424         struct regmap *rm;
 425         int rval;
 426
 427         if (!config->dev)
 428                 return ERR_PTR(-EINVAL);
 429
 430         rm = dev_get_regmap(config->dev, NULL);
 431         if (!rm) {
 432                 dev_err(config->dev, "Regmap not found\n");
 433                 return ERR_PTR(-EINVAL);
 434         }
 435
 436         nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
 437         if (!nvmem)
 438                 return ERR_PTR(-ENOMEM);
 439
 440         rval  = ida_simple_get(&nvmem_ida, 0, 0, GFP_KERNEL);
 441         if (rval < 0) {
 442                 kfree(nvmem);
 443                 return ERR_PTR(rval);
 444         }
 445
 446         nvmem->id = rval;
 447         nvmem->regmap = rm;
 448         nvmem->owner = config->owner;
 449         nvmem->stride = regmap_get_reg_stride(rm);
 450         nvmem->word_size = regmap_get_val_bytes(rm);
 451         nvmem->size = regmap_get_max_register(rm) + nvmem->stride;
 452         nvmem->dev.type = &nvmem_provider_type;
 453         nvmem->dev.bus = &nvmem_bus_type;
 454         nvmem->dev.parent = config->dev;
 455         np = config->dev->of_node;
 456         nvmem->dev.of_node = np;
 457         dev_set_name(&nvmem->dev, "%s%d",
 458                      config->name ? : "nvmem", config->id);
 459
 460         nvmem->read_only = of_property_read_bool(np, "read-only") |
 461                            config->read_only;
 462
 463         if (config->root_only)
 464                 nvmem->dev.groups = nvmem->read_only ?
 465                         nvmem_ro_root_dev_groups :
 466                         nvmem_rw_root_dev_groups;
 467         else
 468                 nvmem->dev.groups = nvmem->read_only ?
 469                         nvmem_ro_dev_groups :
 470                         nvmem_rw_dev_groups;
 471
 472         device_initialize(&nvmem->dev);
 473
 474         dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
 475
 476         rval = device_add(&nvmem->dev);
 477         if (rval)
 478                 goto out;
 479
 480         if (config->compat) {
 481                 rval = nvmem_setup_compat(nvmem, config);
 482                 if (rval)
 483                         goto out;
 484         }
 485
 486         if (config->cells)
 487                 nvmem_add_cells(nvmem, config);
 488
 489         return nvmem;
 490 out:
 491         ida_simple_remove(&nvmem_ida, nvmem->id);
 492         kfree(nvmem);
 493         return ERR_PTR(rval);
 494 }
 495 EXPORT_SYMBOL_GPL(nvmem_register);
 496
 497 /**
 498  * nvmem_unregister() - Unregister previously registered nvmem device
 499  *
 500  * @nvmem: Pointer to previously registered nvmem device.
 501  *
 502  * Return: Will be an negative on error or a zero on success.
 503  */
 504 int nvmem_unregister(struct nvmem_device *nvmem)
 505 {
 506         mutex_lock(&nvmem_mutex);
 507         if (nvmem->users) {
 508                 mutex_unlock(&nvmem_mutex);
 509                 return -EBUSY;
 510         }
 511         mutex_unlock(&nvmem_mutex);
 512
 513         if (nvmem->flags & FLAG_COMPAT)
 514                 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
 515
 516         nvmem_device_remove_all_cells(nvmem);
 517         device_del(&nvmem->dev);
 518
 519         return 0;
 520 }
 521 EXPORT_SYMBOL_GPL(nvmem_unregister);
 522
 523 static struct nvmem_device *__nvmem_device_get(struct device_node *np,
 524                                                struct nvmem_cell **cellp,
 525                                                const char *cell_id)
 526 {
 527         struct nvmem_device *nvmem = NULL;
 528
 529         mutex_lock(&nvmem_mutex);
 530
 531         if (np) {
 532                 nvmem = of_nvmem_find(np);
 533                 if (!nvmem) {
 534                         mutex_unlock(&nvmem_mutex);
 535                         return ERR_PTR(-EPROBE_DEFER);
 536                 }
 537         } else {
 538                 struct nvmem_cell *cell = nvmem_find_cell(cell_id);
 539
 540                 if (cell) {
 541                         nvmem = cell->nvmem;
 542                         *cellp = cell;
 543                 }
 544
 545                 if (!nvmem) {
 546                         mutex_unlock(&nvmem_mutex);
 547                         return ERR_PTR(-ENOENT);
 548                 }
 549         }
 550
 551         nvmem->users++;
 552         mutex_unlock(&nvmem_mutex);
 553
 554         if (!try_module_get(nvmem->owner)) {
 555                 dev_err(&nvmem->dev,
 556                         "could not increase module refcount for cell %s\n",
 557                         nvmem->name);
 558
 559                 mutex_lock(&nvmem_mutex);
 560                 nvmem->users--;
 561                 mutex_unlock(&nvmem_mutex);
 562
 563                 return ERR_PTR(-EINVAL);
 564         }
 565
 566         return nvmem;
 567 }
 568
 569 static void __nvmem_device_put(struct nvmem_device *nvmem)
 570 {
 571         module_put(nvmem->owner);
 572         mutex_lock(&nvmem_mutex);
 573         nvmem->users--;
 574         mutex_unlock(&nvmem_mutex);
 575 }
 576
 577 static int nvmem_match(struct device *dev, void *data)
 578 {
 579         return !strcmp(dev_name(dev), data);
 580 }
 581
 582 static struct nvmem_device *nvmem_find(const char *name)
 583 {
 584         struct device *d;
 585
 586         d = bus_find_device(&nvmem_bus_type, NULL, (void *)name, nvmem_match);
 587
 588         if (!d)
 589                 return NULL;
 590
 591         return to_nvmem_device(d);
 592 }
 593
 594 #if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
 595 /**
 596  * of_nvmem_device_get() - Get nvmem device from a given id
 597  *
 598  * @dev node: Device tree node that uses the nvmem device
 599  * @id: nvmem name from nvmem-names property.
 600  *
 601  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
 602  * on success.
 603  */
 604 struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
 605 {
 606
 607         struct device_node *nvmem_np;
 608         int index;
 609
 610         index = of_property_match_string(np, "nvmem-names", id);
 611
 612         nvmem_np = of_parse_phandle(np, "nvmem", index);
 613         if (!nvmem_np)
 614                 return ERR_PTR(-EINVAL);
 615
 616         return __nvmem_device_get(nvmem_np, NULL, NULL);
 617 }
 618 EXPORT_SYMBOL_GPL(of_nvmem_device_get);
 619 #endif
 620
 621 /**
 622  * nvmem_device_get() - Get nvmem device from a given id
 623  *
 624  * @dev : Device that uses the nvmem device
 625  * @id: nvmem name from nvmem-names property.
 626  *
 627  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
 628  * on success.
 629  */
 630 struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
 631 {
 632         if (dev->of_node) { /* try dt first */
 633                 struct nvmem_device *nvmem;
 634
 635                 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
 636
 637                 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
 638                         return nvmem;
 639
 640         }
 641
 642         return nvmem_find(dev_name);
 643 }
 644 EXPORT_SYMBOL_GPL(nvmem_device_get);
 645
 646 static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
 647 {
 648         struct nvmem_device **nvmem = res;
 649
 650         if (WARN_ON(!nvmem || !*nvmem))
 651                 return 0;
 652
 653         return *nvmem == data;
 654 }
 655
 656 static void devm_nvmem_device_release(struct device *dev, void *res)
 657 {
 658         nvmem_device_put(*(struct nvmem_device **)res);
 659 }
 660
 661 /**
 662  * devm_nvmem_device_put() - put alredy got nvmem device
 663  *
 664  * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
 665  * that needs to be released.
 666  */
 667 void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
 668 {
 669         int ret;
 670
 671         ret = devres_release(dev, devm_nvmem_device_release,
 672                              devm_nvmem_device_match, nvmem);
 673
 674         WARN_ON(ret);
 675 }
 676 EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
 677
 678 /**
 679  * nvmem_device_put() - put alredy got nvmem device
 680  *
 681  * @nvmem: pointer to nvmem device that needs to be released.
 682  */
 683 void nvmem_device_put(struct nvmem_device *nvmem)
 684 {
 685         __nvmem_device_put(nvmem);
 686 }
 687 EXPORT_SYMBOL_GPL(nvmem_device_put);
 688
 689 /**
 690  * devm_nvmem_device_get() - Get nvmem cell of device form a given id
 691  *
 692  * @dev node: Device tree node that uses the nvmem cell
 693  * @id: nvmem name in nvmems property.
 694  *
 695  * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
 696  * on success.  The nvmem_cell will be freed by the automatically once the
 697  * device is freed.
 698  */
 699 struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
 700 {
 701         struct nvmem_device **ptr, *nvmem;
 702
 703         ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
 704         if (!ptr)
 705                 return ERR_PTR(-ENOMEM);
 706
 707         nvmem = nvmem_device_get(dev, id);
 708         if (!IS_ERR(nvmem)) {
 709                 *ptr = nvmem;
 710                 devres_add(dev, ptr);
 711         } else {
 712                 devres_free(ptr);
 713         }
 714
 715         return nvmem;
 716 }
 717 EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
 718
 719 static struct nvmem_cell *nvmem_cell_get_from_list(const char *cell_id)
 720 {
 721         struct nvmem_cell *cell = NULL;
 722         struct nvmem_device *nvmem;
 723
 724         nvmem = __nvmem_device_get(NULL, &cell, cell_id);
 725         if (IS_ERR(nvmem))
 726                 return ERR_CAST(nvmem);
 727
 728         return cell;
 729 }
 730
 731 #if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
 732 /**
 733  * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
 734  *
 735  * @dev node: Device tree node that uses the nvmem cell
 736  * @id: nvmem cell name from nvmem-cell-names property.
 737  *
 738  * Return: Will be an ERR_PTR() on error or a valid pointer
 739  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
 740  * nvmem_cell_put().
 741  */
 742 struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
 743                                             const char *name)
 744 {
 745         struct device_node *cell_np, *nvmem_np;
 746         struct nvmem_cell *cell;
 747         struct nvmem_device *nvmem;
 748         const __be32 *addr;
 749         int rval, len, index;
 750
 751         index = of_property_match_string(np, "nvmem-cell-names", name);
 752
 753         cell_np = of_parse_phandle(np, "nvmem-cells", index);
 754         if (!cell_np)
 755                 return ERR_PTR(-EINVAL);
 756
 757         nvmem_np = of_get_next_parent(cell_np);
 758         if (!nvmem_np)
 759                 return ERR_PTR(-EINVAL);
 760
 761         nvmem = __nvmem_device_get(nvmem_np, NULL, NULL);
 762         if (IS_ERR(nvmem))
 763                 return ERR_CAST(nvmem);
 764
 765         addr = of_get_property(cell_np, "reg", &len);
 766         if (!addr || (len < 2 * sizeof(u32))) {
 767                 dev_err(&nvmem->dev, "nvmem: invalid reg on %s\n",
 768                         cell_np->full_name);
 769                 rval  = -EINVAL;
 770                 goto err_mem;
 771         }
 772
 773         cell = kzalloc(sizeof(*cell), GFP_KERNEL);
 774         if (!cell) {
 775                 rval = -ENOMEM;
 776                 goto err_mem;
 777         }
 778
 779         cell->nvmem = nvmem;
 780         cell->offset = be32_to_cpup(addr++);
 781         cell->bytes = be32_to_cpup(addr);
 782         cell->name = cell_np->name;
 783
 784         addr = of_get_property(cell_np, "bits", &len);
 785         if (addr && len == (2 * sizeof(u32))) {
 786                 cell->bit_offset = be32_to_cpup(addr++);
 787                 cell->nbits = be32_to_cpup(addr);
 788         }
 789
 790         if (cell->nbits)
 791                 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
 792                                            BITS_PER_BYTE);
 793
 794         if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
 795                         dev_err(&nvmem->dev,
 796                                 "cell %s unaligned to nvmem stride %d\n",
 797                                 cell->name, nvmem->stride);
 798                 rval  = -EINVAL;
 799                 goto err_sanity;
 800         }
 801
 802         nvmem_cell_add(cell);
 803
 804         return cell;
 805
 806 err_sanity:
 807         kfree(cell);
 808
 809 err_mem:
 810         __nvmem_device_put(nvmem);
 811
 812         return ERR_PTR(rval);
 813 }
 814 EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
 815 #endif
 816
 817 /**
 818  * nvmem_cell_get() - Get nvmem cell of device form a given cell name
 819  *
 820  * @dev node: Device tree node that uses the nvmem cell
 821  * @id: nvmem cell name to get.
 822  *
 823  * Return: Will be an ERR_PTR() on error or a valid pointer
 824  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
 825  * nvmem_cell_put().
 826  */
 827 struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *cell_id)
 828 {
 829         struct nvmem_cell *cell;
 830
 831         if (dev->of_node) { /* try dt first */
 832                 cell = of_nvmem_cell_get(dev->of_node, cell_id);
 833                 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
 834                         return cell;
 835         }
 836
 837         return nvmem_cell_get_from_list(cell_id);
 838 }
 839 EXPORT_SYMBOL_GPL(nvmem_cell_get);
 840
 841 static void devm_nvmem_cell_release(struct device *dev, void *res)
 842 {
 843         nvmem_cell_put(*(struct nvmem_cell **)res);
 844 }
 845
 846 /**
 847  * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
 848  *
 849  * @dev node: Device tree node that uses the nvmem cell
 850  * @id: nvmem id in nvmem-names property.
 851  *
 852  * Return: Will be an ERR_PTR() on error or a valid pointer
 853  * to a struct nvmem_cell.  The nvmem_cell will be freed by the
 854  * automatically once the device is freed.
 855  */
 856 struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
 857 {
 858         struct nvmem_cell **ptr, *cell;
 859
 860         ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
 861         if (!ptr)
 862                 return ERR_PTR(-ENOMEM);
 863
 864         cell = nvmem_cell_get(dev, id);
 865         if (!IS_ERR(cell)) {
 866                 *ptr = cell;
 867                 devres_add(dev, ptr);
 868         } else {
 869                 devres_free(ptr);
 870         }
 871
 872         return cell;
 873 }
 874 EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
 875
 876 static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
 877 {
 878         struct nvmem_cell **c = res;
 879
 880         if (WARN_ON(!c || !*c))
 881                 return 0;
 882
 883         return *c == data;
 884 }
 885
 886 /**
 887  * devm_nvmem_cell_put() - Release previously allocated nvmem cell
 888  * from devm_nvmem_cell_get.
 889  *
 890  * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get()
 891  */
 892 void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
 893 {
 894         int ret;
 895
 896         ret = devres_release(dev, devm_nvmem_cell_release,
 897                                 devm_nvmem_cell_match, cell);
 898
 899         WARN_ON(ret);
 900 }
 901 EXPORT_SYMBOL(devm_nvmem_cell_put);
 902
 903 /**
 904  * nvmem_cell_put() - Release previously allocated nvmem cell.
 905  *
 906  * @cell: Previously allocated nvmem cell by nvmem_cell_get()
 907  */
 908 void nvmem_cell_put(struct nvmem_cell *cell)
 909 {
 910         struct nvmem_device *nvmem = cell->nvmem;
 911
 912         __nvmem_device_put(nvmem);
 913         nvmem_cell_drop(cell);
 914 }
 915 EXPORT_SYMBOL_GPL(nvmem_cell_put);
 916
 917 static inline void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell,
 918                                                     void *buf)
 919 {
 920         u8 *p, *b;
 921         int i, bit_offset = cell->bit_offset;
 922
 923         p = b = buf;
 924         if (bit_offset) {
 925                 /* First shift */
 926                 *b++ >>= bit_offset;
 927
 928                 /* setup rest of the bytes if any */
 929                 for (i = 1; i < cell->bytes; i++) {
 930                         /* Get bits from next byte and shift them towards msb */
 931                         *p |= *b << (BITS_PER_BYTE - bit_offset);
 932
 933                         p = b;
 934                         *b++ >>= bit_offset;
 935                 }
 936
 937                 /* result fits in less bytes */
 938                 if (cell->bytes != DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE))
 939                         *p-- = 0;
 940         }
 941         /* clear msb bits if any leftover in the last byte */
 942         *p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0);
 943 }
 944
 945 static int __nvmem_cell_read(struct nvmem_device *nvmem,
 946                       struct nvmem_cell *cell,
 947                       void *buf, size_t *len)
 948 {
 949         int rc;
 950
 951         rc = regmap_raw_read(nvmem->regmap, cell->offset, buf, cell->bytes);
 952
 953         if (IS_ERR_VALUE(rc))
 954                 return rc;
 955
 956         /* shift bits in-place */
 957         if (cell->bit_offset || cell->nbits)
 958                 nvmem_shift_read_buffer_in_place(cell, buf);
 959
 960         *len = cell->bytes;
 961
 962         return 0;
 963 }
 964
 965 /**
 966  * nvmem_cell_read() - Read a given nvmem cell
 967  *
 968  * @cell: nvmem cell to be read.
 969  * @len: pointer to length of cell which will be populated on successful read.
 970  *
 971  * Return: ERR_PTR() on error or a valid pointer to a char * buffer on success.
 972  * The buffer should be freed by the consumer with a kfree().
 973  */
 974 void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
 975 {
 976         struct nvmem_device *nvmem = cell->nvmem;
 977         u8 *buf;
 978         int rc;
 979
 980         if (!nvmem || !nvmem->regmap)
 981                 return ERR_PTR(-EINVAL);
 982
 983         buf = kzalloc(cell->bytes, GFP_KERNEL);
 984         if (!buf)
 985                 return ERR_PTR(-ENOMEM);
 986
 987         rc = __nvmem_cell_read(nvmem, cell, buf, len);
 988         if (IS_ERR_VALUE(rc)) {
 989                 kfree(buf);
 990                 return ERR_PTR(rc);
 991         }
 992
 993         return buf;
 994 }
 995 EXPORT_SYMBOL_GPL(nvmem_cell_read);
 996
 997 static inline void *nvmem_cell_prepare_write_buffer(struct nvmem_cell *cell,
 998                                                     u8 *_buf, int len)
 999 {
1000         struct nvmem_device *nvmem = cell->nvmem;
1001         int i, rc, nbits, bit_offset = cell->bit_offset;
1002         u8 v, *p, *buf, *b, pbyte, pbits;
1003
1004         nbits = cell->nbits;
1005         buf = kzalloc(cell->bytes, GFP_KERNEL);
1006         if (!buf)
1007                 return ERR_PTR(-ENOMEM);
1008
1009         memcpy(buf, _buf, len);
1010         p = b = buf;
1011
1012         if (bit_offset) {
1013                 pbyte = *b;
1014                 *b <<= bit_offset;
1015
1016                 /* setup the first byte with lsb bits from nvmem */
1017                 rc = regmap_raw_read(nvmem->regmap, cell->offset, &v, 1);
1018                 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1019
1020                 /* setup rest of the byte if any */
1021                 for (i = 1; i < cell->bytes; i++) {
1022                         /* Get last byte bits and shift them towards lsb */
1023                         pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1024                         pbyte = *b;
1025                         p = b;
1026                         *b <<= bit_offset;
1027                         *b++ |= pbits;
1028                 }
1029         }
1030
1031         /* if it's not end on byte boundary */
1032         if ((nbits + bit_offset) % BITS_PER_BYTE) {
1033                 /* setup the last byte with msb bits from nvmem */
1034                 rc = regmap_raw_read(nvmem->regmap,
1035                                     cell->offset + cell->bytes - 1, &v, 1);
1036                 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1037
1038         }
1039
1040         return buf;
1041 }
1042
1043 /**
1044  * nvmem_cell_write() - Write to a given nvmem cell
1045  *
1046  * @cell: nvmem cell to be written.
1047  * @buf: Buffer to be written.
1048  * @len: length of buffer to be written to nvmem cell.
1049  *
1050  * Return: length of bytes written or negative on failure.
1051  */
1052 int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1053 {
1054         struct nvmem_device *nvmem = cell->nvmem;
1055         int rc;
1056
1057         if (!nvmem || !nvmem->regmap || nvmem->read_only ||
1058             (cell->bit_offset == 0 && len != cell->bytes))
1059                 return -EINVAL;
1060
1061         if (cell->bit_offset || cell->nbits) {
1062                 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1063                 if (IS_ERR(buf))
1064                         return PTR_ERR(buf);
1065         }
1066
1067         rc = regmap_raw_write(nvmem->regmap, cell->offset, buf, cell->bytes);
1068
1069         /* free the tmp buffer */
1070         if (cell->bit_offset || cell->nbits)
1071                 kfree(buf);
1072
1073         if (IS_ERR_VALUE(rc))
1074                 return rc;
1075
1076         return len;
1077 }
1078 EXPORT_SYMBOL_GPL(nvmem_cell_write);
1079
1080 /**
1081  * nvmem_device_cell_read() - Read a given nvmem device and cell
1082  *
1083  * @nvmem: nvmem device to read from.
1084  * @info: nvmem cell info to be read.
1085  * @buf: buffer pointer which will be populated on successful read.
1086  *
1087  * Return: length of successful bytes read on success and negative
1088  * error code on error.
1089  */
1090 ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
1091                            struct nvmem_cell_info *info, void *buf)
1092 {
1093         struct nvmem_cell cell;
1094         int rc;
1095         ssize_t len;
1096
1097         if (!nvmem || !nvmem->regmap)
1098                 return -EINVAL;
1099
1100         rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1101         if (IS_ERR_VALUE(rc))
1102                 return rc;
1103
1104         rc = __nvmem_cell_read(nvmem, &cell, buf, &len);
1105         if (IS_ERR_VALUE(rc))
1106                 return rc;
1107
1108         return len;
1109 }
1110 EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
1111
1112 /**
1113  * nvmem_device_cell_write() - Write cell to a given nvmem device
1114  *
1115  * @nvmem: nvmem device to be written to.
1116  * @info: nvmem cell info to be written
1117  * @buf: buffer to be written to cell.
1118  *
1119  * Return: length of bytes written or negative error code on failure.
1120  * */
1121 int nvmem_device_cell_write(struct nvmem_device *nvmem,
1122                             struct nvmem_cell_info *info, void *buf)
1123 {
1124         struct nvmem_cell cell;
1125         int rc;
1126
1127         if (!nvmem || !nvmem->regmap)
1128                 return -EINVAL;
1129
1130         rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1131         if (IS_ERR_VALUE(rc))
1132                 return rc;
1133
1134         return nvmem_cell_write(&cell, buf, cell.bytes);
1135 }
1136 EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
1137
1138 /**
1139  * nvmem_device_read() - Read from a given nvmem device
1140  *
1141  * @nvmem: nvmem device to read from.
1142  * @offset: offset in nvmem device.
1143  * @bytes: number of bytes to read.
1144  * @buf: buffer pointer which will be populated on successful read.
1145  *
1146  * Return: length of successful bytes read on success and negative
1147  * error code on error.
1148  */
1149 int nvmem_device_read(struct nvmem_device *nvmem,
1150                       unsigned int offset,
1151                       size_t bytes, void *buf)
1152 {
1153         int rc;
1154
1155         if (!nvmem || !nvmem->regmap)
1156                 return -EINVAL;
1157
1158         rc = regmap_raw_read(nvmem->regmap, offset, buf, bytes);
1159
1160         if (IS_ERR_VALUE(rc))
1161                 return rc;
1162
1163         return bytes;
1164 }
1165 EXPORT_SYMBOL_GPL(nvmem_device_read);
1166
1167 /**
1168  * nvmem_device_write() - Write cell to a given nvmem device
1169  *
1170  * @nvmem: nvmem device to be written to.
1171  * @offset: offset in nvmem device.
1172  * @bytes: number of bytes to write.
1173  * @buf: buffer to be written.
1174  *
1175  * Return: length of bytes written or negative error code on failure.
1176  * */
1177 int nvmem_device_write(struct nvmem_device *nvmem,
1178                        unsigned int offset,
1179                        size_t bytes, void *buf)
1180 {
1181         int rc;
1182
1183         if (!nvmem || !nvmem->regmap)
1184                 return -EINVAL;
1185
1186         rc = regmap_raw_write(nvmem->regmap, offset, buf, bytes);
1187
1188         if (IS_ERR_VALUE(rc))
1189                 return rc;
1190
1191
1192         return bytes;
1193 }
1194 EXPORT_SYMBOL_GPL(nvmem_device_write);
1195
1196 static int __init nvmem_init(void)
1197 {
1198         return bus_register(&nvmem_bus_type);
1199 }
1200
1201 static void __exit nvmem_exit(void)
1202 {
1203         bus_unregister(&nvmem_bus_type);
1204 }
1205
1206 subsys_initcall(nvmem_init);
1207 module_exit(nvmem_exit);
1208
1209 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
1210 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
1211 MODULE_DESCRIPTION("nvmem Driver Core");
1212 MODULE_LICENSE("GPL v2");