← 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/adt7310.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/adt7310.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
13
#include <linux/sysfs.h>
16
14
#include <linux/list.h>
17
15
#include <linux/spi/spi.h>
18
 
#include <linux/rtc.h>
19
16
 
20
17
#include "../iio.h"
21
18
#include "../sysfs.h"
82
79
 */
83
80
 
84
81
struct adt7310_chip_info {
85
 
        const char *name;
86
82
        struct spi_device *spi_dev;
87
83
        struct iio_dev *indio_dev;
88
 
        struct work_struct thresh_work;
89
 
        s64 last_timestamp;
90
84
        u8  config;
91
85
};
92
86
 
380
374
 
381
375
static IIO_DEVICE_ATTR(value, S_IRUGO, adt7310_show_value, NULL, 0);
382
376
 
383
 
static ssize_t adt7310_show_name(struct device *dev,
384
 
                struct device_attribute *attr,
385
 
                char *buf)
386
 
{
387
 
        struct iio_dev *dev_info = dev_get_drvdata(dev);
388
 
        struct adt7310_chip_info *chip = dev_info->dev_data;
389
 
        return sprintf(buf, "%s\n", chip->name);
390
 
}
391
 
 
392
 
static IIO_DEVICE_ATTR(name, S_IRUGO, adt7310_show_name, NULL, 0);
393
 
 
394
377
static struct attribute *adt7310_attributes[] = {
395
378
        &iio_dev_attr_available_modes.dev_attr.attr,
396
379
        &iio_dev_attr_mode.dev_attr.attr,
397
380
        &iio_dev_attr_resolution.dev_attr.attr,
398
381
        &iio_dev_attr_id.dev_attr.attr,
399
382
        &iio_dev_attr_value.dev_attr.attr,
400
 
        &iio_dev_attr_name.dev_attr.attr,
401
383
        NULL,
402
384
};
403
385
 
405
387
        .attrs = adt7310_attributes,
406
388
};
407
389
 
408
 
/*
409
 
 * temperature bound events
410
 
 */
411
 
 
412
 
#define IIO_EVENT_CODE_ADT7310_ABOVE_ALARM    IIO_BUFFER_EVENT_CODE(0)
413
 
#define IIO_EVENT_CODE_ADT7310_BELLOW_ALARM   IIO_BUFFER_EVENT_CODE(1)
414
 
#define IIO_EVENT_CODE_ADT7310_ABOVE_CRIT     IIO_BUFFER_EVENT_CODE(2)
415
 
 
416
 
static void adt7310_interrupt_bh(struct work_struct *work_s)
 
390
static irqreturn_t adt7310_event_handler(int irq, void *private)
417
391
{
418
 
        struct adt7310_chip_info *chip =
419
 
                container_of(work_s, struct adt7310_chip_info, thresh_work);
 
392
        struct iio_dev *indio_dev = private;
 
393
        struct adt7310_chip_info *chip = iio_dev_get_devdata(indio_dev);
 
394
        s64 timestamp = iio_get_time_ns();
420
395
        u8 status;
 
396
        int ret;
421
397
 
422
 
        if (adt7310_spi_read_byte(chip, ADT7310_STATUS, &status))
423
 
                return;
 
398
        ret = adt7310_spi_read_byte(chip, ADT7310_STATUS, &status);
 
399
        if (ret)
 
400
                return ret;
424
401
 
425
402
        if (status & ADT7310_STAT_T_HIGH)
426
 
                iio_push_event(chip->indio_dev, 0,
427
 
                        IIO_EVENT_CODE_ADT7310_ABOVE_ALARM,
428
 
                        chip->last_timestamp);
 
403
                iio_push_event(indio_dev, 0,
 
404
                               IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 
405
                                                    IIO_EV_TYPE_THRESH,
 
406
                                                    IIO_EV_DIR_RISING),
 
407
                               timestamp);
429
408
        if (status & ADT7310_STAT_T_LOW)
430
 
                iio_push_event(chip->indio_dev, 0,
431
 
                        IIO_EVENT_CODE_ADT7310_BELLOW_ALARM,
432
 
                        chip->last_timestamp);
 
