← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/iio/adc/ad7150.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/adc/ad7150.c
7
7
 */
8
8
 
9
9
#include <linux/interrupt.h>
10
 
#include <linux/gpio.h>
11
 
#include <linux/workqueue.h>
12
10
#include <linux/device.h>
13
11
#include <linux/kernel.h>
14
12
#include <linux/slab.h>
15
 
#include <linux/sysfs.h>
16
 
#include <linux/list.h>
17
13
#include <linux/i2c.h>
18
 
#include <linux/rtc.h>
19
14
 
20
15
#include "../iio.h"
21
16
#include "../sysfs.h"
63
58
 */
64
59
 
65
60
struct ad7150_chip_info {
66
 
        const char *name;
67
61
        struct i2c_client *client;
68
62
        struct iio_dev *indio_dev;
69
 
        struct work_struct thresh_work;
70
63
        bool inter;
71
 
        s64 last_timestamp;
72
64
        u16 ch1_threshold;     /* Ch1 Threshold (in fixed threshold mode) */
73
65
        u8  ch1_sensitivity;   /* Ch1 Sensitivity (in adaptive threshold mode) */
74
66
        u8  ch1_timeout;       /* Ch1 Timeout (in adaptive threshold mode) */
88
80
        u8 reg_cfg;
89
81
};
90
82
 
91
 
struct ad7150_conversion_mode ad7150_conv_mode_table[AD7150_MAX_CONV_MODE] = {
 
83
static struct ad7150_conversion_mode
 
84
ad7150_conv_mode_table[AD7150_MAX_CONV_MODE] = {
92
85
        { "idle", 0 },
93
86
        { "continuous-conversion", 1 },
94
87
        { "single-conversion", 2 },
590
583
                ad7150_show_ch2_setup,
591
584
                ad7150_store_ch2_setup);
592
585
 
593
 
static ssize_t ad7150_show_name(struct device *dev,
594
 
                struct device_attribute *attr,
595
 
                char *buf)
596
 
{
597
 
        struct iio_dev *dev_info = dev_get_drvdata(dev);
598
 
        struct ad7150_chip_info *chip = dev_info->dev_data;
599
 
        return sprintf(buf, "%s\n", chip->name);
600
 
}
601
 
 
602
 
static IIO_DEVICE_ATTR(name, S_IRUGO, ad7150_show_name, NULL, 0);
603
 
 
604
586
static ssize_t ad7150_show_powerdown_timer(struct device *dev,
605
587
                struct device_attribute *attr,
606
588
                char *buf)
649
631
        &iio_dev_attr_powerdown_timer.dev_attr.attr,
650
632
        &iio_dev_attr_ch1_value.dev_attr.attr,
651
633
        &iio_dev_attr_ch2_value.dev_attr.attr,
652
 
        &iio_dev_attr_name.dev_attr.attr,
653
634
        NULL,
654
635
};
655
636
 
661
642
 * threshold events
662
643
 */
663
644
 
664
 
#define IIO_EVENT_CODE_CH1_HIGH    IIO_BUFFER_EVENT_CODE(0)
665
 
#define IIO_EVENT_CODE_CH1_LOW     IIO_BUFFER_EVENT_CODE(1)
666
 
#define IIO_EVENT_CODE_CH2_HIGH    IIO_BUFFER_EVENT_CODE(2)
667
 
#define IIO_EVENT_CODE_CH2_LOW     IIO_BUFFER_EVENT_CODE(3)
668
 
 
669
 
#define IIO_EVENT_ATTR_CH1_HIGH_SH(_evlist, _show, _store, _mask)       \
670
 
        IIO_EVENT_ATTR_SH(ch1_high, _evlist, _show, _store, _mask)
671
 
 
672
 
#define IIO_EVENT_ATTR_CH2_HIGH_SH(_evlist, _show, _store, _mask)       \
673
 
        IIO_EVENT_ATTR_SH(ch2_high, _evlist, _show, _store, _mask)
674
 
 
675
 
#define IIO_EVENT_ATTR_CH1_LOW_SH(_evlist, _show, _store, _mask)        \
676
 
        IIO_EVENT_ATTR_SH(ch1_low, _evlist, _show, _store, _mask)
677
 
 
678
 
#define IIO_EVENT_ATTR_CH2_LOW_SH(_evlist, _show, _store, _mask)        \
679
 
        IIO_EVENT_ATTR_SH(ch2_low, _evlist, _show, _store, _mask)
680
 
 
681
 
static void ad7150_interrupt_handler_bh(struct work_struct *work_s)
 
