← 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/addac/adt7316.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/addac/adt7316.c
174
174
 */
175
175
 
176
176
struct adt7316_chip_info {
177
 
        const char              *name;
178
177
        struct iio_dev          *indio_dev;
179
 
        struct work_struct      thresh_work;
180
 
        s64                     last_timestamp;
181
178
        struct adt7316_bus      bus;
182
179
        u16                     ldac_pin;
183
180
        u16                     int_mask;       /* 0x2f */
403
400
                return sprintf(buf, "5 - AIN4\n");
404
401
        default:
405
402
                return sprintf(buf, "N/A\n");
406
 
        };
 
403
        }
407
404
}
408
405
 
409
406
static ssize_t adt7316_store_ad_channel(struct device *dev,
465
462
 
466
463
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
467
464
                return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
468
 
                                "2 - External Temperature or AIN2\n"
 
465
                                "2 - External Temperature or AIN1\n"
469
466
                                "3 - AIN2\n4 - AIN3\n5 - AIN4\n");
470
467
        else
471
468
                return sprintf(buf, "0 - VDD\n1 - Internal Temperature\n"
893
890
                        return sprintf(buf, "2 - auto at MSB DAC ABCD writing\n");
894
891
                default: /* ADT7316_DA_EN_MODE_LDAC */
895
892
                        return sprintf(buf, "3 - manual\n");
896
 
                };
 
893
                }
897
894
        }
898
895
}
899
896
 
1205
1202
                        return sprintf(buf, "%d\n", data);
1206
1203
                else
1207
1204
                        break;
1208
 
        };
 
1205
        }
1209
1206
 
1210
1207
        if (data & ADT7316_T_VALUE_SIGN) {
1211
1208
                /* convert supplement to positive value */
1674
1671
 
1675
1672
static IIO_DEVICE_ATTR(bus_type, S_IRUGO, adt7316_show_bus_type, NULL, 0);
1676
1673
 
1677
 
static ssize_t adt7316_show_name(struct device *dev,
1678
 
                struct device_attribute *attr,
1679
 
                char *buf)
1680
 
{
1681
 
        struct iio_dev *dev_info = dev_get_drvdata(dev);
1682
 
        struct adt7316_chip_info *chip = dev_info->dev_data;
1683
 
 
1684
 
        return sprintf(buf, "%s\n", chip->name);
1685
 
}
1686
 
 
1687
 
static IIO_DEVICE_ATTR(name, S_IRUGO, adt7316_show_name, NULL, 0);
1688
 
 
1689
1674
static struct attribute *adt7316_attributes[] = {
1690
1675
        &iio_dev_attr_all_modes.dev_attr.attr,
1691
1676
        &iio_dev_attr_mode.dev_attr.attr,
1722
1707
        &iio_dev_attr_manufactorer_id.dev_attr.attr,
1723
1708
        &iio_dev_attr_device_rev.dev_attr.attr,
1724
1709
        &iio_dev_attr_bus_type.dev_attr.attr,
1725
 
        &iio_dev_attr_name.dev_attr.attr,
1726
1710
        NULL,
1727
1711
};
1728
1712
 
1771
1755
        &iio_dev_attr_manufactorer_id.dev_attr.attr,
1772
1756
        &iio_dev_attr_device_rev.dev_attr.attr,
1773
1757
        &iio_dev_attr_bus_type.dev_attr.attr,
1774
 
        &iio_dev_attr_name.dev_attr.attr,
1775
1758
        NULL,
1776
1759
};
1777
1760
 
1779
1762
        .attrs = adt7516_attributes,
1780
1763
};
1781
1764
 
1782
 
 
1783
 
/*
1784
 
 * temperature bound events
1785
 
 */
1786
 
 
1787
 
#define IIO_EVENT_CODE_ADT7316_IN_TEMP_HIGH   IIO_BUFFER_EVENT_CODE(0)
1788
 
#define IIO_EVENT_CODE_ADT7316_IN_TEMP_LOW    IIO_BUFFER_EVENT_CODE(1)
1789
 
#define IIO_EVENT_CODE_ADT7316_EX_TEMP_HIGH   IIO_BUFFER_EVENT_CODE(2)
1790
 
#define IIO_EVENT_CODE_ADT7316_EX_TEMP_LOW    IIO_BUFFER_EVENT_CODE(3)
1791
 
#define IIO_EVENT_CODE_ADT7316_EX_TEMP_FAULT  IIO_BUFFER_EVENT_CODE(4)
1792
 