409
                iio_push_event(indio_dev, 0,
 
410
                               IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 
411
                                                    IIO_EV_TYPE_THRESH,
 
412
                                                    IIO_EV_DIR_FALLING),
 
413
                               timestamp);
433
414
        if (status & ADT7310_STAT_T_CRIT)
434
 
                iio_push_event(chip->indio_dev, 0,
435
 
                        IIO_EVENT_CODE_ADT7310_ABOVE_CRIT,
436
 
                        chip->last_timestamp);
437
 
}
438
 
 
439
 
static int adt7310_interrupt(struct iio_dev *dev_info,
440
 
                int index,
441
 
                s64 timestamp,
442
 
                int no_test)
443
 
{
444
 
        struct adt7310_chip_info *chip = dev_info->dev_data;
445
 
 
446
 
        chip->last_timestamp = timestamp;
447
 
        schedule_work(&chip->thresh_work);
448
 
 
449
 
        return 0;
450
 
}
451
 
 
452
 
IIO_EVENT_SH(adt7310, &adt7310_interrupt);
453
 
IIO_EVENT_SH(adt7310_ct, &adt7310_interrupt);
 
415
                iio_push_event(indio_dev, 0,
 
416
                               IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 
417
                                                    IIO_EV_TYPE_THRESH,
 
418
                                                    IIO_EV_DIR_RISING),
 
419
                        timestamp);
 
420
        return IRQ_HANDLED;
 
421
}
454
422
 
455
423
static ssize_t adt7310_show_event_mode(struct device *dev,
456
424
                struct device_attribute *attr,
729
697
        return len;
730
698
}
731
699
 
732
 
IIO_EVENT_ATTR_SH(event_mode, iio_event_adt7310,
733
 
                adt7310_show_event_mode, adt7310_set_event_mode, 0);
734
 
IIO_EVENT_ATTR_SH(available_event_modes, iio_event_adt7310,
735
 
                adt7310_show_available_event_modes, NULL, 0);
736
 
IIO_EVENT_ATTR_SH(fault_queue, iio_event_adt7310,
737
 
                adt7310_show_fault_queue, adt7310_set_fault_queue, 0);
738
 
IIO_EVENT_ATTR_SH(t_alarm_high, iio_event_adt7310,
739
 
                adt7310_show_t_alarm_high, adt7310_set_t_alarm_high, 0);
740
 
IIO_EVENT_ATTR_SH(t_alarm_low, iio_event_adt7310,
741
 
                adt7310_show_t_alarm_low, adt7310_set_t_alarm_low, 0);
742
 
IIO_EVENT_ATTR_SH(t_crit, iio_event_adt7310_ct,
743
 
                adt7310_show_t_crit, adt7310_set_t_crit, 0);
744
 
IIO_EVENT_ATTR_SH(t_hyst, iio_event_adt7310,
745
 
                adt7310_show_t_hyst, adt7310_set_t_hyst, 0);
 
700
static IIO_DEVICE_ATTR(event_mode,
 
701
                       S_IRUGO | S_IWUSR,
 
702
                       adt7310_show_event_mode, adt7310_set_event_mode, 0);
 
703
static IIO_DEVICE_ATTR(available_event_modes,
 
704
                       S_IRUGO | S_IWUSR,
 
705
                       adt7310_show_available_event_modes, NULL, 0);
 
706
static IIO_DEVICE_ATTR(fault_queue,
 
707
                       S_IRUGO | S_IWUSR,
 
708
                       adt7310_show_fault_queue, adt7310_set_fault_queue, 0);
 
709
static IIO_DEVICE_ATTR(t_alarm_high,
 
710
                       S_IRUGO | S_IWUSR,
 
711
                       adt7310_show_t_alarm_high, adt7310_set_t_alarm_high, 0);
 
712
static IIO_DEVICE_ATTR(t_alarm_low,
 
713
                       S_IRUGO | S_IWUSR,
 
714
                       adt7310_show_t_alarm_low, adt7310_set_t_alarm_low, 0);
 
715
static IIO_DEVICE_ATTR(t_crit,
 
716
                       S_IRUGO | S_IWUSR,
 
717
                       adt7310_show_t_crit, adt7310_set_t_crit, 0);
 
