inkern.c (7349e8a36caa11c07e71b05f42c384bc540446c8) inkern.c (b804e2b76ac6d5559b99588e0190ac97b5597497)
1// SPDX-License-Identifier: GPL-2.0-only
2/* The industrial I/O core in kernel channel mapping
3 *
4 * Copyright (c) 2011 Jonathan Cameron
5 */
6#include <linux/err.h>
7#include <linux/export.h>
8#include <linux/slab.h>
9#include <linux/mutex.h>
10#include <linux/of.h>
11
12#include <linux/iio/iio.h>
1// SPDX-License-Identifier: GPL-2.0-only
2/* The industrial I/O core in kernel channel mapping
3 *
4 * Copyright (c) 2011 Jonathan Cameron
5 */
6#include <linux/err.h>
7#include <linux/export.h>
8#include <linux/slab.h>
9#include <linux/mutex.h>
10#include <linux/of.h>
11
12#include <linux/iio/iio.h>
13#include <linux/iio/iio-opaque.h>
13#include "iio_core.h"
14#include <linux/iio/machine.h>
15#include <linux/iio/driver.h>
16#include <linux/iio/consumer.h>
17
18struct iio_map_internal {
19 struct iio_dev *indio_dev;
20 struct iio_map *map;

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

533 ret = chan->indio_dev->info->read_raw(chan->indio_dev,
534 chan->channel, val, val2, info);
535
536 return ret;
537}
538
539int iio_read_channel_raw(struct iio_channel *chan, int *val)
540{
14#include "iio_core.h"
15#include <linux/iio/machine.h>
16#include <linux/iio/driver.h>
17#include <linux/iio/consumer.h>
18
19struct iio_map_internal {
20 struct iio_dev *indio_dev;
21 struct iio_map *map;

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

534 ret = chan->indio_dev->info->read_raw(chan->indio_dev,
535 chan->channel, val, val2, info);
536
537 return ret;
538}
539
540int iio_read_channel_raw(struct iio_channel *chan, int *val)
541{
542 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
541 int ret;
542
543 int ret;
544
543 mutex_lock(&chan->indio_dev->info_exist_lock);
545 mutex_lock(&iio_dev_opaque->info_exist_lock);
544 if (chan->indio_dev->info == NULL) {
545 ret = -ENODEV;
546 goto err_unlock;
547 }
548
549 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
550err_unlock:
546 if (chan->indio_dev->info == NULL) {
547 ret = -ENODEV;
548 goto err_unlock;
549 }
550
551 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
552err_unlock:
551 mutex_unlock(&chan->indio_dev->info_exist_lock);
553 mutex_unlock(&iio_dev_opaque->info_exist_lock);
552
553 return ret;
554}
555EXPORT_SYMBOL_GPL(iio_read_channel_raw);
556
557int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
558{
554
555 return ret;
556}
557EXPORT_SYMBOL_GPL(iio_read_channel_raw);
558
559int iio_read_channel_average_raw(struct iio_channel *chan, int *val)
560{
561 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
559 int ret;
560
562 int ret;
563
561 mutex_lock(&chan->indio_dev->info_exist_lock);
564 mutex_lock(&iio_dev_opaque->info_exist_lock);
562 if (chan->indio_dev->info == NULL) {
563 ret = -ENODEV;
564 goto err_unlock;
565 }
566
567 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
568err_unlock:
565 if (chan->indio_dev->info == NULL) {
566 ret = -ENODEV;
567 goto err_unlock;
568 }
569
570 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_AVERAGE_RAW);
571err_unlock:
569 mutex_unlock(&chan->indio_dev->info_exist_lock);
572 mutex_unlock(&iio_dev_opaque->info_exist_lock);
570
571 return ret;
572}
573EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
574
575static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
576 int raw, int *processed, unsigned int scale)
577{

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

626 }
627
628 return 0;
629}
630
631int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
632 int *processed, unsigned int scale)
633{
573
574 return ret;
575}
576EXPORT_SYMBOL_GPL(iio_read_channel_average_raw);
577
578static int iio_convert_raw_to_processed_unlocked(struct iio_channel *chan,
579 int raw, int *processed, unsigned int scale)
580{

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

629 }
630
631 return 0;
632}
633
634int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
635 int *processed, unsigned int scale)
636{
637 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
634 int ret;
635
638 int ret;
639
636 mutex_lock(&chan->indio_dev->info_exist_lock);
640 mutex_lock(&iio_dev_opaque->info_exist_lock);
637 if (chan->indio_dev->info == NULL) {
638 ret = -ENODEV;
639 goto err_unlock;
640 }
641
642 ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
643 scale);
644err_unlock:
641 if (chan->indio_dev->info == NULL) {
642 ret = -ENODEV;
643 goto err_unlock;
644 }
645
646 ret = iio_convert_raw_to_processed_unlocked(chan, raw, processed,
647 scale);
648err_unlock:
645 mutex_unlock(&chan->indio_dev->info_exist_lock);
649 mutex_unlock(&iio_dev_opaque->info_exist_lock);
646
647 return ret;
648}
649EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
650
651int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
652 enum iio_chan_info_enum attribute)
653{
650
651 return ret;
652}
653EXPORT_SYMBOL_GPL(iio_convert_raw_to_processed);
654
655int iio_read_channel_attribute(struct iio_channel *chan, int *val, int *val2,
656 enum iio_chan_info_enum attribute)
657{
658 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
654 int ret;
655
659 int ret;
660
656 mutex_lock(&chan->indio_dev->info_exist_lock);
661 mutex_lock(&iio_dev_opaque->info_exist_lock);
657 if (chan->indio_dev->info == NULL) {
658 ret = -ENODEV;
659 goto err_unlock;
660 }
661
662 ret = iio_channel_read(chan, val, val2, attribute);
663err_unlock:
662 if (chan->indio_dev->info == NULL) {
663 ret = -ENODEV;
664 goto err_unlock;
665 }
666
667 ret = iio_channel_read(chan, val, val2, attribute);
668err_unlock:
664 mutex_unlock(&chan->indio_dev->info_exist_lock);
669 mutex_unlock(&iio_dev_opaque->info_exist_lock);
665
666 return ret;
667}
668EXPORT_SYMBOL_GPL(iio_read_channel_attribute);
669
670int iio_read_channel_offset(struct iio_channel *chan, int *val, int *val2)
671{
672 return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_OFFSET);
673}
674EXPORT_SYMBOL_GPL(iio_read_channel_offset);
675
676int iio_read_channel_processed_scale(struct iio_channel *chan, int *val,
677 unsigned int scale)
678{
670
671 return ret;
672}
673EXPORT_SYMBOL_GPL(iio_read_channel_attribute);
674
675int iio_read_channel_offset(struct iio_channel *chan, int *val, int *val2)
676{
677 return iio_read_channel_attribute(chan, val, val2, IIO_CHAN_INFO_OFFSET);
678}
679EXPORT_SYMBOL_GPL(iio_read_channel_offset);
680
681int iio_read_channel_processed_scale(struct iio_channel *chan, int *val,
682 unsigned int scale)
683{
684 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
679 int ret;
680
685 int ret;
686
681 mutex_lock(&chan->indio_dev->info_exist_lock);
687 mutex_lock(&iio_dev_opaque->info_exist_lock);
682 if (chan->indio_dev->info == NULL) {
683 ret = -ENODEV;
684 goto err_unlock;
685 }
686
687 if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
688 ret = iio_channel_read(chan, val, NULL,
689 IIO_CHAN_INFO_PROCESSED);

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

694 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
695 if (ret < 0)
696 goto err_unlock;
697 ret = iio_convert_raw_to_processed_unlocked(chan, *val, val,
698 scale);
699 }
700
701err_unlock:
688 if (chan->indio_dev->info == NULL) {
689 ret = -ENODEV;
690 goto err_unlock;
691 }
692
693 if (iio_channel_has_info(chan->channel, IIO_CHAN_INFO_PROCESSED)) {
694 ret = iio_channel_read(chan, val, NULL,
695 IIO_CHAN_INFO_PROCESSED);

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

700 ret = iio_channel_read(chan, val, NULL, IIO_CHAN_INFO_RAW);
701 if (ret < 0)
702 goto err_unlock;
703 ret = iio_convert_raw_to_processed_unlocked(chan, *val, val,
704 scale);
705 }
706
707err_unlock:
702 mutex_unlock(&chan->indio_dev->info_exist_lock);
708 mutex_unlock(&iio_dev_opaque->info_exist_lock);
703
704 return ret;
705}
706EXPORT_SYMBOL_GPL(iio_read_channel_processed_scale);
707
708int iio_read_channel_processed(struct iio_channel *chan, int *val)
709{
710 /* This is just a special case with scale factor 1 */

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

728 return chan->indio_dev->info->read_avail(chan->indio_dev, chan->channel,
729 vals, type, length, info);
730}
731
732int iio_read_avail_channel_attribute(struct iio_channel *chan,
733 const int **vals, int *type, int *length,
734 enum iio_chan_info_enum attribute)
735{
709
710 return ret;
711}
712EXPORT_SYMBOL_GPL(iio_read_channel_processed_scale);
713
714int iio_read_channel_processed(struct iio_channel *chan, int *val)
715{
716 /* This is just a special case with scale factor 1 */

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

734 return chan->indio_dev->info->read_avail(chan->indio_dev, chan->channel,
735 vals, type, length, info);
736}
737
738int iio_read_avail_channel_attribute(struct iio_channel *chan,
739 const int **vals, int *type, int *length,
740 enum iio_chan_info_enum attribute)
741{
742 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
736 int ret;
737
743 int ret;
744
738 mutex_lock(&chan->indio_dev->info_exist_lock);
745 mutex_lock(&iio_dev_opaque->info_exist_lock);
739 if (!chan->indio_dev->info) {
740 ret = -ENODEV;
741 goto err_unlock;
742 }
743
744 ret = iio_channel_read_avail(chan, vals, type, length, attribute);
745err_unlock:
746 if (!chan->indio_dev->info) {
747 ret = -ENODEV;
748 goto err_unlock;
749 }
750
751 ret = iio_channel_read_avail(chan, vals, type, length, attribute);
752err_unlock:
746 mutex_unlock(&chan->indio_dev->info_exist_lock);
753 mutex_unlock(&iio_dev_opaque->info_exist_lock);
747
748 return ret;
749}
750EXPORT_SYMBOL_GPL(iio_read_avail_channel_attribute);
751
752int iio_read_avail_channel_raw(struct iio_channel *chan,
753 const int **vals, int *length)
754{

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

810
811 default:
812 return ret;
813 }
814}
815
816int iio_read_max_channel_raw(struct iio_channel *chan, int *val)
817{
754
755 return ret;
756}
757EXPORT_SYMBOL_GPL(iio_read_avail_channel_attribute);
758
759int iio_read_avail_channel_raw(struct iio_channel *chan,
760 const int **vals, int *length)
761{

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

817
818 default:
819 return ret;
820 }
821}
822
823int iio_read_max_channel_raw(struct iio_channel *chan, int *val)
824{
825 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
818 int ret;
819 int type;
820
826 int ret;
827 int type;
828
821 mutex_lock(&chan->indio_dev->info_exist_lock);
829 mutex_lock(&iio_dev_opaque->info_exist_lock);
822 if (!chan->indio_dev->info) {
823 ret = -ENODEV;
824 goto err_unlock;
825 }
826
827 ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
828err_unlock:
830 if (!chan->indio_dev->info) {
831 ret = -ENODEV;
832 goto err_unlock;
833 }
834
835 ret = iio_channel_read_max(chan, val, NULL, &type, IIO_CHAN_INFO_RAW);
836err_unlock:
829 mutex_unlock(&chan->indio_dev->info_exist_lock);
837 mutex_unlock(&iio_dev_opaque->info_exist_lock);
830
831 return ret;
832}
833EXPORT_SYMBOL_GPL(iio_read_max_channel_raw);
834
835int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
836{
838
839 return ret;
840}
841EXPORT_SYMBOL_GPL(iio_read_max_channel_raw);
842
843int iio_get_channel_type(struct iio_channel *chan, enum iio_chan_type *type)
844{
845 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
837 int ret = 0;
838 /* Need to verify underlying driver has not gone away */
839
846 int ret = 0;
847 /* Need to verify underlying driver has not gone away */
848
840 mutex_lock(&chan->indio_dev->info_exist_lock);
849 mutex_lock(&iio_dev_opaque->info_exist_lock);
841 if (chan->indio_dev->info == NULL) {
842 ret = -ENODEV;
843 goto err_unlock;
844 }
845
846 *type = chan->channel->type;
847err_unlock:
850 if (chan->indio_dev->info == NULL) {
851 ret = -ENODEV;
852 goto err_unlock;
853 }
854
855 *type = chan->channel->type;
856err_unlock:
848 mutex_unlock(&chan->indio_dev->info_exist_lock);
857 mutex_unlock(&iio_dev_opaque->info_exist_lock);
849
850 return ret;
851}
852EXPORT_SYMBOL_GPL(iio_get_channel_type);
853
854static int iio_channel_write(struct iio_channel *chan, int val, int val2,
855 enum iio_chan_info_enum info)
856{
857 return chan->indio_dev->info->write_raw(chan->indio_dev,
858 chan->channel, val, val2, info);
859}
860
861int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
862 enum iio_chan_info_enum attribute)
863{
858
859 return ret;
860}
861EXPORT_SYMBOL_GPL(iio_get_channel_type);
862
863static int iio_channel_write(struct iio_channel *chan, int val, int val2,
864 enum iio_chan_info_enum info)
865{
866 return chan->indio_dev->info->write_raw(chan->indio_dev,
867 chan->channel, val, val2, info);
868}
869
870int iio_write_channel_attribute(struct iio_channel *chan, int val, int val2,
871 enum iio_chan_info_enum attribute)
872{
873 struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(chan->indio_dev);
864 int ret;
865
874 int ret;
875
866 mutex_lock(&chan->indio_dev->info_exist_lock);
876 mutex_lock(&iio_dev_opaque->info_exist_lock);
867 if (chan->indio_dev->info == NULL) {
868 ret = -ENODEV;
869 goto err_unlock;
870 }
871
872 ret = iio_channel_write(chan, val, val2, attribute);
873err_unlock:
877 if (chan->indio_dev->info == NULL) {
878 ret = -ENODEV;
879 goto err_unlock;
880 }
881
882 ret = iio_channel_write(chan, val, val2, attribute);
883err_unlock:
874 mutex_unlock(&chan->indio_dev->info_exist_lock);
884 mutex_unlock(&iio_dev_opaque->info_exist_lock);
875
876 return ret;
877}
878EXPORT_SYMBOL_GPL(iio_write_channel_attribute);
879
880int iio_write_channel_raw(struct iio_channel *chan, int val)
881{
882 return iio_write_channel_attribute(chan, val, 0, IIO_CHAN_INFO_RAW);

--- 62 unchanged lines hidden --- 		885
886 return ret;
887}
888EXPORT_SYMBOL_GPL(iio_write_channel_attribute);
889
890int iio_write_channel_raw(struct iio_channel *chan, int val)
891{
892 return iio_write_channel_attribute(chan, val, 0, IIO_CHAN_INFO_RAW);

--- 62 unchanged lines hidden ---