#define IIO_EVENT_CODE_ADT7516_AIN1           IIO_BUFFER_EVENT_CODE(5)
1793
 
#define IIO_EVENT_CODE_ADT7516_AIN2           IIO_BUFFER_EVENT_CODE(6)
1794
 
#define IIO_EVENT_CODE_ADT7516_AIN3           IIO_BUFFER_EVENT_CODE(7)
1795
 
#define IIO_EVENT_CODE_ADT7516_AIN4           IIO_BUFFER_EVENT_CODE(8)
1796
 
#define IIO_EVENT_CODE_ADT7316_VDD            IIO_BUFFER_EVENT_CODE(9)
1797
 
 
1798
 
static void adt7316_interrupt_bh(struct work_struct *work_s)
 
1765
static irqreturn_t adt7316_event_handler(int irq, void *private)
1799
1766
{
1800
 
        struct adt7316_chip_info *chip =
1801
 
                container_of(work_s, struct adt7316_chip_info, thresh_work);
 
1767
        struct iio_dev *indio_dev = private;
 
1768
        struct adt7316_chip_info *chip = iio_dev_get_devdata(indio_dev);
1802
1769
        u8 stat1, stat2;
1803
 
        int i, ret, count;
 
1770
        int ret;
 
1771
        s64 time;
1804
1772
 
1805
1773
        ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT1, &stat1);
1806
1774
        if (!ret) {
1807
 
                if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
1808
 
                        count = 8;
1809
 
                else
1810
 
                        count = 5;
 
1775
                if ((chip->id & ID_FAMILY_MASK) != ID_ADT75XX)
 
1776
                        stat1 &= 0x1F;
1811
1777
 
1812
 
                for (i = 0; i < count; i++) {
1813
 
                        if (stat1 & (1 << i))
1814
 
                                iio_push_event(chip->indio_dev, 0,
1815
 
                                        IIO_EVENT_CODE_ADT7316_IN_TEMP_HIGH + i,
1816
 
                                        chip->last_timestamp);
 
1778
                time = iio_get_time_ns();
 
1779
                if (stat1 & (1 << 0))
 
1780
                        iio_push_event(chip->indio_dev, 0,
 
1781
                                       IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 
1782
                                                            IIO_EV_TYPE_THRESH,
 
1783
                                                            IIO_EV_DIR_RISING),
 
1784
                                       time);
 
1785
                if (stat1 & (1 << 1))
 
1786
                        iio_push_event(chip->indio_dev, 0,
 
1787
                                       IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
 
1788
                                                            IIO_EV_TYPE_THRESH,
 
1789
                                                            IIO_EV_DIR_FALLING),
 
1790
                                       time);
 
1791
                if (stat1 & (1 << 2))
 
1792
                        iio_push_event(chip->indio_dev, 0,
 
1793
                                       IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
 
1794
                                                            IIO_EV_TYPE_THRESH,
 
1795
                                                            IIO_EV_DIR_RISING),
 
1796
                                       time);
 
1797
                if (stat1 & (1 << 3))
 
1798
                        iio_push_event(chip->indio_dev, 0,
 
1799
                                       IIO_UNMOD_EVENT_CODE(IIO_TEMP, 1,
 
1800
                                                            IIO_EV_TYPE_THRESH,
 
1801
                                                            IIO_EV_DIR_FALLING),
 
1802
                                       time);
 
1803
                if (stat1 & (1 << 5))
 
1804
                        iio_push_event(chip->indio_dev, 0,
 
1805
                                       IIO_UNMOD_EVENT_CODE(IIO_IN, 1,
 
1806
                                                            IIO_EV_TYPE_THRESH,
 
1807
                                                            IIO_EV_DIR_EITHER),
 
1808
                                       time);
 
1809
                if (stat1 & (1 << 6))
 
1810
                        iio_push_event(chip->indio_dev, 0,
 
1811
                                       IIO_UNMOD_EVENT_CODE(IIO_IN, 2,
 
1812
                                                            IIO_EV_TYPE_THRESH,
 
1813
                                                            IIO_EV_DIR_EITHER),
 
1814
                                       time);
 
1815
                if (stat1 & (1 << 7))
 
1816
                        iio_push_event(chip->indio_dev, 0,
 
1817
                                       IIO_UNMOD_EVENT_CODE(IIO_IN, 3,
 
1818
                                                            IIO_EV_TYPE_THRESH,
 
1819
                                                            IIO_EV_DIR_EITHER),
 
1820
                                       time);