718
static IIO_DEVICE_ATTR(t_hyst,
 
719
                       S_IRUGO | S_IWUSR,
 
720
                       adt7310_show_t_hyst, adt7310_set_t_hyst, 0);
746
721
 
747
722
static struct attribute *adt7310_event_int_attributes[] = {
748
 
        &iio_event_attr_event_mode.dev_attr.attr,
749
 
        &iio_event_attr_available_event_modes.dev_attr.attr,
750
 
        &iio_event_attr_fault_queue.dev_attr.attr,
751
 
        &iio_event_attr_t_alarm_high.dev_attr.attr,
752
 
        &iio_event_attr_t_alarm_low.dev_attr.attr,
753
 
        &iio_event_attr_t_hyst.dev_attr.attr,
 
723
        &iio_dev_attr_event_mode.dev_attr.attr,
 
724
        &iio_dev_attr_available_event_modes.dev_attr.attr,
 
725
        &iio_dev_attr_fault_queue.dev_attr.attr,
 
726
        &iio_dev_attr_t_alarm_high.dev_attr.attr,
 
727
        &iio_dev_attr_t_alarm_low.dev_attr.attr,
 
728
        &iio_dev_attr_t_hyst.dev_attr.attr,
754
729
        NULL,
755
730
};
756
731
 
757
732
static struct attribute *adt7310_event_ct_attributes[] = {
758
 
        &iio_event_attr_event_mode.dev_attr.attr,
759
 
        &iio_event_attr_available_event_modes.dev_attr.attr,
760
 
        &iio_event_attr_fault_queue.dev_attr.attr,
761
 
        &iio_event_attr_t_crit.dev_attr.attr,
762
 
        &iio_event_attr_t_hyst.dev_attr.attr,
 
733
        &iio_dev_attr_event_mode.dev_attr.attr,
 
734
        &iio_dev_attr_available_event_modes.dev_attr.attr,
 
735
        &iio_dev_attr_fault_queue.dev_attr.attr,
 
736
        &iio_dev_attr_t_crit.dev_attr.attr,
 
737
        &iio_dev_attr_t_hyst.dev_attr.attr,
763
738
        NULL,
764
739
};
765
740
 
766
741
static struct attribute_group adt7310_event_attribute_group[ADT7310_IRQS] = {
767
742
        {
768
743
                .attrs = adt7310_event_int_attributes,
769
 
        },
770
 
        {
 
744
        }, {
771
745
                .attrs = adt7310_event_ct_attributes,
772
746
        }
773
747
};
774
748
 
 
749
static const struct iio_info adt7310_info = {
 
750
        .attrs = &adt7310_attribute_group,
 
751
        .num_interrupt_lines = ADT7310_IRQS,
 
752
        .event_attrs = adt7310_event_attribute_group,
 
753
        .driver_module = THIS_MODULE,
 
754
};
 
755
 
775
756
/*
776
757
 * device probe and remove
777
758
 */
792
773
        dev_set_drvdata(&spi_dev->dev, chip);
793
774
 
794
775
        chip->spi_dev = spi_dev;
795
 
        chip->name = spi_dev->modalias;
796
776
 
797
 
        chip->indio_dev = iio_allocate_device();
 
777
        chip->indio_dev = iio_allocate_device(0);
798
778
        if (chip->indio_dev == NULL) {
799
779
                ret = -ENOMEM;
800
780
                goto error_free_chip;
801
781
        }
802
782
 
803
783
        chip->indio_dev->dev.parent = &spi_dev->dev;
804
 
        chip->indio_dev->attrs = &adt7310_attribute_group;
805
 
        chip->indio_dev->event_attrs = adt7310_event_attribute_group;
 
784
        chip->indio_dev->name = spi_get_device_id(spi_dev)->name;
 
785
        chip->indio_dev->info = &adt7310_info;
806
786
        chip->indio_dev->dev_data = (void *)chip;
807
 
        chip->indio_dev->driver_module = THIS_MODULE;
808
 
        chip->indio_dev->num_interrupt_lines = ADT7310_IRQS;
809
787
        chip->indio_dev->modes = INDIO_DIRECT_MODE;
810
788
 
811
789
        ret = iio_device_register(chip->indio_dev);
818
796
                        irq_flags = adt7310_platform_data[2];
819
797
                else
820
798
                        irq_flags = IRQF_TRIGGER_LOW;
821
 
                ret = iio_register_interrupt_line(spi_dev->irq,
822
 
                                chip->indio_dev,
823
 
                                0,
824
 
                                irq_flags,
825
 
                                chip->name);
 
799
                ret = request_threaded_irq(spi_dev->irq,
 
800
                                           NULL,
 
801
                                           &adt7310_event_handler,
 
802
                                           irq_flags,
 
803
                                           chip->indio_dev->name,
 
804
                                           chip->indio_dev);
826
805
                if (ret)
827
806
                        goto error_unreg_dev;
828
 
 
829
 
                /*
830
 
                 * The event handler list element refer to iio_event_adt7310.
831
 
                 * All event attributes bind to the same event handler.
832
 
                 * One event handler can only be added to one event list.
833
 
                 */
834
 
                iio_add_event_to_list(&iio_event_adt7310,
835
 
                                &chip->indio_dev->interrupts[0]->ev_list);
836
807
        }
837
808
 
838
809
        /* INT bound temperature alarm event. line 1 */
839
810
        if (adt7310_platform_data[0]) {
840
 
                ret = iio_register_interrupt_line(adt7310_platform_data[0],
841
 
                                chip->indio_dev,
842
 
                                1,
843
 
                                adt7310_platform_data[1],
844
 
                                chip->name);
 
811
                ret = request_threaded_irq(adt7310_platform_data[0],
 
812
                                           NULL,
 
813
                                           &adt7310_event_handler,
 
814
                                           adt7310_platform_data[1],
 
815
                                           chip->indio_dev->name,
 
816
                                           chip->indio_dev);
845
817
                if (ret)
846
818
                        goto error_unreg_ct_irq;
847
 
 
848
 
                /*
849
 
                 * The event handler list element refer to iio_event_adt7310.
850
 
                 * All event attributes bind to the same event handler.
851
 
                 * One event handler can only be added to one event list.
852
 
                 */
853
 
                iio_add_event_to_list(&iio_event_adt7310_ct,
854
 
                                &chip->indio_dev->interrupts[1]->ev_list);
855
819
        }
856
820
 
857
821
        if (spi_dev->irq && adt7310_platform_data[0]) {
858
 
                INIT_WORK(&chip->thresh_work, adt7310_interrupt_bh);
859
 
 
860
822
                ret = adt7310_spi_read_byte(chip, ADT7310_CONFIG, &chip->config);
861
823
                if (ret) {
862
824
                        ret = -EIO;
879
841
        }
880
842
 
881
843
        dev_info(&spi_dev->dev, "%s temperature sensor registered.\n",
882
 
                        chip->name);
 
844
                        chip->indio_dev->name);
883
845
 
884
846
        return 0;
885
847
 
886
848
error_unreg_int_irq:
887
 
        iio_unregister_interrupt_line(chip->indio_dev, 1);
 
849
        free_irq(adt7310_platform_data[0], chip->indio_dev);
888
850
error_unreg_ct_irq:
889
 
        iio_unregister_interrupt_line(chip->indio_dev, 0);
 
851
        free_irq(spi_dev->irq, chip->indio_dev);
890
852
error_unreg_dev:
891
853
        iio_device_unregister(chip->indio_dev);
892
854
error_free_dev:
905
867
 
906
868
        dev_set_drvdata(&spi_dev->dev, NULL);
907
869
        if (adt7310_platform_data[0])
908
 
                iio_unregister_interrupt_line(indio_dev, 1);
 
870
                free_irq(adt7310_platform_data[0], chip->indio_dev);
909
871
        if (spi_dev->irq)
910
 
                iio_unregister_interrupt_line(indio_dev, 0);
 
872
                free_irq(spi_dev->irq, chip->indio_dev);
911
873
        iio_device_unregister(indio_dev);
912
874
        iio_free_device(chip->indio_dev);
913
875
        kfree(chip);