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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive