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