← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/input/keyboard/qt1070.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/input/keyboard/qt1070.c
 
1
/*
 
2
 *  Atmel AT42QT1070 QTouch Sensor Controller
 
3
 *
 
4
 *  Copyright (C) 2011 Atmel
 
5
 *
 
6
 *  Authors: Bo Shen <voice.shen@atmel.com>
 
7
 *
 
8
 *  Base on AT42QT2160 driver by:
 
9
 *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
 
10
 *  Copyright (C) 2009
 
11
 *
 
12
 *  This program is free software; you can redistribute it and/or modify
 
13
 *  it under the terms of the GNU General Public License as published by
 
14
 *  the Free Software Foundation; either version 2 of the License, or
 
15
 *  (at your option) any later version.
 
16
 *
 
17
 *  This program is distributed in the hope that it will be useful,
 
18
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 *  GNU General Public License for more details.
 
21
 *
 
22
 *  You should have received a copy of the GNU General Public License
 
23
 *  along with this program; if not, write to the Free Software
 
24
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
25
 */
 
26
#include <linux/kernel.h>
 
27
#include <linux/module.h>
 
28
#include <linux/init.h>
 
29
#include <linux/i2c.h>
 
30
#include <linux/input.h>
 
31
#include <linux/slab.h>
 
32
#include <linux/irq.h>
 
33
#include <linux/interrupt.h>
 
34
#include <linux/jiffies.h>
 
35
#include <linux/delay.h>
 
36
 
 
37
/* Address for each register */
 
38
#define CHIP_ID            0x00
 
39
#define QT1070_CHIP_ID     0x2E
 
40
 
 
41
#define FW_VERSION         0x01
 
42
#define QT1070_FW_VERSION  0x15
 
43
 
 
44
#define DET_STATUS         0x02
 
45
 
 
46
#define KEY_STATUS         0x03
 
47
 
 
48
/* Calibrate */
 
49
#define CALIBRATE_CMD      0x38
 
50
#define QT1070_CAL_TIME    200
 
51
 
 
52
/* Reset */
 
53
#define RESET              0x39
 
54
#define QT1070_RESET_TIME  255
 
55
 
 
56
/* AT42QT1070 support up to 7 keys */
 
57
static const unsigned short qt1070_key2code[] = {
 
58
        KEY_0, KEY_1, KEY_2, KEY_3,
 
59
        KEY_4, KEY_5, KEY_6,
 
60
};
 
61
 
 
62
struct qt1070_data {
 
63
        struct i2c_client *client;
 
64
        struct input_dev *input;
 
65
        unsigned int irq;
 
66
        unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
 
67
        u8 last_keys;
 
68
};
 
69
 
 
70
static int qt1070_read(struct i2c_client *client, u8 reg)
 
71
{
 
72
        int ret;
 
73
 
 
74
        ret = i2c_smbus_read_byte_data(client, reg);
 
75
        if (ret < 0)
 
76
                dev_err(&client->dev,
 
77
                        "can not read register, returned %d\n", ret);
 
78
 
 
79
        return ret;
 
80
}
 
81
 
 
82
static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
 
83
{
 
84
        int ret;
 
85
 
 
86
        ret = i2c_smbus_write_byte_data(client, reg, data);
 
87
        if (ret < 0)
 
88
                dev_err(&client->dev,
 
89
                        "can not write register, returned %d\n", ret);
 
90
 
 
91
        return ret;
 
92
}
 
93
 
 
94
static bool __devinit qt1070_identify(struct i2c_client *client)
 
95
{
 
96
        int id, ver;
 
97
 
 
98
        /* Read Chip ID */
 
99
        id = qt1070_read(client, CHIP_ID);
 
100
        if (id != QT1070_CHIP_ID) {
 
101
                dev_err(&client->dev, "ID %d not supported\n", id);
 
102
                return false;
 
103
        }
 
104
 
 
105
        /* Read firmware version */
 
106
        ver = qt1070_read(client, FW_VERSION);
 
107
        if (ver < 0) {
 
108
                dev_err(&client->dev, "could not read the firmware version\n");
 
109
                return false;
 
110
        }
 
111
 
 
112
        dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver);
 
113
 
 
114
        return true;
 
115
}
 
116
 
 
117
static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
 
118
{
 
119
        struct qt1070_data *data = dev_id;
 
120
        struct i2c_client *client = data->client;
 
121
        struct input_dev *input = data->input;
 
122
        int i;
 
123
        u8 new_keys, keyval, mask = 0x01;
 
124
 
 
125
        /* Read the detected status register, thus clearing interrupt */
 
126
        qt1070_read(client, DET_STATUS);
 
127
 
 
128
        /* Read which key changed */
 
129
        new_keys = qt1070_read(client, KEY_STATUS);
 
130
 
 
131
        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
 
132
                keyval = new_keys & mask;
 
133
                if ((data->last_keys & mask) != keyval)
 
134
                        input_report_key(input, data->keycodes[i], keyval);
 
135
                mask <<= 1;
 
136
        }
 
