Merge branch 'async' of macbook:git/btrfs-unstable
[pandora-kernel.git] / drivers / input / keyboard / qt2160.c
1 /*
2  *  qt2160.c - Atmel AT42QT2160 Touch Sense Controller
3  *
4  *  Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/jiffies.h>
26 #include <linux/i2c.h>
27 #include <linux/irq.h>
28 #include <linux/interrupt.h>
29 #include <linux/input.h>
30
31 #define QT2160_VALID_CHIPID  0x11
32
33 #define QT2160_CMD_CHIPID     0
34 #define QT2160_CMD_CODEVER    1
35 #define QT2160_CMD_GSTAT      2
36 #define QT2160_CMD_KEYS3      3
37 #define QT2160_CMD_KEYS4      4
38 #define QT2160_CMD_SLIDE      5
39 #define QT2160_CMD_GPIOS      6
40 #define QT2160_CMD_SUBVER     7
41 #define QT2160_CMD_CALIBRATE  10
42
43 #define QT2160_CYCLE_INTERVAL   (2*HZ)
44
45 static unsigned char qt2160_key2code[] = {
46         KEY_0, KEY_1, KEY_2, KEY_3,
47         KEY_4, KEY_5, KEY_6, KEY_7,
48         KEY_8, KEY_9, KEY_A, KEY_B,
49         KEY_C, KEY_D, KEY_E, KEY_F,
50 };
51
52 struct qt2160_data {
53         struct i2c_client *client;
54         struct input_dev *input;
55         struct delayed_work dwork;
56         spinlock_t lock;        /* Protects canceling/rescheduling of dwork */
57         unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
58         u16 key_matrix;
59 };
60
61 static int qt2160_read_block(struct i2c_client *client,
62                              u8 inireg, u8 *buffer, unsigned int count)
63 {
64         int error, idx = 0;
65
66         /*
67          * Can't use SMBus block data read. Check for I2C functionality to speed
68          * things up whenever possible. Otherwise we will be forced to read
69          * sequentially.
70          */
71         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))     {
72
73                 error = i2c_smbus_write_byte(client, inireg + idx);
74                 if (error) {
75                         dev_err(&client->dev,
76                                 "couldn't send request. Returned %d\n", error);
77                         return error;
78                 }
79
80                 error = i2c_master_recv(client, buffer, count);
81                 if (error != count) {
82                         dev_err(&client->dev,
83                                 "couldn't read registers. Returned %d bytes\n", error);
84                         return error;
85                 }
86         } else {
87
88                 while (count--) {
89                         int data;
90
91                         error = i2c_smbus_write_byte(client, inireg + idx);
92                         if (error) {
93                                 dev_err(&client->dev,
94                                         "couldn't send request. Returned %d\n", error);
95                                 return error;
96                         }
97
98                         data = i2c_smbus_read_byte(client);
99                         if (data < 0) {
100                                 dev_err(&client->dev,
101                                         "couldn't read register. Returned %d\n", data);
102                                 return data;
103                         }
104
105                         buffer[idx++] = data;
106                 }
107         }
108
109         return 0;
110 }
111
112 static int qt2160_get_key_matrix(struct qt2160_data *qt2160)
113 {
114         struct i2c_client *client = qt2160->client;
115         struct input_dev *input = qt2160->input;
116         u8 regs[6];
117         u16 old_matrix, new_matrix;
118         int ret, i, mask;
119
120         dev_dbg(&client->dev, "requesting keys...\n");
121
122         /*
123          * Read all registers from General Status Register
124          * to GPIOs register
125          */
126         ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6);
127         if (ret) {
128                 dev_err(&client->dev,
129                         "could not perform chip read.\n");
130                 return ret;
131         }
132
133         old_matrix = qt2160->key_matrix;
134         qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1];
135
136         mask = 0x01;
137         for (i = 0; i < 16; ++i, mask <<= 1) {
138                 int keyval = new_matrix & mask;
139
140                 if ((old_matrix & mask) != keyval) {
141                         input_report_key(input, qt2160->keycodes[i], keyval);
142                         dev_dbg(&client->dev, "key %d %s\n",
143                                 i, keyval ? "pressed" : "released");
144                 }
145         }
146
147         input_sync(input);
148
149         return 0;
150 }
151
152 static irqreturn_t qt2160_irq(int irq, void *_qt2160)
153 {
154         struct qt2160_data *qt2160 = _qt2160;
155         unsigned long flags;
156
157         spin_lock_irqsave(&qt2160->lock, flags);
158
159         __cancel_delayed_work(&qt2160->dwork);
160         schedule_delayed_work(&qt2160->dwork, 0);
161
162         spin_unlock_irqrestore(&qt2160->lock, flags);
163
164         return IRQ_HANDLED;
165 }
166
167 static void qt2160_schedule_read(struct qt2160_data *qt2160)
168 {
169         spin_lock_irq(&qt2160->lock);
170         schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL);
171         spin_unlock_irq(&qt2160->lock);
172 }
173
174 static void qt2160_worker(struct work_struct *work)
175 {
176         struct qt2160_data *qt2160 =
177                 container_of(work, struct qt2160_data, dwork.work);
178
179         dev_dbg(&qt2160->client->dev, "worker\n");
180
181         qt2160_get_key_matrix(qt2160);
182
183         /* Avoid device lock up by checking every so often */
184         qt2160_schedule_read(qt2160);
185 }
186
187 static int __devinit qt2160_read(struct i2c_client *client, u8 reg)
188 {
189         int ret;
190
191         ret = i2c_smbus_write_byte(client, reg);
192         if (ret) {
193                 dev_err(&client->dev,
194                         "couldn't send request. Returned %d\n", ret);
195                 return ret;
196         }
197
198         ret = i2c_smbus_read_byte(client);
199         if (ret < 0) {
200                 dev_err(&client->dev,
201                         "couldn't read register. Returned %d\n", ret);
202                 return ret;
203         }
204
205         return ret;
206 }
207
208 static int __devinit qt2160_write(struct i2c_client *client, u8 reg, u8 data)
209 {
210         int error;
211
212         error = i2c_smbus_write_byte(client, reg);
213         if (error) {
214                 dev_err(&client->dev,
215                         "couldn't send request. Returned %d\n", error);
216                 return error;
217         }
218
219         error = i2c_smbus_write_byte(client, data);
220         if (error) {
221                 dev_err(&client->dev,
222                         "couldn't write data. Returned %d\n", error);
223                 return error;
224         }
225
226         return error;
227 }
228
229
230 static bool __devinit qt2160_identify(struct i2c_client *client)
231 {
232         int id, ver, rev;
233
234         /* Read Chid ID to check if chip is valid */
235         id = qt2160_read(client, QT2160_CMD_CHIPID);
236         if (id != QT2160_VALID_CHIPID) {
237                 dev_err(&client->dev, "ID %d not supported\n", id);
238                 return false;
239         }
240
241         /* Read chip firmware version */
242         ver = qt2160_read(client, QT2160_CMD_CODEVER);
243         if (ver < 0) {
244                 dev_err(&client->dev, "could not get firmware version\n");
245                 return false;
246         }
247
248         /* Read chip firmware revision */
249         rev = qt2160_read(client, QT2160_CMD_SUBVER);
250         if (rev < 0) {
251                 dev_err(&client->dev, "could not get firmware revision\n");
252                 return false;
253         }
254
255         dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n",
256                         ver >> 4, ver & 0xf, rev);
257
258         return true;
259 }
260
261 static int __devinit qt2160_probe(struct i2c_client *client,
262                                   const struct i2c_device_id *id)
263 {
264         struct qt2160_data *qt2160;
265         struct input_dev *input;
266         int i;
267         int error;
268
269         /* Check functionality */
270         error = i2c_check_functionality(client->adapter,
271                         I2C_FUNC_SMBUS_BYTE);
272         if (!error) {
273                 dev_err(&client->dev, "%s adapter not supported\n",
274                                 dev_driver_string(&client->adapter->dev));
275                 return -ENODEV;
276         }
277
278         if (!qt2160_identify(client))
279                 return -ENODEV;
280
281         /* Chip is valid and active. Allocate structure */
282         qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL);
283         input = input_allocate_device();
284         if (!qt2160 || !input) {
285                 dev_err(&client->dev, "insufficient memory\n");
286                 error = -ENOMEM;
287                 goto err_free_mem;
288         }
289
290         qt2160->client = client;
291         qt2160->input = input;
292         INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker);
293         spin_lock_init(&qt2160->lock);
294
295         input->name = "AT42QT2160 Touch Sense Keyboard";
296         input->id.bustype = BUS_I2C;
297
298         input->keycode = qt2160->keycodes;
299         input->keycodesize = sizeof(qt2160->keycodes[0]);
300         input->keycodemax = ARRAY_SIZE(qt2160_key2code);
301
302         __set_bit(EV_KEY, input->evbit);
303         __clear_bit(EV_REP, input->evbit);
304         for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) {
305                 qt2160->keycodes[i] = qt2160_key2code[i];
306                 __set_bit(qt2160_key2code[i], input->keybit);
307         }
308         __clear_bit(KEY_RESERVED, input->keybit);
309
310         /* Calibrate device */
311         error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1);
312         if (error) {
313                 dev_err(&client->dev, "failed to calibrate device\n");
314                 goto err_free_mem;
315         }
316
317         if (client->irq) {
318                 error = request_irq(client->irq, qt2160_irq,
319                                     IRQF_TRIGGER_FALLING, "qt2160", qt2160);
320                 if (error) {
321                         dev_err(&client->dev,
322                                 "failed to allocate irq %d\n", client->irq);
323                         goto err_free_mem;
324                 }
325         }
326
327         error = input_register_device(qt2160->input);
328         if (error) {
329                 dev_err(&client->dev,
330                         "Failed to register input device\n");
331                 goto err_free_irq;
332         }
333
334         i2c_set_clientdata(client, qt2160);
335         qt2160_schedule_read(qt2160);
336
337         return 0;
338
339 err_free_irq:
340         if (client->irq)
341                 free_irq(client->irq, qt2160);
342 err_free_mem:
343         input_free_device(input);
344         kfree(qt2160);
345         return error;
346 }
347
348 static int __devexit qt2160_remove(struct i2c_client *client)
349 {
350         struct qt2160_data *qt2160 = i2c_get_clientdata(client);
351
352         /* Release IRQ so no queue will be scheduled */
353         if (client->irq)
354                 free_irq(client->irq, qt2160);
355
356         cancel_delayed_work_sync(&qt2160->dwork);
357
358         input_unregister_device(qt2160->input);
359         kfree(qt2160);
360
361         return 0;
362 }
363
364 static const struct i2c_device_id qt2160_idtable[] = {
365         { "qt2160", 0, },
366         { }
367 };
368
369 MODULE_DEVICE_TABLE(i2c, qt2160_idtable);
370
371 static struct i2c_driver qt2160_driver = {
372         .driver = {
373                 .name   = "qt2160",
374                 .owner  = THIS_MODULE,
375         },
376
377         .id_table       = qt2160_idtable,
378         .probe          = qt2160_probe,
379         .remove         = __devexit_p(qt2160_remove),
380 };
381
382 static int __init qt2160_init(void)
383 {
384         return i2c_add_driver(&qt2160_driver);
385 }
386 module_init(qt2160_init);
387
388 static void __exit qt2160_cleanup(void)
389 {
390         i2c_del_driver(&qt2160_driver);
391 }
392 module_exit(qt2160_cleanup);
393
394 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
395 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
396 MODULE_LICENSE("GPL");