← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/staging/iio/addac/adt7316-spi.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/addac/adt7316-spi.c
 
1
/*
 
2
 * API bus driver for ADT7316/7/8 ADT7516/7/9 digital temperature
 
3
 * sensor, ADC and DAC
 
4
 *
 
5
 * Copyright 2010 Analog Devices Inc.
 
6
 *
 
7
 * Licensed under the GPL-2 or later.
 
8
 */
 
9
 
 
10
#include <linux/device.h>
 
11
#include <linux/kernel.h>
 
12
#include <linux/module.h>
 
13
#include <linux/interrupt.h>
 
14
#include <linux/spi/spi.h>
 
15
 
 
16
#include "adt7316.h"
 
17
 
 
18
#define ADT7316_SPI_MAX_FREQ_HZ         5000000
 
19
#define ADT7316_SPI_CMD_READ            0x91
 
20
#define ADT7316_SPI_CMD_WRITE           0x90
 
21
 
 
22
/*
 
23
 * adt7316 register access by SPI
 
24
 */
 
25
 
 
26
static int adt7316_spi_multi_read(void *client, u8 reg, u8 count, u8 *data)
 
27
{
 
28
        struct spi_device *spi_dev = client;
 
29
        u8 cmd[2];
 
30
        int ret = 0;
 
31
 
 
32
        if (count > ADT7316_REG_MAX_ADDR)
 
33
                count = ADT7316_REG_MAX_ADDR;
 
34
 
 
35
        cmd[0] = ADT7316_SPI_CMD_WRITE;
 
36
        cmd[1] = reg;
 
37
 
 
38
        ret = spi_write(spi_dev, cmd, 2);
 
39
        if (ret < 0) {
 
40
                dev_err(&spi_dev->dev, "SPI fail to select reg\n");
 
41
                return ret;
 
42
        }
 
43
 
 
44
        cmd[0] = ADT7316_SPI_CMD_READ;
 
45
 
 
46
        ret = spi_write_then_read(spi_dev, cmd, 1, data, count);
 
47
        if (ret < 0) {
 
48
                dev_err(&spi_dev->dev, "SPI read data error\n");
 
49
                return ret;
 
50
        }
 
51
 
 
52
        return 0;
 
53
}
 
54
 
 
55
static int adt7316_spi_multi_write(void *client, u8 reg, u8 count, u8 *data)
 
56
{
 
57
        struct spi_device *spi_dev = client;
 
58
        u8 buf[ADT7316_REG_MAX_ADDR + 2];
 
59
        int i, ret = 0;
 
60
 
 
61
        if (count > ADT7316_REG_MAX_ADDR)
 
62
                count = ADT7316_REG_MAX_ADDR;
 
63
 
 
64
        buf[0] = ADT7316_SPI_CMD_WRITE;
 
65
        buf[1] = reg;
 
66
        for (i = 0; i < count; i++)
 
67
                buf[i + 2] = data[i];
 
68
 
 
69
        ret = spi_write(spi_dev, buf, count + 2);
 
70
        if (ret < 0) {
 
71
                dev_err(&spi_dev->dev, "SPI write error\n");
 
72
                return ret;
 
73
        }
 
74
 
 
75
        return ret;
 
76
}
 
77
 
 
78
static int adt7316_spi_read(void *client, u8 reg, u8 *data)
 
79
{
 
80
        return adt7316_spi_multi_read(client, reg, 1, data);
 
81
}
 
82
 
 
83
static int adt7316_spi_write(void *client, u8 reg, u8 val)
 
84
{
 
85
        return adt7316_spi_multi_write(client, reg, 1, &val);
 
86
}
 
87
 
 
88
/*
 
89
 * device probe and remove
 
90
 */
 
91
 
 
92
static int __devinit adt7316_spi_probe(struct spi_device *spi_dev)
 
93
{
 
94
        struct adt7316_bus bus = {
 
95
                .client = spi_dev,
 
96
                .irq = spi_dev->irq,
 
97
                .irq_flags = IRQF_TRIGGER_LOW,
 
98
                .read = adt7316_spi_read,
 
99
                .write = adt7316_spi_write,
 
100
                .multi_read = adt7316_spi_multi_read,
 
101
                .multi_write = adt7316_spi_multi_write,
 
102
        };
 
103
 
 
104
        /* don't exceed max specified SPI CLK frequency */
 
105
        if (spi_dev->max_speed_hz > ADT7316_SPI_MAX_FREQ_HZ) {
 
106
                dev_err(&spi_dev->dev, "SPI CLK %d Hz?\n",
 
107
                        spi_dev->max_speed_hz);
 
108
                return -EINVAL;
 
109
        }
 
110
 
 
111
        /* switch from default I2C protocol to SPI protocol */
 
112
        adt7316_spi_write(spi_dev, 0, 0);
 
113
        adt7316_spi_write(spi_dev, 0, 0);
 
114
        adt7316_spi_write(spi_dev, 0, 0);
 
115
 
 
116
        return adt7316_probe(&spi_dev->dev, &bus, spi_dev->modalias);
 
117
}
 
118
 
 
119
static int __devexit adt7316_spi_remove(struct spi_device *spi_dev)
 
120
{
 
121
        return adt7316_remove(&spi_dev->dev);
 
122
}
 
123
 
 
124
static const struct spi_device_id adt7316_spi_id[] = {
 
125
        { "adt7316", 0 },
 
126
        { "adt7317", 0 },
 
127
        { "adt7318", 0 },
 
128
        { "adt7516", 0 },
 
129
        { "adt7517", 0 },
 
130
        { "adt7519", 0 },
 
131
        { }
 
132
};
 
133
 
 
134
MODULE_DEVICE_TABLE(spi, adt7316_spi_id);
 
135
 
 
136
#ifdef CONFIG_PM
 
137
static int adt7316_spi_suspend(struct spi_device *spi_dev, pm_message_t message)
 
138
{
 
139
        return adt7316_disable(&spi_dev->dev);
 
140
}
 
141
 
 
142
static int adt7316_spi_resume(struct spi_device *spi_dev)
 
143
{
 
144
        return adt7316_enable(&spi_dev->dev);
 
145
}
 
146
#else
 
147
# define adt7316_spi_suspend NULL
 
148
# define adt7316_spi_resume  NULL
 
149
#endif
 
150
 
 
151
static struct spi_driver adt7316_driver = {
 
152
        .driver = {
 
153
                .name = "adt7316",
 
154
                .bus = &spi_bus_type,
 
155
                .owner = THIS_MODULE,
 
156
        },
 
157
        .probe = adt7316_spi_probe,
 
158
        .remove = __devexit_p(adt7316_spi_remove),
 
159
        .suspend = adt7316_spi_suspend,
 
160
        .resume = adt7316_spi_resume,
 
161
        .id_table = adt7316_spi_id,
 
162
};
 
163
 
 
164
static __init int adt7316_spi_init(void)
 
165
{
 
166
        return spi_register_driver(&adt7316_driver);
 
167
}
 
168
 
 
169
static __exit void adt7316_spi_exit(void)
 
170
{
 
171
        spi_unregister_driver(&adt7316_driver);
 
172
}
 
173
 
 
174
MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
 
175
MODULE_DESCRIPTION("SPI bus driver for Analog Devices ADT7316/7/8 and"
 
176
                        "ADT7516/7/9 digital temperature sensor, ADC and DAC");
 
177
MODULE_LICENSE("GPL v2");
 
178
 
 
179
module_init(adt7316_spi_init);
 
180
module_exit(adt7316_spi_exit);