645
static irqreturn_t ad7150_event_handler(int irq, void *private)
682
646
{
683
 
        struct ad7150_chip_info *chip =
684
 
                container_of(work_s, struct ad7150_chip_info, thresh_work);
 
647
        struct iio_dev *indio_dev = private;
 
648
        struct ad7150_chip_info *chip = iio_dev_get_devdata(indio_dev);
685
649
        u8 int_status;
686
 
 
687
 
        enable_irq(chip->client->irq);
 
650
        s64 timestamp = iio_get_time_ns();
688
651
 
689
652
        ad7150_i2c_read(chip, AD7150_STATUS, &int_status, 1);
690
653
 
691
654
        if ((int_status & AD7150_STATUS_OUT1) && !(chip->old_state & AD7150_STATUS_OUT1))
692
 
                iio_push_event(chip->indio_dev, 0,
693
 
                                IIO_EVENT_CODE_CH1_HIGH,
694
 
                                chip->last_timestamp);
 
655
                iio_push_event(indio_dev, 0,
 
656
                               IIO_UNMOD_EVENT_CODE(IIO_EV_CLASS_IN,
 
657
                                                    0,
 
658
                                                    IIO_EV_TYPE_THRESH,
 
659
                                                    IIO_EV_DIR_RISING),
 
660
                                timestamp);
695
661
        else if ((!(int_status & AD7150_STATUS_OUT1)) && (chip->old_state & AD7150_STATUS_OUT1))
696
 
                iio_push_event(chip->indio_dev, 0,
697
 
                                IIO_EVENT_CODE_CH1_LOW,
698
 
                                chip->last_timestamp);
 
662
                iio_push_event(indio_dev, 0,
 
663
                               IIO_UNMOD_EVENT_CODE(IIO_EV_CLASS_IN,
 
664
                                                    0,
 
665
                                                    IIO_EV_TYPE_THRESH,
 
666
                                                    IIO_EV_DIR_FALLING),
 
667
                               timestamp);
699
668
 
700
669
        if ((int_status & AD7150_STATUS_OUT2) && !(chip->old_state & AD7150_STATUS_OUT2))
701
 
                iio_push_event(chip->indio_dev, 0,
702
 
                                IIO_EVENT_CODE_CH2_HIGH,
703
 
                                chip->last_timestamp);
 
670
                iio_push_event(indio_dev, 0,
 
671
                               IIO_UNMOD_EVENT_CODE(IIO_EV_CLASS_IN,
 
672
                                                    1,
 
673
                                                    IIO_EV_TYPE_THRESH,
 
674
                                                    IIO_EV_DIR_RISING),
 
675
                               timestamp);
704
676
        else if ((!(int_status & AD7150_STATUS_OUT2)) && (chip->old_state & AD7150_STATUS_OUT2))
705
 
                iio_push_event(chip->indio_dev, 0,
706
 
                                IIO_EVENT_CODE_CH2_LOW,
707
 
                                chip->last_timestamp);
708
 
}
709
 
 
710
 
static int ad7150_interrupt_handler_th(struct iio_dev *dev_info,
711
 
                int index,
712
 
                s64 timestamp,
713
 
                int no_test)
714
 
{
715
 
        struct ad7150_chip_info *chip = dev_info->dev_data;
716
 
 
717
 
        chip->last_timestamp = timestamp;
718
 
        schedule_work(&chip->thresh_work);
719
 
 
720
 
        return 0;
721
 
}
722
 
 
723
 
IIO_EVENT_SH(threshold, &ad7150_interrupt_handler_th);
724
 
 
725
 
static ssize_t ad7150_query_out_mode(struct device *dev,
726
 
                struct device_attribute *attr,
727
 
                char *buf)
728
 
{
729
 
        /*
730
 
         * AD7150 provides two logic output channels, which can be used as interrupt
731
 
         * but the pins are not configurable
732
 
         */
733
 
        return sprintf(buf, "1\n");
734
 
}
735
 
 
736
 
static ssize_t ad7150_set_out_mode(struct device *dev,
737
 
                struct device_attribute *attr,
738
 
                const char *buf,
739
 
                size_t len)
740
 
{
741
 
        return len;
742
 
}
743
 
 
744
 
IIO_EVENT_ATTR_CH1_HIGH_SH(iio_event_threshold, ad7150_query_out_mode, ad7150_set_out_mode, 0);
745
 
IIO_EVENT_ATTR_CH2_HIGH_SH(iio_event_threshold, ad7150_query_out_mode, ad7150_set_out_mode, 0);
746
 
IIO_EVENT_ATTR_CH1_LOW_SH(iio_event_threshold, ad7150_query_out_mode, ad7150_set_out_mode, 0);
747
 
IIO_EVENT_ATTR_CH2_LOW_SH(iio_event_threshold, ad7150_query_out_mode, ad7150_set_out_mode, 0);
 
677
                iio_push_event(indio_dev, 0,
 
678
                               IIO_UNMOD_EVENT_CODE(IIO_EV_CLASS_IN,
 
679
                                                    1,
 
680
                                                    IIO_EV_TYPE_THRESH,
 
681
                                                    IIO_EV_DIR_FALLING),
 
682
                               timestamp);
 
