regmap.c (c0cc6fe1d09e3f1baecbdf8922473c8e7d3a5317) regmap.c (f01ee60fffa4dc6c77122121233a793f7f696e67)
1/*
2 * Register map access API
3 *
4 * Copyright 2011 Wolfson Microelectronics plc
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 * This program is free software; you can redistribute it and/or modify

--- 229 unchanged lines hidden (view full) ---

238 map->unlock = regmap_unlock_mutex;
239 }
240 map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
241 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
242 map->format.pad_bytes = config->pad_bits / 8;
243 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
244 map->format.buf_size += map->format.pad_bytes;
245 map->reg_shift = config->pad_bits % 8;
1/*
2 * Register map access API
3 *
4 * Copyright 2011 Wolfson Microelectronics plc
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 * This program is free software; you can redistribute it and/or modify

--- 229 unchanged lines hidden (view full) ---

238 map->unlock = regmap_unlock_mutex;
239 }
240 map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
241 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
242 map->format.pad_bytes = config->pad_bits / 8;
243 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
244 map->format.buf_size += map->format.pad_bytes;
245 map->reg_shift = config->pad_bits % 8;
246 if (config->reg_stride)
247 map->reg_stride = config->reg_stride;
248 else
249 map->reg_stride = 1;
246 map->dev = dev;
247 map->bus = bus;
248 map->bus_context = bus_context;
249 map->max_register = config->max_register;
250 map->writeable_reg = config->writeable_reg;
251 map->readable_reg = config->readable_reg;
252 map->volatile_reg = config->volatile_reg;
253 map->precious_reg = config->precious_reg;

--- 210 unchanged lines hidden (view full) ---

464 void *buf;
465 int ret = -ENOTSUPP;
466 size_t len;
467 int i;
468
469 /* Check for unwritable registers before we start */
470 if (map->writeable_reg)
471 for (i = 0; i < val_len / map->format.val_bytes; i++)
250 map->dev = dev;
251 map->bus = bus;
252 map->bus_context = bus_context;
253 map->max_register = config->max_register;
254 map->writeable_reg = config->writeable_reg;
255 map->readable_reg = config->readable_reg;
256 map->volatile_reg = config->volatile_reg;
257 map->precious_reg = config->precious_reg;

--- 210 unchanged lines hidden (view full) ---