1817
1821
                }
1818
 
        }
1819
 
 
1820
1822
        ret = chip->bus.read(chip->bus.client, ADT7316_INT_STAT2, &stat2);
1821
1823
        if (!ret) {
1822
1824
                if (stat2 & ADT7316_INT_MASK2_VDD)
1823
1825
                        iio_push_event(chip->indio_dev, 0,
1824
 
                                IIO_EVENT_CODE_ADT7316_VDD,
1825
 
                                chip->last_timestamp);
 
1826
                                       IIO_UNMOD_EVENT_CODE(IIO_IN,
 
1827
                                                            0,
 
1828
                                                            IIO_EV_TYPE_THRESH,
 
1829
                                                            IIO_EV_DIR_RISING),
 
1830
                                       iio_get_time_ns());
1826
1831
        }
1827
1832
 
1828
 
        enable_irq(chip->bus.irq);
1829
 
}
1830
 
 
1831
 
static int adt7316_interrupt(struct iio_dev *dev_info,
1832
 
                int index,
1833
 
                s64 timestamp,
1834
 
                int no_test)
1835
 
{
1836
 
        struct adt7316_chip_info *chip = dev_info->dev_data;
1837
 
 
1838
 
        chip->last_timestamp = timestamp;
1839
 
        schedule_work(&chip->thresh_work);
1840
 
 
1841
 
        return 0;
1842
 
}
1843
 
 
1844
 
IIO_EVENT_SH(adt7316, &adt7316_interrupt);
 
1833
        return IRQ_HANDLED;
 
1834
}
1845
1835
 
