fix-pm-gsm-disable-serial-drive-when-off.patch
[kernel.git] / 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
44 #include <linux/lis302dl.h>
45
46 /* Utility functions */
47
48 static u8 __reg_read(struct lis302dl_info *lis, u8 reg)
49 {
50         return (lis->pdata->lis302dl_bitbang_reg_read)(lis, reg);
51 }
52
53 static void __reg_write(struct lis302dl_info *lis, u8 reg, u8 val)
54 {
55         (lis->pdata->lis302dl_bitbang_reg_write)(lis, reg, val);
56 }
57
58 static void __reg_set_bit_mask(struct lis302dl_info *lis, u8 reg, u8 mask,
59                 u8 val)
60 {
61         u_int8_t tmp;
62
63         val &= mask;
64
65         tmp = __reg_read(lis, reg);
66         tmp &= ~mask;
67         tmp |= val;
68         __reg_write(lis, reg, tmp);
69 }
70
71 static int __ms_to_duration(struct lis302dl_info *lis, int ms)
72 {
73         /* If we have 400 ms sampling rate, the stepping is 2.5 ms,
74          * on 100 ms the stepping is 10ms */
75         if (lis->flags & LIS302DL_F_DR)
76                 return min((ms * 10) / 25, 637);
77
78         return min(ms / 10, 2550);
79 }
80
81 static int __duration_to_ms(struct lis302dl_info *lis, int duration)
82 {
83         if (lis->flags & LIS302DL_F_DR)
84                 return (duration * 25) / 10;
85
86         return duration * 10;
87 }
88
89 static u8 __mg_to_threshold(struct lis302dl_info *lis, int mg)
90 {
91         /* If FS is set each bit is 71mg, otherwise 18mg. The THS register
92          * has 7 bits for the threshold value */
93         if (lis->flags & LIS302DL_F_FS)
94                 return min(mg / 71, 127);
95
96         return min(mg / 18, 127);
97 }
98
99 static int __threshold_to_mg(struct lis302dl_info *lis, u8 threshold)
100 {
101         if (lis->flags & LIS302DL_F_FS)
102                 return threshold * 71;
103
104         return threshold * 18;
105 }
106
107 /* interrupt handling related */
108
109 enum lis302dl_intmode {
110         LIS302DL_INTMODE_GND            = 0x00,
111         LIS302DL_INTMODE_FF_WU_1        = 0x01,
112         LIS302DL_INTMODE_FF_WU_2        = 0x02,
113         LIS302DL_INTMODE_FF_WU_12       = 0x03,
114         LIS302DL_INTMODE_DATA_READY     = 0x04,
115         LIS302DL_INTMODE_CLICK          = 0x07,
116 };
117
118
119 static void __lis302dl_int_mode(struct device *dev, int int_pin,
120                               enum lis302dl_intmode mode)
121 {
122         struct lis302dl_info *lis = dev_get_drvdata(dev);
123
124         switch (int_pin) {
125         case 1:
126                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x07, mode);
127                 break;
128         case 2:
129                 __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         /* First zero to get to a known state */
139         __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
140                         lis->wakeup.cfg);
141         __reg_write(lis, LIS302DL_REG_FF_WU_THS_1,
142                         lis->wakeup.threshold);
143         __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
144                         lis->wakeup.duration);
145
146         /* Route the interrupt for wakeup */
147         __lis302dl_int_mode(lis->dev, 1,
148                         LIS302DL_INTMODE_FF_WU_1);
149
150         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD);
151 }
152
153 static void __enable_data_collection(struct lis302dl_info *lis)
154 {
155         u_int8_t ctrl1 = LIS302DL_CTRL1_PD | LIS302DL_CTRL1_Xen |
156                          LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen;
157
158         /* make sure we're powered up and generate data ready */
159         __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1);
160
161         /* If the threshold is zero, let the device generated an interrupt
162          * on each datum */
163         if (lis->threshold == 0) {
164                 __reg_write(lis, LIS302DL_REG_CTRL2, 0);
165                 __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_DATA_READY);
166                 __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_DATA_READY);
167         } else {
168                 __reg_write(lis, LIS302DL_REG_CTRL2,
169                                 LIS302DL_CTRL2_HPFF1);
170                 __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, lis->threshold);
171                 __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, lis->duration);
172
173                 /* Clear the HP filter "starting point" */
174                 __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
175                 __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
176                                 LIS302DL_FFWUCFG_XHIE | LIS302DL_FFWUCFG_YHIE |
177                                 LIS302DL_FFWUCFG_ZHIE);
178                 __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_FF_WU_12);
179                 __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_FF_WU_12);
180         }
181 }
182
183 #if 0
184 static void _report_btn_single(struct input_dev *inp, int btn)
185 {
186         input_report_key(inp, btn, 1);
187         input_sync(inp);
188         input_report_key(inp, btn, 0);
189 }
190
191 static void _report_btn_double(struct input_dev *inp, int btn)
192 {
193         input_report_key(inp, btn, 1);
194         input_sync(inp);
195         input_report_key(inp, btn, 0);
196         input_sync(inp);
197         input_report_key(inp, btn, 1);
198         input_sync(inp);
199         input_report_key(inp, btn, 0);
200 }
201 #endif
202
203
204 static void lis302dl_bitbang_read_sample(struct lis302dl_info *lis)
205 {
206         u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */
207         u8 read[5];
208         unsigned long flags;
209         int mg_per_sample;
210
211         local_irq_save(flags);
212         mg_per_sample = __threshold_to_mg(lis, 1);
213
214         (lis->pdata->lis302dl_bitbang)(lis, &data, 1, &read[0], 5);
215
216         local_irq_restore(flags);
217
218         input_report_rel(lis->input_dev, REL_X, mg_per_sample * (s8)read[0]);
219         input_report_rel(lis->input_dev, REL_Y, mg_per_sample * (s8)read[2]);
220         input_report_rel(lis->input_dev, REL_Z, mg_per_sample * (s8)read[4]);
221
222         input_sync(lis->input_dev);
223
224         /* Reset the HP filter */
225         __reg_read(lis, LIS302DL_REG_HP_FILTER_RESET);
226 }
227
228 static irqreturn_t lis302dl_interrupt(int irq, void *_lis)
229 {
230         struct lis302dl_info *lis = _lis;
231
232         lis302dl_bitbang_read_sample(lis);
233         return IRQ_HANDLED;
234 }
235
236 /* sysfs */
237
238 static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
239                          char *buf)
240 {
241         struct lis302dl_info *lis = dev_get_drvdata(dev);
242         u8 ctrl1;
243         unsigned long flags;
244
245         local_irq_save(flags);
246         ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1);
247         local_irq_restore(flags);
248
249         return sprintf(buf, "%d\n", ctrl1 & LIS302DL_CTRL1_DR ? 400 : 100);
250 }
251
252 static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
253                         const char *buf, size_t count)
254 {
255         struct lis302dl_info *lis = dev_get_drvdata(dev);
256         unsigned long flags;
257         int duration_ms = __duration_to_ms(lis, lis->duration);
258
259         local_irq_save(flags);
260
261         if (!strcmp(buf, "400\n")) {
262                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
263                                  LIS302DL_CTRL1_DR);
264                 lis->flags |= LIS302DL_F_DR;
265         } else {
266                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
267                                 0);
268                 lis->flags &= ~LIS302DL_F_DR;
269         }
270         lis->duration = __ms_to_duration(lis, duration_ms);
271         local_irq_restore(flags);
272
273         return count;
274 }
275
276 static DEVICE_ATTR(sample_rate, S_IRUGO | S_IWUSR, show_rate, set_rate);
277
278 static ssize_t show_scale(struct device *dev, struct device_attribute *attr,
279                           char *buf)
280 {
281         struct lis302dl_info *lis = dev_get_drvdata(dev);
282         u_int8_t ctrl1;
283         unsigned long flags;
284
285         local_irq_save(flags);
286         ctrl1 = __reg_read(lis, LIS302DL_REG_CTRL1);
287         local_irq_restore(flags);
288
289         return sprintf(buf, "%s\n", ctrl1 & LIS302DL_CTRL1_FS ? "9.2" : "2.3");
290 }
291
292 static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
293                          const char *buf, size_t count)
294 {
295         struct lis302dl_info *lis = dev_get_drvdata(dev);
296         unsigned long flags;
297         int threshold_mg = __threshold_to_mg(lis, lis->threshold);
298
299         local_irq_save(flags);
300
301         if (!strcmp(buf, "9.2\n")) {
302                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
303                                  LIS302DL_CTRL1_FS);
304                 lis->flags |= LIS302DL_F_FS;
305         } else {
306                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
307                                 0);
308                 lis->flags &= ~LIS302DL_F_FS;
309         }
310
311         /* Adjust the threshold */
312         lis->threshold = __mg_to_threshold(lis, threshold_mg);
313         if (lis->flags & LIS302DL_F_INPUT_OPEN)
314                 __enable_data_collection(lis);
315
316         local_irq_restore(flags);
317
318         return count;
319 }
320
321 static DEVICE_ATTR(full_scale, S_IRUGO | S_IWUSR, show_scale, set_scale);
322
323 static ssize_t show_threshold(struct device *dev, struct device_attribute *attr,
324                  char *buf)
325 {
326         struct lis302dl_info *lis = dev_get_drvdata(dev);
327
328         return sprintf(buf, "%d\n", __threshold_to_mg(lis, lis->threshold));
329 }
330
331 static ssize_t set_threshold(struct device *dev, struct device_attribute *attr,
332                  const char *buf, size_t count)
333 {
334         struct lis302dl_info *lis = dev_get_drvdata(dev);
335         u32 val;
336
337         if (sscanf(buf, "%d\n", &val) != 1)
338                 return -EINVAL;
339         /* 8g is the maximum if FS is 1 */
340         if (val < 0 || val > 8000)
341                 return -ERANGE;
342
343         /* Set the threshold and write it out if the device is used */
344         lis->threshold = __mg_to_threshold(lis, val);
345
346         if (lis->flags & LIS302DL_F_INPUT_OPEN) {
347                 unsigned long flags;
348
349                 local_irq_save(flags);
350                 __enable_data_collection(lis);
351                 local_irq_restore(flags);
352         }
353
354         return count;
355 }
356
357 static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR, show_threshold, set_threshold);
358
359 static ssize_t show_duration(struct device *dev, struct device_attribute *attr,
360                  char *buf)
361 {
362         struct lis302dl_info *lis = dev_get_drvdata(dev);
363
364         return sprintf(buf, "%d\n", __duration_to_ms(lis, lis->duration));
365 }
366
367 static ssize_t set_duration(struct device *dev, struct device_attribute *attr,
368                  const char *buf, size_t count)
369 {
370         struct lis302dl_info *lis = dev_get_drvdata(dev);
371         u32 val;
372
373         if (sscanf(buf, "%d\n", &val) != 1)
374                 return -EINVAL;
375         if (val < 0 || val > 2550)
376                 return -ERANGE;
377
378         lis->duration = __ms_to_duration(lis, val);
379         if (lis->flags & LIS302DL_F_INPUT_OPEN)
380                 __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, lis->duration);
381
382         return count;
383 }
384
385 static DEVICE_ATTR(duration, S_IRUGO | S_IWUSR, show_duration, set_duration);
386
387 static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
388                                                                       char *buf)
389 {
390         struct lis302dl_info *lis = dev_get_drvdata(dev);
391         int n = 0;
392         u8 reg[0x40];
393         char *end = buf;
394         unsigned long flags;
395
396         local_irq_save(flags);
397
398         for (n = 0; n < sizeof(reg); n++)
399                 reg[n] = __reg_read(lis, n);
400
401         local_irq_restore(flags);
402
403         for (n = 0; n < sizeof(reg); n += 16) {
404                 hex_dump_to_buffer(reg + n, 16, 16, 1, end, 128, 0);
405                 end += strlen(end);
406                 *end++ = '\n';
407                 *end++ = '\0';
408         }
409
410         return end - buf;
411 }
412 static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL);
413
414 /* Configure freefall/wakeup interrupts */
415 static ssize_t set_wakeup(struct device *dev, struct device_attribute *attr,
416                          const char *buf, size_t count)
417 {
418         struct lis302dl_info *lis = dev_get_drvdata(dev);
419         u_int8_t x_lo, y_lo, z_lo;
420         u_int8_t x_hi, y_hi, z_hi;
421         int duration, threshold, and_events;
422         int x, y, z;
423
424         /* Zero turns the feature off */
425         if (strcmp(buf, "0\n") == 0) {
426                 lis->wakeup.active = 0;
427
428                 if (lis->flags & LIS302DL_F_IRQ_WAKE) {
429                         disable_irq_wake(lis->pdata->interrupt);
430                         lis->flags &= ~LIS302DL_F_IRQ_WAKE;
431                 }
432
433                 return count;
434         }
435
436         if (sscanf(buf, "%d %d %d %d %d %d", &x, &y, &z, &threshold, &duration,
437                         &and_events) != 6)
438                 return -EINVAL;
439
440         if (duration < 0 || duration > 2550 ||
441                         threshold < 0 || threshold > 8000)
442                 return -ERANGE;
443
444         /* Interrupt flags */
445         x_lo = x < 0 ? LIS302DL_FFWUCFG_XLIE : 0;
446         y_lo = y < 0 ? LIS302DL_FFWUCFG_YLIE : 0;
447         z_lo = z < 0 ? LIS302DL_FFWUCFG_ZLIE : 0;
448         x_hi = x > 0 ? LIS302DL_FFWUCFG_XHIE : 0;
449         y_hi = y > 0 ? LIS302DL_FFWUCFG_YHIE : 0;
450         z_hi = z > 0 ? LIS302DL_FFWUCFG_ZHIE : 0;
451
452         lis->wakeup.duration = __ms_to_duration(lis, duration);
453         lis->wakeup.threshold = __mg_to_threshold(lis, threshold);
454         lis->wakeup.cfg = (and_events ? LIS302DL_FFWUCFG_AOI : 0) |
455                 x_lo | x_hi | y_lo | y_hi | z_lo | z_hi;
456
457         if (!(lis->flags & LIS302DL_F_IRQ_WAKE)) {
458                 enable_irq_wake(lis->pdata->interrupt);
459                 lis->flags |= LIS302DL_F_IRQ_WAKE;
460         }
461         lis->wakeup.active = 1;
462
463         return count;
464 }
465
466 static ssize_t show_wakeup(struct device *dev,
467                 struct device_attribute *attr, char *buf)
468 {
469         struct lis302dl_info *lis = dev_get_drvdata(dev);
470         u8 config;
471
472         /* All events off? */
473         if (!lis->wakeup.active)
474                 return sprintf(buf, "off\n");
475
476         config = lis->wakeup.cfg;
477
478         return sprintf(buf,
479                         "%s events, duration %d, threshold %d, "
480                         "enabled: %s %s %s %s %s %s\n",
481                         (config & LIS302DL_FFWUCFG_AOI) == 0 ? "or" : "and",
482                         __duration_to_ms(lis, lis->wakeup.duration),
483                         __threshold_to_mg(lis, lis->wakeup.threshold),
484                         (config & LIS302DL_FFWUCFG_XLIE) == 0 ? "---" : "xlo",
485                         (config & LIS302DL_FFWUCFG_XHIE) == 0 ? "---" : "xhi",
486                         (config & LIS302DL_FFWUCFG_YLIE) == 0 ? "---" : "ylo",
487                         (config & LIS302DL_FFWUCFG_YHIE) == 0 ? "---" : "yhi",
488                         (config & LIS302DL_FFWUCFG_ZLIE) == 0 ? "---" : "zlo",
489                         (config & LIS302DL_FFWUCFG_ZHIE) == 0 ? "---" : "zhi");
490 }
491
492 static DEVICE_ATTR(wakeup, S_IRUGO | S_IWUSR, show_wakeup, set_wakeup);
493
494 static struct attribute *lis302dl_sysfs_entries[] = {
495         &dev_attr_sample_rate.attr,
496         &dev_attr_full_scale.attr,
497         &dev_attr_threshold.attr,
498         &dev_attr_duration.attr,
499         &dev_attr_dump.attr,
500         &dev_attr_wakeup.attr,
501         NULL
502 };
503
504 static struct attribute_group lis302dl_attr_group = {
505         .name   = NULL,
506         .attrs  = lis302dl_sysfs_entries,
507 };
508
509 /* input device handling and driver core interaction */
510 static int lis302dl_input_open(struct input_dev *inp)
511 {
512         struct lis302dl_info *lis = inp->private;
513         unsigned long flags;
514
515         local_irq_save(flags);
516
517         __enable_data_collection(lis);
518         lis->flags |= LIS302DL_F_INPUT_OPEN;
519
520         /* kick it off -- since we are edge triggered, if we missed the edge
521          * permanent low interrupt is death for us */
522         lis302dl_bitbang_read_sample(lis);
523
524         local_irq_restore(flags);
525
526         return 0;
527 }
528
529 static void lis302dl_input_close(struct input_dev *inp)
530 {
531         struct lis302dl_info *lis = inp->private;
532         u_int8_t ctrl1 = LIS302DL_CTRL1_Xen | LIS302DL_CTRL1_Yen |
533                          LIS302DL_CTRL1_Zen;
534         unsigned long flags;
535
536         local_irq_save(flags);
537
538         /* since the input core already serializes access and makes sure we
539          * only see close() for the close of the last user, we can safely
540          * disable the data ready events */
541         __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, 0x00);
542         lis->flags &= ~LIS302DL_F_INPUT_OPEN;
543
544         /* however, don't power down the whole device if still needed */
545         if (!(lis->flags & LIS302DL_F_WUP_FF ||
546               lis->flags & LIS302DL_F_WUP_CLICK)) {
547                 __reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
548                                  0x00);
549         }
550         local_irq_restore(flags);
551 }
552
553 /* get the device to reload its coefficients from EEPROM and wait for it
554  * to complete
555  */
556
557 static int __lis302dl_reset_device(struct lis302dl_info *lis)
558 {
559         int timeout = 10;
560
561         __reg_write(lis, LIS302DL_REG_CTRL2,
562                         LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS);
563
564         while ((__reg_read(lis, LIS302DL_REG_CTRL2)
565                         & LIS302DL_CTRL2_BOOT) && (timeout--))
566                 mdelay(1);
567
568         return !!(timeout < 0);
569 }
570
571 static int __devinit lis302dl_probe(struct platform_device *pdev)
572 {
573         int rc;
574         struct lis302dl_info *lis;
575         u_int8_t wai;
576         unsigned long flags;
577         struct lis302dl_platform_data *pdata = pdev->dev.platform_data;
578
579         lis = kzalloc(sizeof(*lis), GFP_KERNEL);
580         if (!lis)
581                 return -ENOMEM;
582
583         local_irq_save(flags);
584
585         lis->dev = &pdev->dev;
586
587         dev_set_drvdata(lis->dev, lis);
588
589         lis->pdata = pdata;
590
591         /* Configure our IO */
592         (lis->pdata->lis302dl_suspend_io)(lis, 1);
593
594         wai = __reg_read(lis, LIS302DL_REG_WHO_AM_I);
595         if (wai != LIS302DL_WHO_AM_I_MAGIC) {
596                 dev_err(lis->dev, "unknown who_am_i signature 0x%02x\n", wai);
597                 dev_set_drvdata(lis->dev, NULL);
598                 rc = -ENODEV;
599                 goto bail_free_lis;
600         }
601
602         rc = sysfs_create_group(&lis->dev->kobj, &lis302dl_attr_group);
603         if (rc) {
604                 dev_err(lis->dev, "error creating sysfs group\n");
605                 goto bail_free_lis;
606         }
607
608         /* initialize input layer details */
609         lis->input_dev = input_allocate_device();
610         if (!lis->input_dev) {
611                 dev_err(lis->dev, "Unable to allocate input device\n");
612                 goto bail_sysfs;
613         }
614
615         set_bit(EV_REL, lis->input_dev->evbit);
616         set_bit(REL_X, lis->input_dev->relbit);
617         set_bit(REL_Y, lis->input_dev->relbit);
618         set_bit(REL_Z, lis->input_dev->relbit);
619 /*      set_bit(EV_KEY, lis->input_dev->evbit);
620         set_bit(BTN_X, lis->input_dev->keybit);
621         set_bit(BTN_Y, lis->input_dev->keybit);
622         set_bit(BTN_Z, lis->input_dev->keybit);
623 */
624         lis->threshold = 1;
625         lis->duration = 0;
626         memset(&lis->wakeup, 0, sizeof(lis->wakeup));
627
628         lis->input_dev->private = lis;
629         lis->input_dev->name = pdata->name;
630          /* SPI Bus not defined as a valid bus for input subsystem*/
631         lis->input_dev->id.bustype = BUS_I2C; /* lie about it */
632         lis->input_dev->open = lis302dl_input_open;
633         lis->input_dev->close = lis302dl_input_close;
634
635         rc = input_register_device(lis->input_dev);
636         if (rc) {
637                 dev_err(lis->dev, "error %d registering input device\n", rc);
638                 goto bail_inp_dev;
639         }
640
641         if (__lis302dl_reset_device(lis))
642                 dev_err(lis->dev, "device BOOT reload failed\n");
643
644         /* force us powered */
645         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD |
646                         LIS302DL_CTRL1_Xen |
647                         LIS302DL_CTRL1_Yen |
648                         LIS302DL_CTRL1_Zen);
649         mdelay(1);
650
651         __reg_write(lis, LIS302DL_REG_CTRL2, 0);
652         __reg_write(lis, LIS302DL_REG_CTRL3,
653                         LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
654         __reg_write(lis, LIS302DL_REG_FF_WU_THS_1, 0x0);
655         __reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0x00);
656         __reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, 0x0);
657
658         /* start off in powered down mode; we power up when someone opens us */
659         __reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_Xen |
660                         LIS302DL_CTRL1_Yen | LIS302DL_CTRL1_Zen);
661
662         if (pdata->open_drain)
663                 /* switch interrupt to open collector, active-low */
664                 __reg_write(lis, LIS302DL_REG_CTRL3,
665                                 LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
666         else
667                 /* push-pull, active-low */
668                 __reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL);
669
670         __lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_GND);
671         __lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_GND);
672
673         __reg_read(lis, LIS302DL_REG_STATUS);
674         __reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
675         __reg_read(lis, LIS302DL_REG_FF_WU_SRC_2);
676         __reg_read(lis, LIS302DL_REG_CLICK_SRC);
677
678         dev_info(lis->dev, "Found %s\n", pdata->name);
679
680         lis->pdata = pdata;
681
682         rc = request_irq(pdata->interrupt, lis302dl_interrupt,
683                          IRQF_TRIGGER_FALLING, "lis302dl", lis);
684         if (rc < 0) {
685                 dev_err(lis->dev, "error requesting IRQ %d\n",
686                         lis->pdata->interrupt);
687                 goto bail_inp_reg;
688         }
689         local_irq_restore(flags);
690         return 0;
691
692 bail_inp_reg:
693         input_unregister_device(lis->input_dev);
694 bail_inp_dev:
695         input_free_device(lis->input_dev);
696 bail_sysfs:
697         sysfs_remove_group(&lis->dev->kobj, &lis302dl_attr_group);
698 bail_free_lis:
699         kfree(lis);
700         local_irq_restore(flags);
701         return rc;
702 }
703
704 static int __devexit lis302dl_remove(struct platform_device *pdev)
705 {
706         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
707         unsigned long flags;
708
709         /* Reset and power down the device */
710         local_irq_save(flags);
711         __reg_write(lis, LIS302DL_REG_CTRL3, 0x00);
712         __reg_write(lis, LIS302DL_REG_CTRL2, 0x00);
713         __reg_write(lis, LIS302DL_REG_CTRL1, 0x00);
714         local_irq_restore(flags);
715
716         /* Cleanup resources */
717         free_irq(lis->pdata->interrupt, lis);
718         sysfs_remove_group(&pdev->dev.kobj, &lis302dl_attr_group);
719         input_unregister_device(lis->input_dev);
720         if (lis->input_dev)
721                 input_free_device(lis->input_dev);
722         dev_set_drvdata(lis->dev, NULL);
723         kfree(lis);
724
725         return 0;
726 }
727
728 #ifdef CONFIG_PM
729
730 static u8 regs_to_save[] = {
731         LIS302DL_REG_CTRL1,
732         LIS302DL_REG_CTRL2,
733         LIS302DL_REG_CTRL3,
734         LIS302DL_REG_FF_WU_CFG_1,
735         LIS302DL_REG_FF_WU_THS_1,
736         LIS302DL_REG_FF_WU_DURATION_1,
737         LIS302DL_REG_FF_WU_CFG_2,
738         LIS302DL_REG_FF_WU_THS_2,
739         LIS302DL_REG_FF_WU_DURATION_2,
740         LIS302DL_REG_CLICK_CFG,
741         LIS302DL_REG_CLICK_THSY_X,
742         LIS302DL_REG_CLICK_THSZ,
743         LIS302DL_REG_CLICK_TIME_LIMIT,
744         LIS302DL_REG_CLICK_LATENCY,
745         LIS302DL_REG_CLICK_WINDOW,
746
747 };
748
749 static int lis302dl_suspend(struct platform_device *pdev, pm_message_t state)
750 {
751         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
752         unsigned long flags;
753         u_int8_t tmp;
754         int n;
755
756         /* determine if we want to wake up from the accel. */
757         if (lis->flags & LIS302DL_F_WUP_CLICK)
758                 return 0;
759
760         disable_irq(lis->pdata->interrupt);
761         local_irq_save(flags);
762
763         /*
764          * When we share SPI over multiple sensors, there is a race here
765          * that one or more sensors will lose.  In that case, the shared
766          * SPI bus GPIO will be in sleep mode and partially pulled down.  So
767          * we explicitly put our IO into "wake" mode here before the final
768          * traffic to the sensor.
769          */
770         (lis->pdata->lis302dl_suspend_io)(lis, 1);
771
772         /* save registers */
773         for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
774                 lis->regs[regs_to_save[n]] =
775                         __reg_read(lis, regs_to_save[n]);
776
777         /* power down or enable wakeup */
778         if (!lis->wakeup.active) {
779                 tmp = __reg_read(lis, LIS302DL_REG_CTRL1);
780                 tmp &= ~LIS302DL_CTRL1_PD;
781                 __reg_write(lis, LIS302DL_REG_CTRL1, tmp);
782         } else
783                 __enable_wakeup(lis);
784
785         /* place our IO to the device in sleep-compatible states */
786         (lis->pdata->lis302dl_suspend_io)(lis, 0);
787
788         local_irq_restore(flags);
789
790         return 0;
791 }
792
793 static int lis302dl_resume(struct platform_device *pdev)
794 {
795         struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
796         unsigned long flags;
797         int n;
798
799         if (lis->flags & LIS302DL_F_WUP_CLICK)
800                 return 0;
801
802         local_irq_save(flags);
803
804         /* get our IO to the device back in operational states */
805         (lis->pdata->lis302dl_suspend_io)(lis, 1);
806
807         /* resume from powerdown first! */
808         __reg_write(lis, LIS302DL_REG_CTRL1,
809                         LIS302DL_CTRL1_PD |
810                         LIS302DL_CTRL1_Xen |
811                         LIS302DL_CTRL1_Yen |
812                         LIS302DL_CTRL1_Zen);
813         mdelay(1);
814
815         if (__lis302dl_reset_device(lis))
816                 dev_err(&pdev->dev, "device BOOT reload failed\n");
817
818         lis->regs[LIS302DL_REG_CTRL1] |=        LIS302DL_CTRL1_PD |
819                                                 LIS302DL_CTRL1_Xen |
820                                                 LIS302DL_CTRL1_Yen |
821                                                 LIS302DL_CTRL1_Zen;
822
823         /* restore registers after resume */
824         for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
825                 __reg_write(lis, regs_to_save[n], lis->regs[regs_to_save[n]]);
826
827         local_irq_restore(flags);
828         enable_irq(lis->pdata->interrupt);
829
830         return 0;
831 }
832 #else
833 #define lis302dl_suspend        NULL
834 #define lis302dl_resume         NULL
835 #endif
836
837 static struct platform_driver lis302dl_driver = {
838         .driver = {
839                 .name   = "lis302dl",
840                 .owner  = THIS_MODULE,
841         },
842
843         .probe   = lis302dl_probe,
844         .remove  = __devexit_p(lis302dl_remove),
845         .suspend = lis302dl_suspend,
846         .resume  = lis302dl_resume,
847 };
848
849 static int __devinit lis302dl_init(void)
850 {
851         return platform_driver_register(&lis302dl_driver);
852 }
853
854 static void __exit lis302dl_exit(void)
855 {
856         platform_driver_unregister(&lis302dl_driver);
857 }
858
859 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
860 MODULE_LICENSE("GPL");
861
862 module_init(lis302dl_init);
863 module_exit(lis302dl_exit);