projects / openwrt / staging / yousong.git / blob
? search:


e5cd02990bd18b3a6e5f6265b94b306f15c35b1b
[openwrt/staging/yousong.git] / target / linux / s3c24xx / files-2.6.31 / drivers / input / misc / lis302dl.c
1 /* Linux kernel driver for the ST LIS302D 3-axis accelerometer
2 *
3 * Copyright (C) 2007-2008 by Openmoko, Inc.
4 * Author: Harald Welte <laforge@openmoko.org>
5 * converted to private bitbang by:
6 * Andy Green <andy@openmoko.com>
7 * ability to set acceleration threshold added by:
8 * Simon Kagstrom <simon.kagstrom@gmail.com>
9 * All rights reserved.
10 * Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of
15 * the License, or (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., 59 Temple Place, Suite 330, Boston,
25 * MA 02111-1307 USA
26 *
27 * TODO
28 * * statistics for overflow events
29 * * configuration interface (sysfs) for
30 * * enable/disable x/y/z axis data ready
31 * * enable/disable resume from freee fall / click
32 * * free fall / click parameters
33 * * high pass filter parameters
34 */
35 #include <linux/kernel.h>
36 #include <linux/types.h>
37 #include <linux/module.h>
38 #include <linux/device.h>
39 #include <linux/platform_device.h>
40 #include <linux/delay.h>
41 #include <linux/irq.h>
42 #include <linux/interrupt.h>
43 #include <linux/sysfs.h>
44 #include <linux/spi/spi.h>
45
46 #include <linux/lis302dl.h>
47
48 static uint8_t lis_reg_read(struct lis302dl_info *lis, uint8_t reg)
49 {
50 return spi_w8r8(lis->spi, 0xc0 | reg);
51 }
52
53 static void lis_reg_write(struct lis302dl_info *lis, uint8_t reg, uint8_t val)
54 {
55 uint8_t data[2] = {reg, val};
56
57 spi_write(lis->spi, data, sizeof(data));
58 }
59
60 static void lis_reg_set_bit_mask(struct lis302dl_info *lis, uint8_t reg, uint8_t mask,
61 uint8_t val)
62 {
63 uint8_t tmp;
64
65 val &= mask;
66
67 tmp = lis_reg_read(lis, reg);
68 tmp &= ~mask;
69 tmp |= val;
70 lis_reg_write(lis, reg, tmp);
71 }
72
73 static int __ms_to_duration(struct lis302dl_info *lis, int ms)
74 {
75 /* If we have 400 ms sampling rate, the stepping is 2.5 ms,
76 * on 100 ms the stepping is 10ms */
77 if (lis->flags & LIS302DL_F_DR)
78 return min((ms * 10) / 25, 637);
79
80 return min(ms / 10, 2550);
81 }
82
83 static int __duration_to_ms(struct lis302dl_info *lis, int duration)
84 {
85 if (lis->flags & LIS302DL_F_DR)
86 return (duration * 25) / 10;
87
88 return duration * 10;
89 }
90
91 static uint8_t __mg_to_threshold(struct lis302dl_info *lis, int mg)
92 {
93 /* If FS is set each bit is 71mg, otherwise 18mg. The THS register
94 * has 7 bits for the threshold value */
95 if (lis->flags & LIS302DL_F_FS)
96 return min(mg / 71, 127);
97
98 return min(mg / 18, 127);
99 }
100
101 static int __threshold_to_mg(struct lis302dl_info *lis, uint8_t threshold)
102 {
103 if (lis->flags & LIS302DL_F_FS)
104 return threshold * 71;
105
106 return threshold * 18;
107 }
108
109 /* interrupt handling related */
110
111 enum lis302dl_intmode {
112 LIS302DL_INTMODE_GND = 0x00,
113 LIS302DL_INTMODE_FF_WU_1 = 0x01,
114 LIS302DL_INTMODE_FF_WU_2 = 0x02,
115 LIS302DL_INTMODE_FF_WU_12 = 0x03,
116 LIS302DL_INTMODE_DATA_READY = 0x04,
117 LIS302DL_INTMODE_CLICK = 0x07,
118 };
119
120 static void lis302dl_set_int_mode(struct device *dev, int int_pin,
121 enum lis302dl_intmode mode)
122 {
123 struct lis302dl_info *lis = dev_get_drvdata(dev);
124 switch (int_pin) {
125 case 1:
126 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x07, mode);
127 break;
128 case 2:
129 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x38, mode << 3);
130 break;
131 default:
132 BUG();
133 }
134 }
135
136 static void __enable_wakeup(struct lis302dl_info *lis)
137 {
138 lis_reg_write(lis, LIS302DL_REG_CTRL1, 0);
139
140 /* First zero to get to a known state */
141 lis_reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, LIS302DL_FFWUCFG_XHIE |
142 LIS302DL_FFWUCFG_YHIE | LIS302DL_FFWUCFG_ZHIE |
143 LIS302DL_FFWUCFG_LIR);
144 lis_reg_write(lis, LIS302DL_REG_FF_WU_THS_1,
145 __mg_to_threshold(lis, lis->wakeup.threshold));
146 lis_reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
147 __ms_to_duration(lis, lis->wakeup.duration));
148
149 /* Route the interrupt for wakeup */
150 lis302dl_set_int_mode(lis->dev, 1,
151 LIS302DL_INTMODE_FF_WU_1);
152
153 lis_reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
154 lis_reg_read(lis, LIS302DL_REG_OUT_X);
155 lis_reg_read(lis, LIS302DL_REG_OUT_Y);
156 lis_reg_read(lis, LIS302DL_REG_OUT_Z);
157 lis_reg_read(lis, LIS302DL_REG_STATUS);
158 lis_reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
159 lis_reg_read(lis, LIS302DL_REG_FF_WU_SRC_2);
160 lis_reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD | 7);
161 }
162
163 static void __enable_data_collection(struct lis302dl_info *lis)
164 {
165 u_int8_t ctrl1 = LIS302DL_CTRL1_PD | LIS302DL_CTRL1_Xen |
166 LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen;
167
168 /* make sure we're powered up and generate data ready */
169 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1);
170
171 /* If the threshold is zero, let the device generated an interrupt
172 * on each datum */
173 if (lis->threshold == 0) {
174 lis_reg_write(lis, LIS302DL_REG_CTRL2, 0);
175 lis302dl_set_int_mode(lis->dev, 1, LIS302DL_INTMODE_DATA_READY);
176 lis302dl_set_int_mode(lis->dev, 2, LIS302DL_INTMODE_DATA_READY);
177 } else {
178 lis_reg_write(lis, LIS302DL_REG_CTRL2,
179 LIS302DL_CTRL2_HPFF1);
180 lis_reg_write(lis, LIS302DL_REG_FF_WU_THS_1,
181 __mg_to_threshold(lis, lis->threshold));
182 lis_reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
183 __ms_to_duration(lis, lis->duration));
184
185 /* Clear the HP filter "starting point" */
186 lis_reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
187 lis_reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
188 LIS302DL_FFWUCFG_XHIE | LIS302DL_FFWUCFG_YHIE |
189 LIS302DL_FFWUCFG_ZHIE | LIS302DL_FFWUCFG_LIR);
190 lis302dl_set_int_mode(lis->dev, 1, LIS302DL_INTMODE_FF_WU_12);
191 lis302dl_set_int_mode(lis->dev, 2, LIS302DL_INTMODE_FF_WU_12);
192 }
193 }
194
195 #if 0
196 static void _report_btn_single(struct input_dev *inp, int btn)
197 {
198 input_report_key(inp, btn, 1);
199 input_sync(inp);
200 input_report_key(inp, btn, 0);
201 }
202
203 static void _report_btn_double(struct input_dev *inp, int btn)
204 {
205 input_report_key(inp, btn, 1);
206 input_sync(inp);
207 input_report_key(inp, btn, 0);
208 input_sync(inp);
209 input_report_key(inp, btn, 1);
210 input_sync(inp);
211 input_report_key(inp, btn, 0);
212 }
213 #endif
214
215
216 static void lis302dl_bitbang_read_sample(struct lis302dl_info *lis)
217 {
218 uint8_t data[(LIS302DL_REG_OUT_Z - LIS302DL_REG_STATUS) + 2] = {0xC0 | LIS302DL_REG_STATUS};
219 uint8_t *read = data + 1;
220 unsigned long flags;
221 int mg_per_sample = __threshold_to_mg(lis, 1);
222 struct spi_message msg;
223 struct spi_transfer t;
224
225 spi_message_init(&msg);
226 memset(&t, 0, sizeof t);
227 t.len = sizeof(data);
228 spi_message_add_tail(&t, &msg);
229 t.tx_buf = &data[0];
230 t.rx_buf = &data[0];
231
232 /* grab the set of register containing status and XYZ data */
233 local_irq_save(flags);
234 /* Should complete without blocking */
235 if (spi_sync(lis->spi, &msg) < 0)
236 dev_err(lis->dev, "Error reading registers\n");
237
238 local_irq_restore(flags);
239 /*
240 * at the minute the test below fails 50% of the time due to
241 * a problem with level interrupts causing ISRs to get called twice.
242 * This is a workaround for that, but actually this test is still
243 * valid and the information can be used for overrrun stats.
244 */
245
246 /* has any kind of overrun been observed by the lis302dl? */
247 if (read[0] & (LIS302DL_STATUS_XOR |
248 LIS302DL_STATUS_YOR |
249 LIS302DL_STATUS_ZOR))
250 lis->overruns++;
251
252 /* we have a valid sample set? */
253 if (read[0] & LIS302DL_STATUS_XYZDA) {
254 input_report_abs(lis->input_dev, ABS_X, mg_per_sample *
255 (s8)read[LIS302DL_REG_OUT_X - LIS302DL_REG_STATUS]);
256 input_report_abs(lis->input_dev, ABS_Y, mg_per_sample *
257 (s8)read[LIS302DL_REG_OUT_Y - LIS302DL_REG_STATUS]);
258 input_report_abs(lis->input_dev, ABS_Z, mg_per_sample *
259 (s8)read[LIS302DL_REG_OUT_Z - LIS302DL_REG_STATUS]);
260
261 input_sync(lis->input_dev);
262 } else {
263 printk("invalid sample\n");
264 }
265
266 if (lis->threshold)
267 /* acknowledge the wakeup source */
268 lis_reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
269 enable_irq(lis->pdata->interrupt);
270 }
271
272 static void lis302dl_irq_worker(struct work_struct *work) {
273 struct lis302dl_info *lis = container_of(work, struct lis302dl_info, work);
274 lis302dl_bitbang_read_sample(lis);
275 }
276
277 static irqreturn_t lis302dl_interrupt(int irq, void *_lis)
278 {
279 struct lis302dl_info *lis = _lis;
280 disable_irq_nosync(lis->pdata->interrupt);
281 schedule_work(&lis->work);
282 return IRQ_HANDLED;
283 }
284
285 /* sysfs */
286
287 static ssize_t show_overruns(struct device *dev, struct device_attribute *attr,
288 char *buf)
289 {
290 struct lis302dl_info *lis = dev_get_drvdata(dev);
291
292 return sprintf(buf, "%u\n", lis->overruns);
293 }
294
295 static DEVICE_ATTR(overruns, S_IRUGO, show_overruns, NULL);
296
297 static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
298 char *buf)
299 {
300 struct lis302dl_info *lis = dev_get_drvdata(dev);
301 uint8_t ctrl1;
302 unsigned long flags;
303
304 local_irq_save(flags);
305 ctrl1 = lis_reg_read(lis, LIS302DL_REG_CTRL1);
306 local_irq_restore(flags);
307
308 return sprintf(buf, "%d\n", ctrl1 & LIS302DL_CTRL1_DR ? 400 : 100);
309 }
310
311 static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
312 const char *buf, size_t count)
313 {
314 struct lis302dl_info *lis = dev_get_drvdata(dev);
315 unsigned long flags;
316
317 local_irq_save(flags);
318
319 if (!strcmp(buf, "400\n")) {
320 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
321 LIS302DL_CTRL1_DR);
322 lis->flags |= LIS302DL_F_DR;
323 } else {
324 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
325 0);
326 lis->flags &= ~LIS302DL_F_DR;
327 }
328 local_irq_restore(flags);
329
330 return count;
331 }
332
333 static DEVICE_ATTR(sample_rate, S_IRUGO | S_IWUSR, show_rate, set_rate);
334
335 static ssize_t show_scale(struct device *dev, struct device_attribute *attr,
336 char *buf)
337 {
338 struct lis302dl_info *lis = dev_get_drvdata(dev);
339 u_int8_t ctrl1;
340 unsigned long flags;
341
342 local_irq_save(flags);
343 ctrl1 = lis_reg_read(lis, LIS302DL_REG_CTRL1);
344 local_irq_restore(flags);
345
346 return sprintf(buf, "%s\n", ctrl1 & LIS302DL_CTRL1_FS ? "9.2" : "2.3");
347 }
348
349 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
350 const char *buf, size_t count)
351 {
352 struct lis302dl_info *lis = dev_get_drvdata(dev);
353 unsigned long flags;
354
355 local_irq_save(flags);
356
357 if (!strcmp(buf, "9.2\n")) {
358 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
359 LIS302DL_CTRL1_FS);
360 lis->flags |= LIS302DL_F_FS;
361 } else {
362 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
363 0);
364 lis->flags &= ~LIS302DL_F_FS;
365 }
366
367 if (lis->flags & LIS302DL_F_INPUT_OPEN)
368 __enable_data_collection(lis);
369
370 local_irq_restore(flags);
371
372 return count;
373 }
374
375 static DEVICE_ATTR(full_scale, S_IRUGO | S_IWUSR, show_scale, set_scale);
376
377 static ssize_t show_threshold(struct device *dev, struct device_attribute *attr,
378 char *buf)
379 {
380 struct lis302dl_info *lis = dev_get_drvdata(dev);
381
382 /* Display the device view of the threshold setting */
383 return sprintf(buf, "%d\n", __threshold_to_mg(lis,
384 __mg_to_threshold(lis, lis->threshold)));
385 }
386
387 static ssize_t set_threshold(struct device *dev, struct device_attribute *attr,
388 const char *buf, size_t count)
389 {
390 struct lis302dl_info *lis = dev_get_drvdata(dev);
391 unsigned int val;
392
393 if (sscanf(buf, "%u\n", &val) != 1)
394 return -EINVAL;
395 /* 8g is the maximum if FS is 1 */
396 if (val > 8000)
397 return -ERANGE;
398
399 /* Set the threshold and write it out if the device is used */
400 lis->threshold = val;
401
402 if (lis->flags & LIS302DL_F_INPUT_OPEN) {
403 unsigned long flags;
404
405 local_irq_save(flags);
406 __enable_data_collection(lis);
407 local_irq_restore(flags);
408 }
409
410 return count;
411 }
412
413 static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR, show_threshold, set_threshold);
414
415 static ssize_t show_duration(struct device *dev, struct device_attribute *attr,
416 char *buf)
417 {
418 struct lis302dl_info *lis = dev_get_drvdata(dev);
419
420 return sprintf(buf, "%d\n", __duration_to_ms(lis,
421 __ms_to_duration(lis, lis->duration)));
422 }
423
424 static ssize_t set_duration(struct device *dev, struct device_attribute *attr,
425 const char *buf, size_t count)
426 {
427 struct lis302dl_info *lis = dev_get_drvdata(dev);
428 unsigned int val;
429
430 if (sscanf(buf, "%u\n", &val) != 1)
431 return -EINVAL;
432 if (val > 2550)
433 return -ERANGE;
434
435 lis->duration = val;
436 if (lis->flags & LIS302DL_F_INPUT_OPEN)
437 lis_reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
438 __ms_to_duration(lis, lis->duration));
439
440 return count;
441 }
442
443 static DEVICE_ATTR(duration, S_IRUGO | S_IWUSR, show_duration, set_duration);
444
445 static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
446 char *buf)
447 {
448 struct lis302dl_info *lis = dev_get_drvdata(dev);
449 int n = 0;
450 uint8_t reg[0x40];
451 char *end = buf;
452 unsigned long flags;
453
454 local_irq_save(flags);
455
456 for (n = 0; n < sizeof(reg); n++)
457 reg[n] = lis_reg_read(lis, n);
458
459 local_irq_restore(flags);
460
461 for (n = 0; n < sizeof(reg); n += 16) {
462 hex_dump_to_buffer(reg + n, 16, 16, 1, end, 128, 0);
463 end += strlen(end);
464 *end++ = '\n';
465 *end++ = '\0';
466 }
467
468 return end - buf;
469 }
470 static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL);
471
472 /* Configure freefall/wakeup interrupts */
473 static ssize_t set_wakeup_threshold(struct device *dev,
474 struct device_attribute *attr, const char *buf, size_t count)
475 {
476 struct lis302dl_info *lis = dev_get_drvdata(dev);
477 unsigned int threshold;
478
479 if (sscanf(buf, "%u\n", &threshold) != 1)
480 return -EINVAL;
481
482 if (threshold > 8000)
483 return -ERANGE;
484
485 /* Zero turns the feature off */
486 if (threshold == 0) {
487 if (lis->flags & LIS302DL_F_IRQ_WAKE) {
488 disable_irq_wake(lis->pdata->interrupt);
489 lis->flags &= ~LIS302DL_F_IRQ_WAKE;
490 }
491
492 return count;
493 }
494
495 lis->wakeup.threshold = threshold;
496
497 if (!(lis->flags & LIS302DL_F_IRQ_WAKE)) {
498 enable_irq_wake(lis->pdata->interrupt);
499 lis->flags |= LIS302DL_F_IRQ_WAKE;
500 }
501
502 return count;
503 }
504
505 static ssize_t show_wakeup_threshold(struct device *dev,
506 struct device_attribute *attr, char *buf)
507 {
508 struct lis302dl_info *lis = dev_get_drvdata(dev);
509
510 /* All events off? */
511 if (lis->wakeup.threshold == 0)
512 return sprintf(buf, "off\n");
513
514 return sprintf(buf, "%u\n", lis->wakeup.threshold);
515 }
516
517 static DEVICE_ATTR(wakeup_threshold, S_IRUGO | S_IWUSR, show_wakeup_threshold,
518 set_wakeup_threshold);
519
520 static ssize_t set_wakeup_duration(struct device *dev,
521 struct device_attribute *attr, const char *buf, size_t count)
522 {
523 struct lis302dl_info *lis = dev_get_drvdata(dev);
524 unsigned int duration;
525
526 if (sscanf(buf, "%u\n", &duration) != 1)
527 return -EINVAL;
528
529 if (duration > 2550)
530 return -ERANGE;
531
532 lis->wakeup.duration = duration;
533
534 return count;
535 }
536
537 static ssize_t show_wakeup_duration(struct device *dev,
538 struct device_attribute *attr, char *buf)
539 {
540 struct lis302dl_info *lis = dev_get_drvdata(dev);
541
542 return sprintf(buf, "%u\n", lis->wakeup.duration);
543 }
544
545 static DEVICE_ATTR(wakeup_duration, S_IRUGO | S_IWUSR, show_wakeup_duration,
546 set_wakeup_duration);
547
548 static struct attribute *lis302dl_sysfs_entries[] = {
549 &dev_attr_sample_rate.attr,
550 &dev_attr_full_scale.attr,
551 &dev_attr_threshold.attr,
552 &dev_attr_duration.attr,
553 &dev_attr_dump.attr,
554 &dev_attr_wakeup_threshold.attr,
555 &dev_attr_wakeup_duration.attr,
556 &dev_attr_overruns.attr,
557 NULL
558 };
559
560 static struct attribute_group lis302dl_attr_group = {
561 .name = NULL,
562 .attrs = lis302dl_sysfs_entries,
563 };
564
565 /* input device handling and driver core interaction */
566
567 static int lis302dl_input_open(struct input_dev *inp)
568 {
569 struct lis302dl_info *lis = input_get_drvdata(inp);
570 unsigned long flags;
571
572 local_irq_save(flags);
573
574 __enable_data_collection(lis);
575 lis->flags |= LIS302DL_F_INPUT_OPEN;
576
577 local_irq_restore(flags);
578
579 return 0;
580 }
581
582 static void lis302dl_input_close(struct input_dev *inp)
583 {
584 struct lis302dl_info *lis = input_get_drvdata(inp);
585 u_int8_t ctrl1 = LIS302DL_CTRL1_Xen | LIS302DL_CTRL1_Yen |
586 LIS302DL_CTRL1_Zen;
587 unsigned long flags;
588
589 local_irq_save(flags);
590
591 /* since the input core already serializes access and makes sure we
592 * only see close() for the close of the last user, we can safely
593 * disable the data ready events */
594 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, 0x00);
595 lis->flags &= ~LIS302DL_F_INPUT_OPEN;
596
597 /* however, don't power down the whole device if still needed */
598 if (!(lis->flags & LIS302DL_F_WUP_FF ||
599 lis->flags & LIS302DL_F_WUP_CLICK)) {
600 lis_reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
601 0x00);
602 }
603 local_irq_restore(flags);
604 }
605
606 /* get the device to reload its coefficients from EEPROM and wait for it
607 * to complete
608 */
609
610 static int __lis302dl_reset_device(struct lis302dl_info *lis)
611 {
612 int timeout = 10;
613
614 lis_reg_write(lis, LIS302DL_REG_CTRL2,
615 LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS);
616
617 while ((lis_reg_read(lis, LIS302DL_REG_CTRL2)
618 & LIS302DL_CTRL2_BOOT) && (timeout--))
619 mdelay(1);
620
621 return !!(timeout < 0);
622 }
623
624 static int __devinit lis302dl_probe(struct spi_device *spi)
625 {
626 int rc;
627 struct lis302dl_info *lis;
628 u_int8_t wai;
629 unsigned long flags;
630 struct lis302dl_platform_data *pdata = spi->dev.platform_data;
631
632 spi->mode = SPI_MODE_3;
633 rc = spi_setup(spi);
634 if (rc < 0) {
635 dev_err(&spi->dev, "spi_setup failed\n");
636 return rc;
637 }
638
639 lis = kzalloc(sizeof(*lis), GFP_KERNEL);
640 if (!lis)
641 return -ENOMEM;
642
643 lis->dev = &spi->dev;
644 lis->spi = spi;
645
646 dev_set_drvdata(lis->dev, lis);
647
648 lis->pdata = pdata;
649
650 rc = sysfs_create_group(&lis->dev->kobj, &lis302dl_attr_group);
651 if (rc) {
652 dev_err(lis->dev, "error creating sysfs group\n");
653 goto bail_free_lis;
654 }
655
656 /* initialize input layer details */
657 lis->input_dev = input_allocate_device();
658 if (!lis->input_dev) {
659 dev_err(lis->dev, "Unable to allocate input device\n");
660 goto bail_sysfs;
661 }
662
663 input_set_drvdata(lis->input_dev, lis);
664 lis->input_dev->name = pdata->name;
665 /* SPI Bus not defined as a valid bus for input subsystem*/
666 lis->input_dev->id.bustype = BUS_I2C; /* lie about it */
667 lis->input_dev->open = lis302dl_input_open;
668 lis->input_dev->close = lis302dl_input_close;
669
670 rc = input_register_device(lis->input_dev);
671 if (rc) {
672 dev_err(lis->dev, "error %d registering input device\n", rc);
673 goto bail_inp_dev;
674 }
675
676 local_irq_save(flags);
677 /* Configure our IO */
678 (lis->pdata->lis302dl_suspend_io)(lis, 1);
679
680 wai = lis_reg_read(lis, LIS302DL_REG_WHO_AM_I);
681 if (wai != LIS302DL_WHO_AM_I_MAGIC) {
682 dev_err(lis->dev, "unknown who_am_i signature 0x%02x\n", wai);
683 dev_set_drvdata(lis->dev, NULL);
684 rc = -ENODEV;
685 local_irq_restore(flags);
686 goto bail_inp_reg;
687 }
688
689 set_bit(EV_ABS, lis->input_dev->evbit);
690 input_set_abs_params(lis->input_dev, ABS_X, 0, 0, 0, 0);
691 input_set_abs_params(lis->input_dev, ABS_Y, 0, 0, 0, 0);
692 input_set_abs_params(lis->input_dev, ABS_Z, 0, 0, 0, 0);
693
694 lis->threshold = 0;
695 lis->duration = 0;
696 memset(&lis->wakeup, 0, sizeof(lis->wakeup));
697
698 if (__lis302dl_reset_device(lis))
699 dev_err(lis->dev, "device BOOT reload failed\n");
700
701 /* force us powered */
702 lis_reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD |
703 LIS302DL_CTRL1_Xen |
704 LIS302DL_CTRL1_Yen |
705 LIS302DL_CTRL1_Zen);
706 mdelay(1);
707
708 lis_reg_write(lis, LIS302DL_REG_CTRL2, 0);
709 lis_reg_write(lis, LIS302DL_REG_CTRL3,
710 LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
711 lis_reg_write(lis, LIS302DL_REG_FF_WU_THS_1, 0x0);
712 lis_reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0x00);
713 lis_reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, 0x0);
714
715 /* start off in powered down mode; we power up when someone opens us */
716 lis_reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_Xen |
717 LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen);
718
719 if (pdata->open_drain)
720 /* switch interrupt to open collector, active-low */
721 lis_reg_write(lis, LIS302DL_REG_CTRL3,
722 LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
723 else
724 /* push-pull, active-low */
725 lis_reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL);
726
727 lis302dl_set_int_mode(lis->dev, 1, LIS302DL_INTMODE_GND);
728 lis302dl_set_int_mode(lis->dev, 2, LIS302DL_INTMODE_GND);
729
730 lis_reg_read(lis, LIS302DL_REG_STATUS);
731 lis_reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
732 lis_reg_read(lis, LIS302DL_REG_FF_WU_SRC_2);
733 lis_reg_read(lis, LIS302DL_REG_CLICK_SRC);
734 local_irq_restore(flags);
735
736 dev_info(lis->dev, "Found %s\n", pdata->name);
737
738 lis->pdata = pdata;
739
740 INIT_WORK(&lis->work, lis302dl_irq_worker);
741
742 set_irq_handler(lis->pdata->interrupt, handle_level_irq);
743 set_irq_type(lis->pdata->interrupt, IRQ_TYPE_LEVEL_LOW);
744 rc = request_irq(lis->pdata->interrupt, lis302dl_interrupt,
745 IRQF_TRIGGER_FALLING, "lis302dl", lis);
746
747 if (rc < 0) {
748 dev_err(lis->dev, "error requesting IRQ %d\n",
749 lis->pdata->interrupt);
750 goto bail_inp_reg;
751 }
752 return 0;
753
754 bail_inp_reg:
755 input_unregister_device(lis->input_dev);
756 bail_inp_dev:
757 input_free_device(lis->input_dev);
758 bail_sysfs:
759 sysfs_remove_group(&lis->dev->kobj, &lis302dl_attr_group);
760 bail_free_lis:
761 kfree(lis);
762 return rc;
763 }
764
765 static int __devexit lis302dl_remove(struct spi_device *spi)
766 {
767 struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
768 unsigned long flags;
769
770 /* Disable interrupts */
771 if (lis->flags & LIS302DL_F_IRQ_WAKE)
772 disable_irq_wake(lis->pdata->interrupt);
773 free_irq(lis->pdata->interrupt, lis);
774
775 /* Reset and power down the device */
776 local_irq_save(flags);
777 lis_reg_write(lis, LIS302DL_REG_CTRL3, 0x00);
778 lis_reg_write(lis, LIS302DL_REG_CTRL2, 0x00);
779 lis_reg_write(lis, LIS302DL_REG_CTRL1, 0x00);
780 local_irq_restore(flags);
781
782 /* Cleanup resources */
783 sysfs_remove_group(&spi->dev.kobj, &lis302dl_attr_group);
784 input_unregister_device(lis->input_dev);
785 if (lis->input_dev)
786 input_free_device(lis->input_dev);
787 dev_set_drvdata(lis->dev, NULL);
788 kfree(lis);
789
790 return 0;
791 }
792
793 #ifdef CONFIG_PM
794
795 static uint8_t regs_to_save[] = {
796 LIS302DL_REG_CTRL1,
797 LIS302DL_REG_CTRL2,
798 LIS302DL_REG_CTRL3,
799 LIS302DL_REG_FF_WU_CFG_1,
800 LIS302DL_REG_FF_WU_THS_1,
801 LIS302DL_REG_FF_WU_DURATION_1,
802 LIS302DL_REG_FF_WU_CFG_2,
803 LIS302DL_REG_FF_WU_THS_2,
804 LIS302DL_REG_FF_WU_DURATION_2,
805 LIS302DL_REG_CLICK_CFG,
806 LIS302DL_REG_CLICK_THSY_X,
807 LIS302DL_REG_CLICK_THSZ,
808 LIS302DL_REG_CLICK_TIME_LIMIT,
809 LIS302DL_REG_CLICK_LATENCY,
810 LIS302DL_REG_CLICK_WINDOW,
811
812 };
813
814 static int lis302dl_suspend(struct spi_device *spi, pm_message_t state)
815 {
816 struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
817 unsigned long flags;
818 u_int8_t tmp;
819 int n;
820
821 /* determine if we want to wake up from the accel. */
822 if (lis->flags & LIS302DL_F_WUP_CLICK)
823 return 0;
824
825 disable_irq(lis->pdata->interrupt);
826 local_irq_save(flags);
827
828 /*
829 * When we share SPI over multiple sensors, there is a race here
830 * that one or more sensors will lose. In that case, the shared
831 * SPI bus GPIO will be in sleep mode and partially pulled down. So
832 * we explicitly put our IO into "wake" mode here before the final
833 * traffic to the sensor.
834 */
835 (lis->pdata->lis302dl_suspend_io)(lis, 1);
836
837 /* save registers */
838 for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
839 lis->regs[regs_to_save[n]] =
840 lis_reg_read(lis, regs_to_save[n]);
841
842 /* power down or enable wakeup */
843
844 if (lis->wakeup.threshold == 0) {
845 tmp = lis_reg_read(lis, LIS302DL_REG_CTRL1);
846 tmp &= ~LIS302DL_CTRL1_PD;
847 lis_reg_write(lis, LIS302DL_REG_CTRL1, tmp);
848 } else
849 __enable_wakeup(lis);
850
851 /* place our IO to the device in sleep-compatible states */
852 (lis->pdata->lis302dl_suspend_io)(lis, 0);
853
854 local_irq_restore(flags);
855
856 return 0;
857 }
858
859 static int lis302dl_resume(struct spi_device *spi)
860 {
861 struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
862 unsigned long flags;
863 int n;
864
865 if (lis->flags & LIS302DL_F_WUP_CLICK)
866 return 0;
867
868 local_irq_save(flags);
869
870 /* get our IO to the device back in operational states */
871 (lis->pdata->lis302dl_suspend_io)(lis, 1);
872
873 /* resume from powerdown first! */
874 lis_reg_write(lis, LIS302DL_REG_CTRL1,
875 LIS302DL_CTRL1_PD |
876 LIS302DL_CTRL1_Xen |
877 LIS302DL_CTRL1_Yen |
878 LIS302DL_CTRL1_Zen);
879 mdelay(1);
880
881 if (__lis302dl_reset_device(lis))
882 dev_err(&spi->dev, "device BOOT reload failed\n");
883
884 lis->regs[LIS302DL_REG_CTRL1] |= LIS302DL_CTRL1_PD |
885 LIS302DL_CTRL1_Xen |
886 LIS302DL_CTRL1_Yen |
887 LIS302DL_CTRL1_Zen;
888
889 /* restore registers after resume */
890 for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
891 lis_reg_write(lis, regs_to_save[n], lis->regs[regs_to_save[n]]);
892
893 /* if someone had us open, reset the non-wake threshold stuff */
894 if (lis->flags & LIS302DL_F_INPUT_OPEN)
895 __enable_data_collection(lis);
896
897 local_irq_restore(flags);
898 enable_irq(lis->pdata->interrupt);
899
900 return 0;
901 }
902 #else
903 #define lis302dl_suspend NULL
904 #define lis302dl_resume NULL
905 #endif
906
907 static struct spi_driver lis302dl_spi_driver = {
908 .driver = {
909 .name = "lis302dl",
910 .owner = THIS_MODULE,
911 },
912
913 .probe = lis302dl_probe,
914 .remove = __devexit_p(lis302dl_remove),
915 .suspend = lis302dl_suspend,
916 .resume = lis302dl_resume,
917 };
918
919 static int __devinit lis302dl_init(void)
920 {
921 return spi_register_driver(&lis302dl_spi_driver);
922 }
923 module_init(lis302dl_init);
924
925 static void __exit lis302dl_exit(void)
926 {
927 spi_unregister_driver(&lis302dl_spi_driver);
928 }
929 module_exit(lis302dl_exit);
930
931 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
932 MODULE_LICENSE("GPL");
Yousong Zhou staging tree