1846
1836
/*
1847
1837
 * Show mask of enabled interrupts in Hex.
1901
1891
}
1902
1892
static inline ssize_t adt7316_show_ad_bound(struct device *dev,
1903
1893
                struct device_attribute *attr,
1904
 
                u8 bound_reg,
1905
1894
                char *buf)
1906
1895
{
 
1896
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1907
1897
        struct iio_dev *dev_info = dev_get_drvdata(dev);
1908
1898
        struct adt7316_chip_info *chip = dev_info->dev_data;
1909
1899
        u8 val;
1911
1901
        int ret;
1912
1902
 
1913
1903
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1914
 
                bound_reg > ADT7316_EX_TEMP_LOW)
 
1904
                this_attr->address > ADT7316_EX_TEMP_LOW)
1915
1905
                return -EPERM;
1916
1906
 
1917
 
        ret = chip->bus.read(chip->bus.client, bound_reg, &val);
 
1907
        ret = chip->bus.read(chip->bus.client, this_attr->address, &val);
1918
1908
        if (ret)
1919
1909
                return -EIO;
1920
1910
 
1931
1921
 
1932
1922
static inline ssize_t adt7316_set_ad_bound(struct device *dev,
1933
1923
                struct device_attribute *attr,
1934
 
                u8 bound_reg,
1935
1924
                const char *buf,
1936
1925
                size_t len)
1937
1926
{
 
1927
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
1938
1928
        struct iio_dev *dev_info = dev_get_drvdata(dev);
1939
1929
        struct adt7316_chip_info *chip = dev_info->dev_data;
1940
1930
        long data;
1942
1932
        int ret;
1943
1933
 
1944
1934
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT73XX &&
1945
 
                bound_reg > ADT7316_EX_TEMP_LOW)
 
1935
                this_attr->address > ADT7316_EX_TEMP_LOW)
1946
1936
                return -EPERM;
1947
1937
 
1948
1938
        ret = strict_strtol(buf, 10, &data);
1963
1953
 
1964
1954
        val = (u8)data;
1965
1955
 
1966
 
        ret = chip->bus.write(chip->bus.client, bound_reg, val);
 
1956
        ret = chip->bus.write(chip->bus.client, this_attr->address, val);
1967
1957
        if (ret)
1968
1958
                return -EIO;
1969
1959
 
1970
1960
        return len;
1971
1961
}
1972
1962
 
1973
 
static ssize_t adt7316_show_in_temp_high(struct device *dev,
1974
 
                struct device_attribute *attr,
1975
 
                char *buf)
1976
 
{
1977
 
        return adt7316_show_ad_bound(dev, attr,
1978
 
                        ADT7316_IN_TEMP_HIGH, buf);
1979
 
}
1980
 
 
1981
 
static inline ssize_t adt7316_set_in_temp_high(struct device *dev,
1982
 
                struct device_attribute *attr,
1983
 
                const char *buf,
1984
 
                size_t len)
1985
 
{
1986
 
        return adt7316_set_ad_bound(dev, attr,
1987
 
                        ADT7316_IN_TEMP_HIGH, buf, len);
1988
 
}
1989
 
 
1990
 
static ssize_t adt7316_show_in_temp_low(struct device *dev,
1991
 
                struct device_attribute *attr,
1992
 
                char *buf)
1993
 
{
1994
 
        return adt7316_show_ad_bound(dev, attr,
1995
 
                        ADT7316_IN_TEMP_LOW, buf);
1996
 
}
1997
 
 
1998
 
static inline ssize_t adt7316_set_in_temp_low(struct device *dev,
1999
 
                struct device_attribute *attr,
2000
 
                const char *buf,
2001
 
                size_t len)
2002
 
{
2003
 
        return adt7316_set_ad_bound(dev, attr,
2004
 
                        ADT7316_IN_TEMP_LOW, buf, len);
2005
 
}
2006
 
 
2007
 
static ssize_t adt7316_show_ex_temp_ain1_high(struct device *dev,
2008
 
                struct device_attribute *attr,
2009
 
                char *buf)
2010
 
{
2011
 
        return adt7316_show_ad_bound(dev, attr,
2012
 
                        ADT7316_EX_TEMP_HIGH, buf);
2013
 
}
2014
 
 
2015
 
static inline ssize_t adt7316_set_ex_temp_ain1_high(struct device *dev,
2016
 
                struct device_attribute *attr,
2017
 
                const char *buf,
2018
 
                size_t len)
2019
 
{
2020
 
        return adt7316_set_ad_bound(dev, attr,
2021
 
                        ADT7316_EX_TEMP_HIGH, buf, len);
2022
 
}
2023
 
 
2024
 
static ssize_t adt7316_show_ex_temp_ain1_low(struct device *dev,
2025
 
                struct device_attribute *attr,
2026
 
                char *buf)
2027
 
{
2028
 
        return adt7316_show_ad_bound(dev, attr,
2029
 
                        ADT7316_EX_TEMP_LOW, buf);
2030
 
}
2031
 
 
2032
 
static inline ssize_t adt7316_set_ex_temp_ain1_low(struct device *dev,
2033
 
                struct device_attribute *attr,
2034
 
                const char *buf,
2035
 
                size_t len)
2036
 
{
2037
 
        return adt7316_set_ad_bound(dev, attr,
2038
 
                        ADT7316_EX_TEMP_LOW, buf, len);
2039
 
}
2040
 
 
2041
 
static ssize_t adt7316_show_ain2_high(struct device *dev,
2042
 
                struct device_attribute *attr,
2043
 
                char *buf)
2044
 
{
2045
 
        return adt7316_show_ad_bound(dev, attr,
2046
 
                        ADT7516_AIN2_HIGH, buf);
2047
 
}
2048
 
 
2049
 
static inline ssize_t adt7316_set_ain2_high(struct device *dev,
2050
 
                struct device_attribute *attr,
2051
 
                const char *buf,
2052
 
                size_t len)
2053
 
{
2054
 
        return adt7316_set_ad_bound(dev, attr,
2055
 
                        ADT7516_AIN2_HIGH, buf, len);
2056
 
}
2057
 
 
2058
 
static ssize_t adt7316_show_ain2_low(struct device *dev,
2059
 
                struct device_attribute *attr,
2060
 
                char *buf)
2061
 
{
2062
 
        return adt7316_show_ad_bound(dev, attr,
2063
 
                        ADT7516_AIN2_LOW, buf);
2064
 
}
2065
 
 
2066
 
static inline ssize_t adt7316_set_ain2_low(struct device *dev,
2067
 
                struct device_attribute *attr,
2068
 
                const char *buf,
2069
 
                size_t len)
2070
 
{
2071
 
        return adt7316_set_ad_bound(dev, attr,
2072
 
                        ADT7516_AIN2_LOW, buf, len);
2073
 
}
2074
 
 
2075
 
static ssize_t adt7316_show_ain3_high(struct device *dev,
2076
 
                struct device_attribute *attr,
2077
 
                char *buf)
2078
 
{
2079
 
        return adt7316_show_ad_bound(dev, attr,
2080
 
                        ADT7516_AIN3_HIGH, buf);
2081
 
}
2082
 
 
2083
 
static inline ssize_t adt7316_set_ain3_high(struct device *dev,
2084
 
                struct device_attribute *attr,
2085
 
                const char *buf,
2086
 
                size_t len)
2087
 
{
2088
 
        return adt7316_set_ad_bound(dev, attr,
2089
 
                        ADT7516_AIN3_HIGH, buf, len);
2090
 
}
2091
 
 
2092
 
static ssize_t adt7316_show_ain3_low(struct device *dev,
2093
 
                struct device_attribute *attr,
2094
 
                char *buf)
2095
 
{
2096
 
        return adt7316_show_ad_bound(dev, attr,
2097
 
                        ADT7516_AIN3_LOW, buf);
2098
 
}
2099
 
 
2100
 
static inline ssize_t adt7316_set_ain3_low(struct device *dev,
2101
 
                struct device_attribute *attr,
2102
 
                const char *buf,
2103
 
                size_t len)
2104
 
{
2105
 
        return adt7316_set_ad_bound(dev, attr,
2106
 
                        ADT7516_AIN3_LOW, buf, len);
2107
 
}
2108
 
 
2109
 
static ssize_t adt7316_show_ain4_high(struct device *dev,
2110
 
                struct device_attribute *attr,
2111
 
                char *buf)
2112
 
{
2113
 
        return adt7316_show_ad_bound(dev, attr,
2114
 
                        ADT7516_AIN4_HIGH, buf);
2115
 
}
2116
 
 
2117
 
static inline ssize_t adt7316_set_ain4_high(struct device *dev,
2118
 
                struct device_attribute *attr,
2119
 
                const char *buf,
2120
 
                size_t len)
2121
 
{
2122
 
        return adt7316_set_ad_bound(dev, attr,
2123
 
                        ADT7516_AIN4_HIGH, buf, len);
2124
 
}
2125
 
 
2126
 
static ssize_t adt7316_show_ain4_low(struct device *dev,
2127
 
                struct device_attribute *attr,
2128
 
                char *buf)
2129
 
{
2130
 
        return adt7316_show_ad_bound(dev, attr,
2131
 
                        ADT7516_AIN4_LOW, buf);
2132
 
}
2133
 
 
2134
 
static inline ssize_t adt7316_set_ain4_low(struct device *dev,
2135
 
                struct device_attribute *attr,
2136
 
                const char *buf,
2137
 
                size_t len)
2138
 
{
2139
 
        return adt7316_set_ad_bound(dev, attr,
2140
 
                        ADT7516_AIN4_LOW, buf, len);
2141
 
}
2142
 
 
2143
1963
static ssize_t adt7316_show_int_enabled(struct device *dev,
2144
1964
                struct device_attribute *attr,
2145
1965
                char *buf)
2173
1993
        return len;
2174
1994
}
2175
1995
 
 
1996
static IIO_DEVICE_ATTR(int_mask,
 
1997
                       S_IRUGO | S_IWUSR,
 
1998
                       adt7316_show_int_mask, adt7316_set_int_mask,
 
1999
                       0);
 
2000
static IIO_DEVICE_ATTR(in_temp_high_value,
 
2001
                       S_IRUGO | S_IWUSR,
 
2002
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2003
                       ADT7316_IN_TEMP_HIGH);
 
2004
static IIO_DEVICE_ATTR(in_temp_low_value,
 
2005
                       S_IRUGO | S_IWUSR,
 
2006
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2007
                       ADT7316_IN_TEMP_LOW);
 
2008
static IIO_DEVICE_ATTR(ex_temp_high_value,
 
2009
                       S_IRUGO | S_IWUSR,
 
2010
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2011
                       ADT7316_EX_TEMP_HIGH);
 
2012
static IIO_DEVICE_ATTR(ex_temp_low_value,
 
2013
                       S_IRUGO | S_IWUSR,
 
2014
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2015
                       ADT7316_EX_TEMP_LOW);
2176
2016
 
2177
 
IIO_EVENT_ATTR_SH(int_mask, iio_event_adt7316,
2178
 
                adt7316_show_int_mask, adt7316_set_int_mask, 0);
2179
 
IIO_EVENT_ATTR_SH(in_temp_high, iio_event_adt7316,
2180
 
                adt7316_show_in_temp_high, adt7316_set_in_temp_high, 0);
2181
 
IIO_EVENT_ATTR_SH(in_temp_low, iio_event_adt7316,
2182
 
                adt7316_show_in_temp_low, adt7316_set_in_temp_low, 0);
2183
 
IIO_EVENT_ATTR_SH(ex_temp_high, iio_event_adt7316,
2184
 
                adt7316_show_ex_temp_ain1_high,
2185
 
                adt7316_set_ex_temp_ain1_high, 0);
2186
 
IIO_EVENT_ATTR_SH(ex_temp_low, iio_event_adt7316,
2187
 
                adt7316_show_ex_temp_ain1_low,
2188
 
                adt7316_set_ex_temp_ain1_low, 0);
2189
 
IIO_EVENT_ATTR_SH(ex_temp_ain1_high, iio_event_adt7316,
2190
 
                adt7316_show_ex_temp_ain1_high,
2191
 
                adt7316_set_ex_temp_ain1_high, 0);
2192
 
IIO_EVENT_ATTR_SH(ex_temp_ain1_low, iio_event_adt7316,
2193
 
                adt7316_show_ex_temp_ain1_low,
2194
 
                adt7316_set_ex_temp_ain1_low, 0);
2195
 
IIO_EVENT_ATTR_SH(ain2_high, iio_event_adt7316,
2196
 
                adt7316_show_ain2_high, adt7316_set_ain2_high, 0);
2197
 
IIO_EVENT_ATTR_SH(ain2_low, iio_event_adt7316,
2198
 
                adt7316_show_ain2_low, adt7316_set_ain2_low, 0);
2199
 
IIO_EVENT_ATTR_SH(ain3_high, iio_event_adt7316,
2200
 
                adt7316_show_ain3_high, adt7316_set_ain3_high, 0);
2201
 
IIO_EVENT_ATTR_SH(ain3_low, iio_event_adt7316,
2202
 
                adt7316_show_ain3_low, adt7316_set_ain3_low, 0);
2203
 
IIO_EVENT_ATTR_SH(ain4_high, iio_event_adt7316,
2204
 
                adt7316_show_ain4_high, adt7316_set_ain4_high, 0);
2205
 
IIO_EVENT_ATTR_SH(ain4_low, iio_event_adt7316,
2206
 
                adt7316_show_ain4_low, adt7316_set_ain4_low, 0);
2207
 
IIO_EVENT_ATTR_SH(int_enabled, iio_event_adt7316,
2208
 
                adt7316_show_int_enabled, adt7316_set_int_enabled, 0);
 
2017
/* NASTY duplication to be fixed */
 
