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"); 1213