[package] busybox: implement ms static routes option in udhcpc (#6435)
[openwrt.git] / 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 */
48 static 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
72 static 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
90 static 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
103 static 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
113 static 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
121 static 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
131 static 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
141 enum 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
150 static 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
167 static 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
194 static 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
227 static 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
234 static 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
247 static 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
303 static 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
313 static 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
321 static DEVICE_ATTR(overruns, S_IRUGO, show_overruns, NULL);
322
323 static 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
337 static 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
359 static DEVICE_ATTR(sample_rate, S_IRUGO | S_IWUSR, show_rate, set_rate);
360
361 static 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
375 static 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
401 static DEVICE_ATTR(full_scale, S_IRUGO | S_IWUSR, show_scale, set_scale);
402
403 static 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
413 static 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
439 static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR, show_threshold, set_threshold);
440
441 static 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
450 static 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
469 static DEVICE_ATTR(duration, S_IRUGO | S_IWUSR, show_duration, set_duration);
470
471 static 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 }
496 static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL);
497
498 /* Configure freefall/wakeup interrupts */
499 static 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
531 static 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
543 static DEVICE_ATTR(wakeup_threshold, S_IRUGO | S_IWUSR, show_wakeup_threshold,
544 set_wakeup_threshold);
545
546 static 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
563 static 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
571 static DEVICE_ATTR(wakeup_duration, S_IRUGO | S_IWUSR, show_wakeup_duration,
572 set_wakeup_duration);
573
574 static 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
586 static 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
593 static 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
608 static 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
636 static 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
650 static 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
778 bail_inp_reg:
779 input_unregister_device(lis->input_dev);
780 bail_inp_dev:
781 input_free_device(lis->input_dev);
782 bail_sysfs:
783 sysfs_remove_group(&lis->dev->kobj, &lis302dl_attr_group);
784 bail_free_lis:
785 kfree(lis);
786 return rc;
787 }
788
789 static 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
819 static 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
838 static 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
883 static 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
931 static 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
943 static int __devinit lis302dl_init(void)
944 {
945 return spi_register_driver(&lis302dl_spi_driver);
946 }
947
948 static void __exit lis302dl_exit(void)
949 {
950 spi_unregister_driver(&lis302dl_spi_driver);
951 }
952
953 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
954 MODULE_LICENSE("GPL");
955
956 module_init(lis302dl_init);
957 module_exit(lis302dl_exit);
This page took 0.116574 seconds and 5 git commands to generate.