2018
static IIO_DEVICE_ATTR(ex_temp_ain1_high_value,
 
2019
                       S_IRUGO | S_IWUSR,
 
2020
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2021
                       ADT7316_EX_TEMP_HIGH);
 
2022
static IIO_DEVICE_ATTR(ex_temp_ain1_low_value,
 
2023
                       S_IRUGO | S_IWUSR,
 
2024
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2025
                       ADT7316_EX_TEMP_LOW);
 
2026
static IIO_DEVICE_ATTR(ain2_high_value,
 
2027
                       S_IRUGO | S_IWUSR,
 
2028
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2029
                       ADT7516_AIN2_HIGH);
 
2030
static IIO_DEVICE_ATTR(ain2_low_value,
 
2031
                       S_IRUGO | S_IWUSR,
 
2032
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2033
                       ADT7516_AIN2_LOW);
 
2034
static IIO_DEVICE_ATTR(ain3_high_value,
 
2035
                       S_IRUGO | S_IWUSR,
 
2036
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2037
                       ADT7516_AIN3_HIGH);
 
2038
static IIO_DEVICE_ATTR(ain3_low_value,
 
2039
                       S_IRUGO | S_IWUSR,
 
2040
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2041
                       ADT7516_AIN3_LOW);
 
2042
static IIO_DEVICE_ATTR(ain4_high_value,
 
2043
                       S_IRUGO | S_IWUSR,
 
2044
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2045
                       ADT7516_AIN4_HIGH);
 