137
        input_sync(input);
 
138
 
 
139
        data->last_keys = new_keys;
 
140
        return IRQ_HANDLED;
 
141
}
 
142
 
 
143
static int __devinit qt1070_probe(struct i2c_client *client,
 
144
                                const struct i2c_device_id *id)
 
145
{
 
146
        struct qt1070_data *data;
 
147
        struct input_dev *input;
 
148
        int i;
 
149
        int err;
 
150
 
 
151
        err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
 
152
        if (!err) {
 
153
                dev_err(&client->dev, "%s adapter not supported\n",
 
154
                        dev_driver_string(&client->adapter->dev));
 
155
                return -ENODEV;
 
156
        }
 
157
 
 
158
        if (!client->irq) {
 
159
                dev_err(&client->dev, "please assign the irq to this device\n");
 
160
                return -EINVAL;
 
161
        }
 
162
 
 
163
        /* Identify the qt1070 chip */
 
164
        if (!qt1070_identify(client))
 
165
                return -ENODEV;
 
166
 
 
167
        data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
 
168
        input = input_allocate_device();
 
169
        if (!data || !input) {
 
170
                dev_err(&client->dev, "insufficient memory\n");
 
171
                err = -ENOMEM;
 
172
                goto err_free_mem;
 
173
        }
 
174
 
 
175
        data->client = client;
 
176
        data->input = input;
 
177
        data->irq = client->irq;
 
178
 
 
179
        input->name = "AT42QT1070 QTouch Sensor";
 
180
        input->dev.parent = &client->dev;
 
181
        input->id.bustype = BUS_I2C;
 
182
 
 
183
        /* Add the keycode */
 
184
        input->keycode = data->keycodes;
 
185
        input->keycodesize = sizeof(data->keycodes[0]);
 
186
        input->keycodemax = ARRAY_SIZE(qt1070_key2code);
 
187
 
 
188
        __set_bit(EV_KEY, input->evbit);
 
189
 
 
190
        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
 
191
                data->keycodes[i] = qt1070_key2code[i];
 
192
                __set_bit(qt1070_key2code[i], input->keybit);
 
193
        }
 
194
 
 
195
        /* Calibrate device */
 
196
        qt1070_write(client, CALIBRATE_CMD, 1);
 
197
        msleep(QT1070_CAL_TIME);
 
198
 
 
199
        /* Soft reset */
 
200
        qt1070_write(client, RESET, 1);
 
201
        msleep(QT1070_RESET_TIME);
 
202
 
 
203
        err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
 
204
                IRQF_TRIGGER_NONE, client->dev.driver->name, data);
 
205
        if (err) {
 
206
                dev_err(&client->dev, "fail to request irq\n");
 
207
                goto err_free_mem;
 
208
        }
 
209
 
 
210
        /* Register the input device */
 
211
        err = input_register_device(data->input);
 
212
        if (err) {
 
213
                dev_err(&client->dev, "Failed to register input device\n");
 
214
                goto err_free_irq;
 
215
        }
 
216
 
 
217
        i2c_set_clientdata(client, data);
 
218
 
 
219
        /* Read to clear the chang line */
 
220
        qt1070_read(client, DET_STATUS);
 
221
 
 
222
        return 0;
 
223
 
 
224
err_free_irq:
 
225
        free_irq(client->irq, data);
 
226
err_free_mem:
 
227
        input_free_device(input);
 
228
        kfree(data);
 
229
        return err;
 
230
}
 
231
 
 
232
static int __devexit qt1070_remove(struct i2c_client *client)
 
233
{
 
234
        struct qt1070_data *data = i2c_get_clientdata(client);
 
235
 
 
236
        /* Release IRQ */
 
237
        free_irq(client->irq, data);
 
238
 
 
239
        input_unregister_device(data->input);
 
240
        kfree(data);
 
241
 
 
242
        i2c_set_clientdata(client, NULL);
 
243
 
 
244
        return 0;
 
245
}
 
246
 
 
247
static const struct i2c_device_id qt1070_id[] = {
 
248
        { "qt1070", 0 },
 
249
        { },
 
250
};
 
251
MODULE_DEVICE_TABLE(i2c, qt1070_id);
 
252
 
 
253
static struct i2c_driver qt1070_driver = {
 
254
        .driver = {
 
255
                .name   = "qt1070",
 
256
                .owner  = THIS_MODULE,
 
257
        },
 
258
        .id_table       = qt1070_id,
 
259
        .probe          = qt1070_probe,
 
260
        .remove         = __devexit_p(qt1070_remove),
 
261
};
 
262
 
 
263
static int __init qt1070_init(void)
 
264
{
 
265
        return i2c_add_driver(&qt1070_driver);
 
266
}
 
267
module_init(qt1070_init);
 
268
 
 
269
static void __exit qt1070_exit(void)
 
270
{
 
271
        i2c_del_driver(&qt1070_driver);
 
272
}
 
273
module_exit(qt1070_exit);
 
274
 
 
275
MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
 
276
MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
 
277
MODULE_LICENSE("GPL");