468 void *buf;
469 int ret = -ENOTSUPP;
470 size_t len;
471 int i;
472
473 /* Check for unwritable registers before we start */
474 if (map->writeable_reg)
475 for (i = 0; i < val_len / map->format.val_bytes; i++)
472 if (!map->writeable_reg(map->dev, reg + i))
476 if (!map->writeable_reg(map->dev,
477 reg + (i * map->reg_stride)))
473 return -EINVAL;
474
475 if (!map->cache_bypass && map->format.parse_val) {
476 unsigned int ival;
477 int val_bytes = map->format.val_bytes;
478 for (i = 0; i < val_len / val_bytes; i++) {
479 memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
480 ival = map->format.parse_val(map->work_buf);
478 return -EINVAL;
479
480 if (!map->cache_bypass && map->format.parse_val) {
481 unsigned int ival;
482 int val_bytes = map->format.val_bytes;
483 for (i = 0; i < val_len / val_bytes; i++) {
484 memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
485 ival = map->format.parse_val(map->work_buf);
481 ret = regcache_write(map, reg + i, ival);
486 ret = regcache_write(map, reg + (i * map->reg_stride),
487 ival);
482 if (ret) {
483 dev_err(map->dev,
484 "Error in caching of register: %u ret: %d\n",
485 reg + i, ret);
486 return ret;
487 }
488 }
489 if (map->cache_only) {

--- 95 unchanged lines hidden (view full) ---

585 *
586 * A value of zero will be returned on success, a negative errno will
587 * be returned in error cases.
588 */
589int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
590{
591 int ret;
592
488 if (ret) {
489 dev_err(map->dev,
490 "Error in caching of register: %u ret: %d\n",
491 reg + i, ret);
492 return ret;
493 }
494 }
495 if (map->cache_only) {

--- 95 unchanged lines hidden (view full) ---

591 *
592 * A value of zero will be returned on success, a negative errno will
593 * be returned in error cases.
594 */
595int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
596{
597 int ret;
598
599 if (reg % map->reg_stride)
600 return -EINVAL;
601
593 map->lock(map);
594
595 ret = _regmap_write(map, reg, val);
596
597 map->unlock(map);
598
599 return ret;
600}

--- 17 unchanged lines hidden (view full) ---

618 */
619int regmap_raw_write(struct regmap *map, unsigned int reg,
620 const void *val, size_t val_len)
621{
622 int ret;
623
624 if (val_len % map->format.val_bytes)
625 return -EINVAL;
602 map->lock(map);
603
604 ret = _regmap_write(map, reg, val);
605
606 map->unlock(map);
607
608 return ret;
609}

--- 17 unchanged lines hidden (view full) ---

627 */
628int regmap_raw_write(struct regmap *map, unsigned int reg,
629 const void *val, size_t val_len)
630{
631 int ret;
632
633 if (val_len % map->format.val_bytes)
634 return -EINVAL;
635 if (reg % map->reg_stride)
636 return -EINVAL;
626
627 map->lock(map);
628
629 ret = _regmap_raw_write(map, reg, val, val_len);
630
631 map->unlock(map);
632
633 return ret;

--- 18 unchanged lines hidden (view full) ---

652 size_t val_count)
653{
654 int ret = 0, i;
655 size_t val_bytes = map->format.val_bytes;
656 void *wval;
657
658 if (!map->format.parse_val)
659 return -EINVAL;
637
638 map->lock(map);
639
640 ret = _regmap_raw_write(map, reg, val, val_len);
641
642 map->unlock(map);
643
644 return ret;

--- 18 unchanged lines hidden (view full) ---

663 size_t val_count)
664{
665 int ret = 0, i;
666 size_t val_bytes = map->format.val_bytes;
667 void *wval;
668
669 if (!map->format.parse_val)
670 return -EINVAL;
671 if (reg % map->reg_stride)
672 return -EINVAL;
660
661 map->lock(map);
662
663 /* No formatting is require if val_byte is 1 */
664 if (val_bytes == 1) {
665 wval = (void *)val;
666 } else {
667 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);

--- 80 unchanged lines hidden (view full) ---

748 *
749 * A value of zero will be returned on success, a negative errno will
750 * be returned in error cases.
751 */
752int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
753{
754 int ret;
755
673
674 map->lock(map);
675
676 /* No formatting is require if val_byte is 1 */
677 if (val_bytes == 1) {
678 wval = (void *)val;
679 } else {
680 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);

--- 80 unchanged lines hidden (view full) ---

761 *
762 * A value of zero will be returned on success, a negative errno will
763 * be returned in error cases.
764 */
765int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
766{
767 int ret;
768
769 if (reg % map->reg_stride)
770 return -EINVAL;
771
756 map->lock(map);
757
758 ret = _regmap_read(map, reg, val);
759
760 map->unlock(map);
761
762 return ret;
763}

--- 15 unchanged lines hidden (view full) ---

779{
780 size_t val_bytes = map->format.val_bytes;
781 size_t val_count = val_len / val_bytes;
782 unsigned int v;
783 int ret, i;
784
785 if (val_len % map->format.val_bytes)
786 return -EINVAL;
772 map->lock(map);
773
774 ret = _regmap_read(map, reg, val);
775
776 map->unlock(map);
777
778 return ret;
779}

--- 15 unchanged lines hidden (view full) ---

795{
796 size_t val_bytes = map->format.val_bytes;
797 size_t val_count = val_len / val_bytes;
798 unsigned int v;
799 int ret, i;
800
801 if (val_len % map->format.val_bytes)
802 return -EINVAL;
803 if (reg % map->reg_stride)
804 return -EINVAL;
787
788 map->lock(map);
789
790 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
791 map->cache_type == REGCACHE_NONE) {
792 /* Physical block read if there's no cache involved */
793 ret = _regmap_raw_read(map, reg, val, val_len);
794
795 } else {
796 /* Otherwise go word by word for the cache; should be low
797 * cost as we expect to hit the cache.
798 */
799 for (i = 0; i < val_count; i++) {
805
806 map->lock(map);
807
808 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
809 map->cache_type == REGCACHE_NONE) {
810 /* Physical block read if there's no cache involved */
811 ret = _regmap_raw_read(map, reg, val, val_len);
812
813 } else {
814 /* Otherwise go word by word for the cache; should be low
815 * cost as we expect to hit the cache.
816 */
817 for (i = 0; i < val_count; i++) {
800 ret = _regmap_read(map, reg + i, &v);
818 ret = _regmap_read(map, reg + (i * map->reg_stride),
819 &v);
801 if (ret != 0)
802 goto out;
803
804 map->format.format_val(val + (i * val_bytes), v, 0);
805 }
806 }
807
808 out:

--- 18 unchanged lines hidden (view full) ---

827 size_t val_count)
828{
829 int ret, i;
830 size_t val_bytes = map->format.val_bytes;
831 bool vol = regmap_volatile_range(map, reg, val_count);
832
833 if (!map->format.parse_val)
834 return -EINVAL;
820 if (ret != 0)
821 goto out;
822
823 map->format.format_val(val + (i * val_bytes), v, 0);
824 }
825 }
826
827 out:

--- 18 unchanged lines hidden (view full) ---

846 size_t val_count)
847{
848 int ret, i;
849 size_t val_bytes = map->format.val_bytes;
850 bool vol = regmap_volatile_range(map, reg, val_count);
851
852 if (!map->format.parse_val)
853 return -EINVAL;
854 if (reg % map->reg_stride)
855 return -EINVAL;
835
836 if (vol || map->cache_type == REGCACHE_NONE) {
837 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
838 if (ret != 0)
839 return ret;
840
841 for (i = 0; i < val_count * val_bytes; i += val_bytes)
842 map->format.parse_val(val + i);
843 } else {
844 for (i = 0; i < val_count; i++) {
856
857 if (vol || map->cache_type == REGCACHE_NONE) {
858 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
859 if (ret != 0)
860 return ret;
861
862 for (i = 0; i < val_count * val_bytes; i += val_bytes)
863 map->format.parse_val(val + i);
864 } else {
865 for (i = 0; i < val_count; i++) {
845 ret = regmap_read(map, reg + i, val + (i * val_bytes));
866 ret = regmap_read(map, reg + (i * map->reg_stride),
867 val + (i * val_bytes));
846 if (ret != 0)
847 return ret;
848 }
849 }
850
851 return 0;
852}
853EXPORT_SYMBOL_GPL(regmap_bulk_read);

--- 148 unchanged lines hidden --- 		868 if (ret != 0)
869 return ret;
870 }
871 }
872
873 return 0;
874}
875EXPORT_SYMBOL_GPL(regmap_bulk_read);

--- 148 unchanged lines hidden ---