2046
static IIO_DEVICE_ATTR(ain4_low_value,
 
2047
                       S_IRUGO | S_IWUSR,
 
2048
                       adt7316_show_ad_bound, adt7316_set_ad_bound,
 
2049
                       ADT7516_AIN4_LOW);
 
2050
static IIO_DEVICE_ATTR(int_enabled,
 
2051
                       S_IRUGO | S_IWUSR,
 
2052
                       adt7316_show_int_enabled,
 
2053
                       adt7316_set_int_enabled, 0);
2209
2054
 
2210
2055
static struct attribute *adt7316_event_attributes[] = {
2211
 
        &iio_event_attr_int_mask.dev_attr.attr,
2212
 
        &iio_event_attr_in_temp_high.dev_attr.attr,
2213
 
        &iio_event_attr_in_temp_low.dev_attr.attr,
2214
 
        &iio_event_attr_ex_temp_high.dev_attr.attr,
2215
 
        &iio_event_attr_ex_temp_low.dev_attr.attr,
2216
 
        &iio_event_attr_int_enabled.dev_attr.attr,
 
2056
        &iio_dev_attr_int_mask.dev_attr.attr,
 
2057
        &iio_dev_attr_in_temp_high_value.dev_attr.attr,
 
2058
        &iio_dev_attr_in_temp_low_value.dev_attr.attr,
 
2059
        &iio_dev_attr_ex_temp_high_value.dev_attr.attr,
 
2060
        &iio_dev_attr_ex_temp_low_value.dev_attr.attr,
 
2061
        &iio_dev_attr_int_enabled.dev_attr.attr,
2217
2062
        NULL,
2218
2063
};
2219
2064
 