683
        return IRQ_HANDLED;
 
684
}
 
685
 
 
686
static IIO_CONST_ATTR(ch1_high_en, "1");
 
687
static IIO_CONST_ATTR(ch2_high_en, "1");
 
688
static IIO_CONST_ATTR(ch1_low_en, "1");
 
689
static IIO_CONST_ATTR(ch2_low_en, "1");
748
690
 
749
691
static struct attribute *ad7150_event_attributes[] = {
750
 
        &iio_event_attr_ch1_high.dev_attr.attr,
751
 
        &iio_event_attr_ch2_high.dev_attr.attr,
752
 
        &iio_event_attr_ch1_low.dev_attr.attr,
753
 
        &iio_event_attr_ch2_low.dev_attr.attr,
 
692
        &iio_const_attr_ch1_high_en.dev_attr.attr,
 
693
        &iio_const_attr_ch2_high_en.dev_attr.attr,
 
694
        &iio_const_attr_ch1_low_en.dev_attr.attr,
 
695
        &iio_const_attr_ch2_low_en.dev_attr.attr,
754
696
        NULL,
755
697
};
756
698
 
758
700
        .attrs = ad7150_event_attributes,
759
701
};
760
702
 
 
703
static const struct iio_info ad7150_info = {
 
704
        .attrs = &ad7150_attribute_group,
 
705
        .num_interrupt_lines = 1,
 
706
        .event_attrs = &ad7150_event_attribute_group,
 
707
        .driver_module = THIS_MODULE,
 
708
};
761
709
/*
762
710
 * device probe and remove
763
711
 */
776
724
        i2c_set_clientdata(client, chip);
777
725
 
778
726
        chip->client = client;
779
 
        chip->name = id->name;
780
727
 
781
 
        chip->indio_dev = iio_allocate_device();
 
728
        chip->indio_dev = iio_allocate_device(0);
782
729
        if (chip->indio_dev == NULL) {
783
730
                ret = -ENOMEM;
784
731
                goto error_free_chip;
785
732
        }
786
733
 
787
 
        /* Echipabilish that the iio_dev is a child of the i2c device */
 
734
        /* Establish that the iio_dev is a child of the i2c device */
 
735
        chip->indio_dev->name = id->name;
788
736
        chip->indio_dev->dev.parent = &client->dev;
789
 
        chip->indio_dev->attrs = &ad7150_attribute_group;
790
 
        chip->indio_dev->event_attrs = &ad7150_event_attribute_group;
 
737
 
 
738
        chip->indio_dev->info = &ad7150_info;
791
739
        chip->indio_dev->dev_data = (void *)(chip);
792
 
        chip->indio_dev->driver_module = THIS_MODULE;
793
 
        chip->indio_dev->num_interrupt_lines = 1;
 
740
 
794
741
        chip->indio_dev->modes = INDIO_DIRECT_MODE;
795
742
 
796
743
        ret = iio_device_register(chip->indio_dev);
798
745
                goto error_free_dev;
799
746
        regdone = 1;
800
747
 
801
 
        if (client->irq && gpio_is_valid(irq_to_gpio(client->irq)) > 0) {
802
 
                ret = iio_register_interrupt_line(client->irq,
803
 
                                chip->indio_dev,
804
 
                                0,
805
 
                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
806
 
                                "ad7150");
 
748
        if (client->irq) {
 
749
                ret = request_threaded_irq(client->irq,
 
750
                                           NULL,
 
751
                                           &ad7150_event_handler,
 
752
                                           IRQF_TRIGGER_RISING |
 
753
                                           IRQF_TRIGGER_FALLING,
 
754
                                           "ad7150",
 
755
                                           chip->indio_dev);
807
756
                if (ret)
808
757
                        goto error_free_dev;
809
 
 
810
 
                iio_add_event_to_list(iio_event_attr_ch2_low.listel,
811
 
                                &chip->indio_dev->interrupts[0]->ev_list);
812
 
 
813
 
                INIT_WORK(&chip->thresh_work, ad7150_interrupt_handler_bh);
814
758
        }
815
759
 
816
760
        dev_err(&client->dev, "%s capacitive sensor registered, irq: %d\n", id->name, client->irq);
833
777
        struct ad7150_chip_info *chip = i2c_get_clientdata(client);
834
778
        struct iio_dev *indio_dev = chip->indio_dev;
835
779
 
836
 
        if (client->irq && gpio_is_valid(irq_to_gpio(client->irq)) > 0)
837
 
                iio_unregister_interrupt_line(indio_dev, 0);
 
780
        if (client->irq)
 
781
                free_irq(client->irq, indio_dev);
838
782
        iio_device_unregister(indio_dev);
839
783
        kfree(chip);
840
784