2222
2067
};
2223
2068
 
2224
2069
static struct attribute *adt7516_event_attributes[] = {
2225
 
        &iio_event_attr_int_mask.dev_attr.attr,
2226
 
        &iio_event_attr_in_temp_high.dev_attr.attr,
2227
 
        &iio_event_attr_in_temp_low.dev_attr.attr,
2228
 
        &iio_event_attr_ex_temp_ain1_high.dev_attr.attr,
2229
 
        &iio_event_attr_ex_temp_ain1_low.dev_attr.attr,
2230
 
        &iio_event_attr_ain2_high.dev_attr.attr,
2231
 
        &iio_event_attr_ain2_low.dev_attr.attr,
2232
 
        &iio_event_attr_ain3_high.dev_attr.attr,
2233
 
        &iio_event_attr_ain3_low.dev_attr.attr,
2234
 
        &iio_event_attr_ain4_high.dev_attr.attr,
2235
 
        &iio_event_attr_ain4_low.dev_attr.attr,
2236
 
        &iio_event_attr_int_enabled.dev_attr.attr,
 
2070
        &iio_dev_attr_int_mask.dev_attr.attr,
 
2071
        &iio_dev_attr_in_temp_high_value.dev_attr.attr,
 
2072
        &iio_dev_attr_in_temp_low_value.dev_attr.attr,
 
2073
        &iio_dev_attr_ex_temp_ain1_high_value.dev_attr.attr,
 
2074
        &iio_dev_attr_ex_temp_ain1_low_value.dev_attr.attr,
 
2075
        &iio_dev_attr_ain2_high_value.dev_attr.attr,
 
2076
        &iio_dev_attr_ain2_low_value.dev_attr.attr,
 
2077
        &iio_dev_attr_ain3_high_value.dev_attr.attr,
 
2078
        &iio_dev_attr_ain3_low_value.dev_attr.attr,
 
2079
        &iio_dev_attr_ain4_high_value.dev_attr.attr,
 
2080
        &iio_dev_attr_ain4_low_value.dev_attr.attr,
 
2081
        &iio_dev_attr_int_enabled.dev_attr.attr,
2237
2082
        NULL,
2238
2083
};
2239
2084
 
2261
2106
EXPORT_SYMBOL(adt7316_enable);
2262
2107
#endif
2263
2108
 
 
2109
static const struct iio_info adt7316_info = {
 
2110
        .attrs = &adt7316_attribute_group,
 
2111
        .num_interrupt_lines = 1,
 
2112
        .event_attrs = &adt7316_event_attribute_group,
 
2113
        .driver_module = THIS_MODULE,
 
2114
};
 
2115
 
 
2116
static const struct iio_info adt7516_info = {
 
2117
        .attrs = &adt7516_attribute_group,
 
2118
        .num_interrupt_lines = 1,
 
2119
        .event_attrs = &adt7516_event_attribute_group,
 
2120
        .driver_module = THIS_MODULE,
 
2121
};
 
2122
 
2264
2123
/*
2265
2124
 * device probe and remove
2266
2125
 */
2280
2139
        dev_set_drvdata(dev, chip);
2281
2140
 
2282
2141
        chip->bus = *bus;
2283
 
        chip->name = name;
2284
2142
 
2285
2143
        if (name[4] == '3')
2286
2144
                chip->id = ID_ADT7316 + (name[6] - '6');
2299
2157
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
2300
2158
                chip->int_mask |= ADT7516_AIN_INT_MASK;
2301
2159
 
2302
 
        chip->indio_dev = iio_allocate_device();
 
2160
        chip->indio_dev = iio_allocate_device(0);
2303
2161
        if (chip->indio_dev == NULL) {
2304
2162
                ret = -ENOMEM;
2305
2163
                goto error_free_chip;
2306
2164
        }
2307
2165
 
2308
2166
        chip->indio_dev->dev.parent = dev;
2309
 
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX) {
2310
 
                chip->indio_dev->attrs = &adt7516_attribute_group;
2311
 
                chip->indio_dev->event_attrs = &adt7516_event_attribute_group;
2312
 
        } else {
2313
 
                chip->indio_dev->attrs = &adt7316_attribute_group;
2314
 
                chip->indio_dev->event_attrs = &adt7316_event_attribute_group;
2315
 
        }
 
2167
        if ((chip->id & ID_FAMILY_MASK) == ID_ADT75XX)
 
2168
                chip->indio_dev->info = &adt7516_info;
 
2169
        else
 
2170
                chip->indio_dev->info = &adt7316_info;
 
2171
        chip->indio_dev->name = name;
2316
2172
        chip->indio_dev->dev_data = (void *)chip;
2317
 
        chip->indio_dev->driver_module = THIS_MODULE;
2318
 
        chip->indio_dev->num_interrupt_lines = 1;
2319
2173
        chip->indio_dev->modes = INDIO_DIRECT_MODE;
2320
2174
 
2321
2175
        ret = iio_device_register(chip->indio_dev);
2326
2180
                if (adt7316_platform_data[0])
2327
2181
                        chip->bus.irq_flags = adt7316_platform_data[0];
2328
2182
 
2329
 
                ret = iio_register_interrupt_line(chip->bus.irq,
2330
 
                                chip->indio_dev,
2331
 
                                0,
2332
 
                                chip->bus.irq_flags,
2333
 
                                chip->name);
 
2183
                ret = request_threaded_irq(chip->bus.irq,
 
2184
                                           NULL,
 
2185
                                           &adt7316_event_handler,
 
2186
                                           chip->bus.irq_flags | IRQF_ONESHOT,
 
2187
                                           chip->indio_dev->name,
 
2188
                                           chip->indio_dev);
2334
2189
                if (ret)
2335
2190
                        goto error_unreg_dev;
2336
2191
 
2337
 
                /*
2338
 
                 * The event handler list element refer to iio_event_adt7316.
2339
 
                 * All event attributes bind to the same event handler.
2340
 
                 * So, only register event handler once.
2341
 
                 */
2342
 
                iio_add_event_to_list(&iio_event_adt7316,
2343
 
                                &chip->indio_dev->interrupts[0]->ev_list);
2344
 
 
2345
 
                INIT_WORK(&chip->thresh_work, adt7316_interrupt_bh);
2346
 
 
2347
2192
                if (chip->bus.irq_flags & IRQF_TRIGGER_HIGH)
2348
2193
                        chip->config1 |= ADT7316_INT_POLARITY;
2349
2194
        }
2361
2206
        }
2362
2207
 
2363
2208
        dev_info(dev, "%s temperature sensor, ADC and DAC registered.\n",
2364
 
                        chip->name);
 
2209
                        chip->indio_dev->name);
2365
2210
 
2366
2211
        return 0;
2367
2212
 
2368
2213
error_unreg_irq:
2369
 
        iio_unregister_interrupt_line(chip->indio_dev, 0);
 
2214
        free_irq(chip->bus.irq, chip->indio_dev);
2370
2215
error_unreg_dev:
2371
2216
        iio_device_unregister(chip->indio_dev);
2372
2217
error_free_dev:
2383
2228
 
2384
2229
        struct iio_dev *dev_info = dev_get_drvdata(dev);
2385
2230
        struct adt7316_chip_info *chip = dev_info->dev_data;
2386
 
        struct iio_dev *indio_dev = chip->indio_dev;
2387
2231
 
2388
2232
        dev_set_drvdata(dev, NULL);
2389
2233
        if (chip->bus.irq)
2390
 
                iio_unregister_interrupt_line(indio_dev, 0);
2391
 
        iio_device_unregister(indio_dev);
 
2234
                free_irq(chip->bus.irq, chip->indio_dev);
 
2235
        iio_device_unregister(chip->indio_dev);
2392
2236
        iio_free_device(chip->indio_dev);
2393
2237
        kfree(chip);
2394
2238