1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/hwmon.h>
21#include <linux/init.h>
22#include <linux/err.h>
23#include <linux/delay.h>
24#include <linux/input.h>
25#include <linux/interrupt.h>
26#include <linux/slab.h>
27#include <linux/gpio.h>
28#include <linux/spi/spi.h>
29#include <linux/spi/ads7846.h>
30#include <asm/irq.h>
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54#define TS_POLL_DELAY (1 * 1000000)
55#define TS_POLL_PERIOD (5 * 1000000)
56
57
58#define SAMPLE_BITS (8 + 16 + 2 )
59
60struct ts_event {
61
62
63
64
65
66 u16 x;
67 u16 y;
68 u16 z1, z2;
69 int ignore;
70};
71
72
73
74
75
76
77struct ads7846_packet {
78 u8 read_x, read_y, read_z1, read_z2, pwrdown;
79 u16 dummy;
80 struct ts_event tc;
81};
82
83struct ads7846 {
84 struct input_dev *input;
85 char phys[32];
86 char name[32];
87
88 struct spi_device *spi;
89
90#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
91 struct attribute_group *attr_group;
92 struct device *hwmon;
93#endif
94
95 u16 model;
96 u16 vref_mv;
97 u16 vref_delay_usecs;
98 u16 x_plate_ohms;
99 u16 pressure_max;
100
101 bool swap_xy;
102
103 struct ads7846_packet *packet;
104
105 struct spi_transfer xfer[18];
106 struct spi_message msg[5];
107 struct spi_message *last_msg;
108 int msg_idx;
109 int read_cnt;
110 int read_rep;
111 int last_read;
112
113 u16 debounce_max;
114 u16 debounce_tol;
115 u16 debounce_rep;
116
117 u16 penirq_recheck_delay_usecs;
118
119 spinlock_t lock;
120 struct hrtimer timer;
121 unsigned pendown:1;
122 unsigned pending:1;
123
124 unsigned irq_disabled:1;
125 unsigned disabled:1;
126 unsigned is_suspended:1;
127
128 int (*filter)(void *data, int data_idx, int *val);
129 void *filter_data;
130 void (*filter_cleanup)(void *data);
131 int (*get_pendown_state)(void);
132 int gpio_pendown;
133
134 void (*wait_for_sync)(void);
135};
136
137
138#if 0
139#define CS_CHANGE(xfer) ((xfer).cs_change = 1)
140#else
141#define CS_CHANGE(xfer) ((xfer).cs_change = 0)
142#endif
143
144
145
146
147
148
149#define ADS_START (1 << 7)
150#define ADS_A2A1A0_d_y (1 << 4)
151#define ADS_A2A1A0_d_z1 (3 << 4)
152#define ADS_A2A1A0_d_z2 (4 << 4)
153#define ADS_A2A1A0_d_x (5 << 4)
154#define ADS_A2A1A0_temp0 (0 << 4)
155#define ADS_A2A1A0_vbatt (2 << 4)
156#define ADS_A2A1A0_vaux (6 << 4)
157#define ADS_A2A1A0_temp1 (7 << 4)
158#define ADS_8_BIT (1 << 3)
159#define ADS_12_BIT (0 << 3)
160#define ADS_SER (1 << 2)
161#define ADS_DFR (0 << 2)
162#define ADS_PD10_PDOWN (0 << 0)
163#define ADS_PD10_ADC_ON (1 << 0)
164#define ADS_PD10_REF_ON (2 << 0)
165#define ADS_PD10_ALL_ON (3 << 0)
166
167#define MAX_12BIT ((1<<12)-1)
168
169
170#define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
171 | ADS_12_BIT | ADS_DFR | \
172 (adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
173
174#define READ_Y(vref) (READ_12BIT_DFR(y, 1, vref))
175#define READ_Z1(vref) (READ_12BIT_DFR(z1, 1, vref))
176#define READ_Z2(vref) (READ_12BIT_DFR(z2, 1, vref))
177
178#define READ_X(vref) (READ_12BIT_DFR(x, 1, vref))
179#define PWRDOWN (READ_12BIT_DFR(y, 0, 0))
180
181
182
183
184#define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
185 | ADS_12_BIT | ADS_SER)
186
187#define REF_ON (READ_12BIT_DFR(x, 1, 1))
188#define REF_OFF (READ_12BIT_DFR(y, 0, 0))
189
190
191
192
193
194
195
196
197
198struct ser_req {
199 u8 ref_on;
200 u8 command;
201 u8 ref_off;
202 u16 scratch;
203 __be16 sample;
204 struct spi_message msg;
205 struct spi_transfer xfer[6];
206};
207
208static void ads7846_enable(struct ads7846 *ts);
209static void ads7846_disable(struct ads7846 *ts);
210
211static int device_suspended(struct device *dev)
212{
213 struct ads7846 *ts = dev_get_drvdata(dev);
214 return ts->is_suspended || ts->disabled;
215}
216
217static int ads7846_read12_ser(struct device *dev, unsigned command)
218{
219 struct spi_device *spi = to_spi_device(dev);
220 struct ads7846 *ts = dev_get_drvdata(dev);
221 struct ser_req *req = kzalloc(sizeof *req, GFP_KERNEL);
222 int status;
223 int use_internal;
224
225 if (!req)
226 return -ENOMEM;
227
228 spi_message_init(&req->msg);
229
230
231 use_internal = (ts->model == 7846);
232
233
234 if (use_internal) {
235 req->ref_on = REF_ON;
236 req->xfer[0].tx_buf = &req->ref_on;
237 req->xfer[0].len = 1;
238 spi_message_add_tail(&req->xfer[0], &req->msg);
239
240 req->xfer[1].rx_buf = &req->scratch;
241 req->xfer[1].len = 2;
242
243
244 req->xfer[1].delay_usecs = ts->vref_delay_usecs;
245 spi_message_add_tail(&req->xfer[1], &req->msg);
246 }
247
248
249 req->command = (u8) command;
250 req->xfer[2].tx_buf = &req->command;
251 req->xfer[2].len = 1;
252 spi_message_add_tail(&req->xfer[2], &req->msg);
253
254 req->xfer[3].rx_buf = &req->sample;
255 req->xfer[3].len = 2;
256 spi_message_add_tail(&req->xfer[3], &req->msg);
257
258
259
260
261 req->ref_off = PWRDOWN;
262 req->xfer[4].tx_buf = &req->ref_off;
263 req->xfer[4].len = 1;
264 spi_message_add_tail(&req->xfer[4], &req->msg);
265
266 req->xfer[5].rx_buf = &req->scratch;
267 req->xfer[5].len = 2;
268 CS_CHANGE(req->xfer[5]);
269 spi_message_add_tail(&req->xfer[5], &req->msg);
270
271 ts->irq_disabled = 1;
272 disable_irq(spi->irq);
273 status = spi_sync(spi, &req->msg);
274 ts->irq_disabled = 0;
275 enable_irq(spi->irq);
276
277 if (status == 0) {
278
279 status = be16_to_cpu(req->sample);
280 status = status >> 3;
281 status &= 0x0fff;
282 }
283
284 kfree(req);
285 return status;
286}
287
288#if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
289
290#define SHOW(name, var, adjust) static ssize_t \
291name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
292{ \
293 struct ads7846 *ts = dev_get_drvdata(dev); \
294 ssize_t v = ads7846_read12_ser(dev, \
295 READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \
296 if (v < 0) \
297 return v; \
298 return sprintf(buf, "%u\n", adjust(ts, v)); \
299} \
300static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
301
302
303
304
305
306
307
308static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
309{
310 return v;
311}
312
313SHOW(temp0, temp0, null_adjust)
314SHOW(temp1, temp1, null_adjust)
315
316
317
318
319
320
321static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
322{
323 unsigned retval = v;
324
325
326 retval *= ts->vref_mv;
327 retval = retval >> 12;
328 return retval;
329}
330
331static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
332{
333 unsigned retval = vaux_adjust(ts, v);
334
335
336 if (ts->model == 7846)
337 retval *= 4;
338 return retval;
339}
340
341SHOW(in0_input, vaux, vaux_adjust)
342SHOW(in1_input, vbatt, vbatt_adjust)
343
344
345static struct attribute *ads7846_attributes[] = {
346 &dev_attr_temp0.attr,
347 &dev_attr_temp1.attr,
348 &dev_attr_in0_input.attr,
349 &dev_attr_in1_input.attr,
350 NULL,
351};
352
353static struct attribute_group ads7846_attr_group = {
354 .attrs = ads7846_attributes,
355};
356
357static struct attribute *ads7843_attributes[] = {
358 &dev_attr_in0_input.attr,
359 &dev_attr_in1_input.attr,
360 NULL,
361};
362
363static struct attribute_group ads7843_attr_group = {
364 .attrs = ads7843_attributes,
365};
366
367static struct attribute *ads7845_attributes[] = {
368 &dev_attr_in0_input.attr,
369 NULL,
370};
371
372static struct attribute_group ads7845_attr_group = {
373 .attrs = ads7845_attributes,
374};
375
376static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
377{
378 struct device *hwmon;
379 int err;
380
381
382 switch (ts->model) {
383 case 7846:
384 if (!ts->vref_mv) {
385 dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
386 ts->vref_mv = 2500;
387 }
388 break;
389 case 7845:
390 case 7843:
391 if (!ts->vref_mv) {
392 dev_warn(&spi->dev,
393 "external vREF for ADS%d not specified\n",
394 ts->model);
395 return 0;
396 }
397 break;
398 }
399
400
401 switch (ts->model) {
402 case 7846:
403 ts->attr_group = &ads7846_attr_group;
404 break;
405 case 7845:
406 ts->attr_group = &ads7845_attr_group;
407 break;
408 case 7843:
409 ts->attr_group = &ads7843_attr_group;
410 break;
411 default:
412 dev_dbg(&spi->dev, "ADS%d not recognized\n", ts->model);
413 return 0;
414 }
415
416 err = sysfs_create_group(&spi->dev.kobj, ts->attr_group);
417 if (err)
418 return err;
419
420 hwmon = hwmon_device_register(&spi->dev);
421 if (IS_ERR(hwmon)) {
422 sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
423 return PTR_ERR(hwmon);
424 }
425
426 ts->hwmon = hwmon;
427 return 0;
428}
429
430static void ads784x_hwmon_unregister(struct spi_device *spi,
431 struct ads7846 *ts)
432{
433 if (ts->hwmon) {
434 sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
435 hwmon_device_unregister(ts->hwmon);
436 }
437}
438
439#else
440static inline int ads784x_hwmon_register(struct spi_device *spi,
441 struct ads7846 *ts)
442{
443 return 0;
444}
445
446static inline void ads784x_hwmon_unregister(struct spi_device *spi,
447 struct ads7846 *ts)
448{
449}
450#endif
451
452static int is_pen_down(struct device *dev)
453{
454 struct ads7846 *ts = dev_get_drvdata(dev);
455
456 return ts->pendown;
457}
458
459static ssize_t ads7846_pen_down_show(struct device *dev,
460 struct device_attribute *attr, char *buf)
461{
462 return sprintf(buf, "%u\n", is_pen_down(dev));
463}
464
465static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
466
467static ssize_t ads7846_disable_show(struct device *dev,
468 struct device_attribute *attr, char *buf)
469{
470 struct ads7846 *ts = dev_get_drvdata(dev);
471
472 return sprintf(buf, "%u\n", ts->disabled);
473}
474
475static ssize_t ads7846_disable_store(struct device *dev,
476 struct device_attribute *attr,
477 const char *buf, size_t count)
478{
479 struct ads7846 *ts = dev_get_drvdata(dev);
480 unsigned long i;
481
482 if (strict_strtoul(buf, 10, &i))
483 return -EINVAL;
484
485 spin_lock_irq(&ts->lock);
486
487 if (i)
488 ads7846_disable(ts);
489 else
490 ads7846_enable(ts);
491
492 spin_unlock_irq(&ts->lock);
493
494 return count;
495}
496
497static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
498
499static struct attribute *ads784x_attributes[] = {
500 &dev_attr_pen_down.attr,
501 &dev_attr_disable.attr,
502 NULL,
503};
504
505static struct attribute_group ads784x_attr_group = {
506 .attrs = ads784x_attributes,
507};
508
509
510
511static int get_pendown_state(struct ads7846 *ts)
512{
513 if (ts->get_pendown_state)
514 return ts->get_pendown_state();
515
516 return !gpio_get_value(ts->gpio_pendown);
517}
518
519static void null_wait_for_sync(void)
520{
521}
522
523
524
525
526
527
528
529
530
531static void ads7846_rx(void *ads)
532{
533 struct ads7846 *ts = ads;
534 struct ads7846_packet *packet = ts->packet;
535 unsigned Rt;
536 u16 x, y, z1, z2;
537
538
539
540
541 x = packet->tc.x;
542 y = packet->tc.y;
543 z1 = packet->tc.z1;
544 z2 = packet->tc.z2;
545
546
547 if (x == MAX_12BIT)
548 x = 0;
549
550 if (ts->model == 7843) {
551 Rt = ts->pressure_max / 2;
552 } else if (likely(x && z1)) {
553
554 Rt = z2;
555 Rt -= z1;
556 Rt *= x;
557 Rt *= ts->x_plate_ohms;
558 Rt /= z1;
559 Rt = (Rt + 2047) >> 12;
560 } else {
561 Rt = 0;
562 }
563
564
565
566
567
568 if (packet->tc.ignore || Rt > ts->pressure_max) {
569#ifdef VERBOSE
570 pr_debug("%s: ignored %d pressure %d\n",
571 dev_name(&ts->spi->dev), packet->tc.ignore, Rt);
572#endif
573 hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
574 HRTIMER_MODE_REL);
575 return;
576 }
577
578
579
580
581 if (ts->penirq_recheck_delay_usecs) {
582 udelay(ts->penirq_recheck_delay_usecs);
583 if (!get_pendown_state(ts))
584 Rt = 0;
585 }
586
587
588
589
590
591
592
593
594
595 if (Rt) {
596 struct input_dev *input = ts->input;
597
598 if (!ts->pendown) {
599 input_report_key(input, BTN_TOUCH, 1);
600 ts->pendown = 1;
601#ifdef VERBOSE
602 dev_dbg(&ts->spi->dev, "DOWN\n");
603#endif
604 }
605
606 if (ts->swap_xy)
607 swap(x, y);
608
609 input_report_abs(input, ABS_X, x);
610 input_report_abs(input, ABS_Y, y);
611 input_report_abs(input, ABS_PRESSURE, Rt);
612
613 input_sync(input);
614#ifdef VERBOSE
615 dev_dbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
616#endif
617 }
618
619 hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
620 HRTIMER_MODE_REL);
621}
622
623static int ads7846_debounce(void *ads, int data_idx, int *val)
624{
625 struct ads7846 *ts = ads;
626
627 if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
628
629 ts->read_rep = 0;
630
631
632 if (ts->read_cnt < ts->debounce_max) {
633 ts->last_read = *val;
634 ts->read_cnt++;
635 return ADS7846_FILTER_REPEAT;
636 } else {
637
638
639
640
641
642 ts->read_cnt = 0;
643 return ADS7846_FILTER_IGNORE;
644 }
645 } else {
646 if (++ts->read_rep > ts->debounce_rep) {
647
648
649 ts->read_cnt = 0;
650 ts->read_rep = 0;
651 return ADS7846_FILTER_OK;
652 } else {
653
654 ts->read_cnt++;
655 return ADS7846_FILTER_REPEAT;
656 }
657 }
658}
659
660static int ads7846_no_filter(void *ads, int data_idx, int *val)
661{
662 return ADS7846_FILTER_OK;
663}
664
665static void ads7846_rx_val(void *ads)
666{
667 struct ads7846 *ts = ads;
668 struct ads7846_packet *packet = ts->packet;
669 struct spi_message *m;
670 struct spi_transfer *t;
671 int val;
672 int action;
673 int status;
674
675 m = &ts->msg[ts->msg_idx];
676 t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
677
678
679
680
681 val = be16_to_cpup((__be16 *)t->rx_buf) >> 3;
682
683 action = ts->filter(ts->filter_data, ts->msg_idx, &val);
684 switch (action) {
685 case ADS7846_FILTER_REPEAT:
686 break;
687 case ADS7846_FILTER_IGNORE:
688 packet->tc.ignore = 1;
689
690
691
692 m = ts->last_msg;
693 break;
694 case ADS7846_FILTER_OK:
695 *(u16 *)t->rx_buf = val;
696 packet->tc.ignore = 0;
697 m = &ts->msg[++ts->msg_idx];
698 break;
699 default:
700 BUG();
701 }
702 ts->wait_for_sync();
703 status = spi_async(ts->spi, m);
704 if (status)
705 dev_err(&ts->spi->dev, "spi_async --> %d\n",
706 status);
707}
708
709static enum hrtimer_restart ads7846_timer(struct hrtimer *handle)
710{
711 struct ads7846 *ts = container_of(handle, struct ads7846, timer);
712 int status = 0;
713
714 spin_lock(&ts->lock);
715
716 if (unlikely(!get_pendown_state(ts) ||
717 device_suspended(&ts->spi->dev))) {
718 if (ts->pendown) {
719 struct input_dev *input = ts->input;
720
721 input_report_key(input, BTN_TOUCH, 0);
722 input_report_abs(input, ABS_PRESSURE, 0);
723 input_sync(input);
724
725 ts->pendown = 0;
726#ifdef VERBOSE
727 dev_dbg(&ts->spi->dev, "UP\n");
728#endif
729 }
730
731
732 if (!device_suspended(&ts->spi->dev)) {
733 ts->irq_disabled = 0;
734 enable_irq(ts->spi->irq);
735 }
736 ts->pending = 0;
737 } else {
738
739 ts->msg_idx = 0;
740 ts->wait_for_sync();
741 status = spi_async(ts->spi, &ts->msg[0]);
742 if (status)
743 dev_err(&ts->spi->dev, "spi_async --> %d\n", status);
744 }
745
746 spin_unlock(&ts->lock);
747 return HRTIMER_NORESTART;
748}
749
750static irqreturn_t ads7846_irq(int irq, void *handle)
751{
752 struct ads7846 *ts = handle;
753 unsigned long flags;
754
755 spin_lock_irqsave(&ts->lock, flags);
756 if (likely(get_pendown_state(ts))) {
757 if (!ts->irq_disabled) {
758
759
760
761
762
763 ts->irq_disabled = 1;
764 disable_irq_nosync(ts->spi->irq);
765 ts->pending = 1;
766 hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),
767 HRTIMER_MODE_REL);
768 }
769 }
770 spin_unlock_irqrestore(&ts->lock, flags);
771
772 return IRQ_HANDLED;
773}
774
775
776
777
778static void ads7846_disable(struct ads7846 *ts)
779{
780 if (ts->disabled)
781 return;
782
783 ts->disabled = 1;
784
785
786 if (!ts->pending) {
787 ts->irq_disabled = 1;
788 disable_irq(ts->spi->irq);
789 } else {
790
791
792
793 while (ts->pending) {
794 spin_unlock_irq(&ts->lock);
795 msleep(1);
796 spin_lock_irq(&ts->lock);
797 }
798 }
799
800
801
802
803}
804
805
806static void ads7846_enable(struct ads7846 *ts)
807{
808 if (!ts->disabled)
809 return;
810
811 ts->disabled = 0;
812 ts->irq_disabled = 0;
813 enable_irq(ts->spi->irq);
814}
815
816static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
817{
818 struct ads7846 *ts = dev_get_drvdata(&spi->dev);
819
820 spin_lock_irq(&ts->lock);
821
822 ts->is_suspended = 1;
823 ads7846_disable(ts);
824
825 spin_unlock_irq(&ts->lock);
826
827 return 0;
828
829}
830
831static int ads7846_resume(struct spi_device *spi)
832{
833 struct ads7846 *ts = dev_get_drvdata(&spi->dev);
834
835 spin_lock_irq(&ts->lock);
836
837 ts->is_suspended = 0;
838 ads7846_enable(ts);
839
840 spin_unlock_irq(&ts->lock);
841
842 return 0;
843}
844
845static int __devinit setup_pendown(struct spi_device *spi, struct ads7846 *ts)
846{
847 struct ads7846_platform_data *pdata = spi->dev.platform_data;
848 int err;
849
850
851
852
853
854 if (!pdata->get_pendown_state && !gpio_is_valid(pdata->gpio_pendown)) {
855 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
856 return -EINVAL;
857 }
858
859 if (pdata->get_pendown_state) {
860 ts->get_pendown_state = pdata->get_pendown_state;
861 return 0;
862 }
863
864 err = gpio_request(pdata->gpio_pendown, "ads7846_pendown");
865 if (err) {
866 dev_err(&spi->dev, "failed to request pendown GPIO%d\n",
867 pdata->gpio_pendown);
868 return err;
869 }
870
871 ts->gpio_pendown = pdata->gpio_pendown;
872 return 0;
873}
874
875static int __devinit ads7846_probe(struct spi_device *spi)
876{
877 struct ads7846 *ts;
878 struct ads7846_packet *packet;
879 struct input_dev *input_dev;
880 struct ads7846_platform_data *pdata = spi->dev.platform_data;
881 struct spi_message *m;
882 struct spi_transfer *x;
883 int vref;
884 int err;
885
886 if (!spi->irq) {
887 dev_dbg(&spi->dev, "no IRQ?\n");
888 return -ENODEV;
889 }
890
891 if (!pdata) {
892 dev_dbg(&spi->dev, "no platform data?\n");
893 return -ENODEV;
894 }
895
896
897 if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
898 dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
899 (spi->max_speed_hz/SAMPLE_BITS)/1000);
900 return -EINVAL;
901 }
902
903
904
905
906
907 spi->bits_per_word = 8;
908 spi->mode = SPI_MODE_0;
909 err = spi_setup(spi);
910 if (err < 0)
911 return err;
912
913 ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
914 packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
915 input_dev = input_allocate_device();
916 if (!ts || !packet || !input_dev) {
917 err = -ENOMEM;
918 goto err_free_mem;
919 }
920
921 dev_set_drvdata(&spi->dev, ts);
922
923 ts->packet = packet;
924 ts->spi = spi;
925 ts->input = input_dev;
926 ts->vref_mv = pdata->vref_mv;
927 ts->swap_xy = pdata->swap_xy;
928
929 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
930 ts->timer.function = ads7846_timer;
931
932 spin_lock_init(&ts->lock);
933
934 ts->model = pdata->model ? : 7846;
935 ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
936 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
937 ts->pressure_max = pdata->pressure_max ? : ~0;
938
939 if (pdata->filter != NULL) {
940 if (pdata->filter_init != NULL) {
941 err = pdata->filter_init(pdata, &ts->filter_data);
942 if (err < 0)
943 goto err_free_mem;
944 }
945 ts->filter = pdata->filter;
946 ts->filter_cleanup = pdata->filter_cleanup;
947 } else if (pdata->debounce_max) {
948 ts->debounce_max = pdata->debounce_max;
949 if (ts->debounce_max < 2)
950 ts->debounce_max = 2;
951 ts->debounce_tol = pdata->debounce_tol;
952 ts->debounce_rep = pdata->debounce_rep;
953 ts->filter = ads7846_debounce;
954 ts->filter_data = ts;
955 } else
956 ts->filter = ads7846_no_filter;
957
958 err = setup_pendown(spi, ts);
959 if (err)
960 goto err_cleanup_filter;
961
962 if (pdata->penirq_recheck_delay_usecs)
963 ts->penirq_recheck_delay_usecs =
964 pdata->penirq_recheck_delay_usecs;
965
966 ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
967
968 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
969 snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
970
971 input_dev->name = ts->name;
972 input_dev->phys = ts->phys;
973 input_dev->dev.parent = &spi->dev;
974
975 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
976 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
977 input_set_abs_params(input_dev, ABS_X,
978 pdata->x_min ? : 0,
979 pdata->x_max ? : MAX_12BIT,
980 0, 0);
981 input_set_abs_params(input_dev, ABS_Y,
982 pdata->y_min ? : 0,
983 pdata->y_max ? : MAX_12BIT,
984 0, 0);
985 input_set_abs_params(input_dev, ABS_PRESSURE,
986 pdata->pressure_min, pdata->pressure_max, 0, 0);
987
988 vref = pdata->keep_vref_on;
989
990
991
992
993 m = &ts->msg[0];
994 x = ts->xfer;
995
996 spi_message_init(m);
997
998
999 packet->read_y = READ_Y(vref);
1000 x->tx_buf = &packet->read_y;
1001 x->len = 1;
1002 spi_message_add_tail(x, m);
1003
1004 x++;
1005 x->rx_buf = &packet->tc.y;
1006 x->len = 2;
1007 spi_message_add_tail(x, m);
1008
1009
1010
1011
1012
1013 if (pdata->settle_delay_usecs) {
1014 x->delay_usecs = pdata->settle_delay_usecs;
1015
1016 x++;
1017 x->tx_buf = &packet->read_y;
1018 x->len = 1;
1019 spi_message_add_tail(x, m);
1020
1021 x++;
1022 x->rx_buf = &packet->tc.y;
1023 x->len = 2;
1024 spi_message_add_tail(x, m);
1025 }
1026
1027 m->complete = ads7846_rx_val;
1028 m->context = ts;
1029
1030 m++;
1031 spi_message_init(m);
1032
1033
1034 x++;
1035 packet->read_x = READ_X(vref);
1036 x->tx_buf = &packet->read_x;
1037 x->len = 1;
1038 spi_message_add_tail(x, m);
1039
1040 x++;
1041 x->rx_buf = &packet->tc.x;
1042 x->len = 2;
1043 spi_message_add_tail(x, m);
1044
1045
1046 if (pdata->settle_delay_usecs) {
1047 x->delay_usecs = pdata->settle_delay_usecs;
1048
1049 x++;
1050 x->tx_buf = &packet->read_x;
1051 x->len = 1;
1052 spi_message_add_tail(x, m);
1053
1054 x++;
1055 x->rx_buf = &packet->tc.x;
1056 x->len = 2;
1057 spi_message_add_tail(x, m);
1058 }
1059
1060 m->complete = ads7846_rx_val;
1061 m->context = ts;
1062
1063
1064 if (ts->model == 7846) {
1065 m++;
1066 spi_message_init(m);
1067
1068 x++;
1069 packet->read_z1 = READ_Z1(vref);
1070 x->tx_buf = &packet->read_z1;
1071 x->len = 1;
1072 spi_message_add_tail(x, m);
1073
1074 x++;
1075 x->rx_buf = &packet->tc.z1;
1076 x->len = 2;
1077 spi_message_add_tail(x, m);
1078
1079
1080 if (pdata->settle_delay_usecs) {
1081 x->delay_usecs = pdata->settle_delay_usecs;
1082
1083 x++;
1084 x->tx_buf = &packet->read_z1;
1085 x->len = 1;
1086 spi_message_add_tail(x, m);
1087
1088 x++;
1089 x->rx_buf = &packet->tc.z1;
1090 x->len = 2;
1091 spi_message_add_tail(x, m);
1092 }
1093
1094 m->complete = ads7846_rx_val;
1095 m->context = ts;
1096
1097 m++;
1098 spi_message_init(m);
1099
1100 x++;
1101 packet->read_z2 = READ_Z2(vref);
1102 x->tx_buf = &packet->read_z2;
1103 x->len = 1;
1104 spi_message_add_tail(x, m);
1105
1106 x++;
1107 x->rx_buf = &packet->tc.z2;
1108 x->len = 2;
1109 spi_message_add_tail(x, m);
1110
1111
1112 if (pdata->settle_delay_usecs) {
1113 x->delay_usecs = pdata->settle_delay_usecs;
1114
1115 x++;
1116 x->tx_buf = &packet->read_z2;
1117 x->len = 1;
1118 spi_message_add_tail(x, m);
1119
1120 x++;
1121 x->rx_buf = &packet->tc.z2;
1122 x->len = 2;
1123 spi_message_add_tail(x, m);
1124 }
1125
1126 m->complete = ads7846_rx_val;
1127 m->context = ts;
1128 }
1129
1130
1131 m++;
1132 spi_message_init(m);
1133
1134 x++;
1135 packet->pwrdown = PWRDOWN;
1136 x->tx_buf = &packet->pwrdown;
1137 x->len = 1;
1138 spi_message_add_tail(x, m);
1139
1140 x++;
1141 x->rx_buf = &packet->dummy;
1142 x->len = 2;
1143 CS_CHANGE(*x);
1144 spi_message_add_tail(x, m);
1145
1146 m->complete = ads7846_rx;
1147 m->context = ts;
1148
1149 ts->last_msg = m;
1150
1151 if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
1152 spi->dev.driver->name, ts)) {
1153 dev_info(&spi->dev,
1154 "trying pin change workaround on irq %d\n", spi->irq);
1155 err = request_irq(spi->irq, ads7846_irq,
1156 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
1157 spi->dev.driver->name, ts);
1158 if (err) {
1159 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
1160 goto err_free_gpio;
1161 }
1162 }
1163
1164 err = ads784x_hwmon_register(spi, ts);
1165 if (err)
1166 goto err_free_irq;
1167
1168 dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
1169
1170
1171
1172
1173 (void) ads7846_read12_ser(&spi->dev,
1174 READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
1175
1176 err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
1177 if (err)
1178 goto err_remove_hwmon;
1179
1180 err = input_register_device(input_dev);
1181 if (err)
1182 goto err_remove_attr_group;
1183
1184 return 0;
1185
1186 err_remove_attr_group:
1187 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1188 err_remove_hwmon:
1189 ads784x_hwmon_unregister(spi, ts);
1190 err_free_irq:
1191 free_irq(spi->irq, ts);
1192 err_free_gpio:
1193 if (ts->gpio_pendown != -1)
1194 gpio_free(ts->gpio_pendown);
1195 err_cleanup_filter:
1196 if (ts->filter_cleanup)
1197 ts->filter_cleanup(ts->filter_data);
1198 err_free_mem:
1199 input_free_device(input_dev);
1200 kfree(packet);
1201 kfree(ts);
1202 return err;
1203}
1204
1205static int __devexit ads7846_remove(struct spi_device *spi)
1206{
1207 struct ads7846 *ts = dev_get_drvdata(&spi->dev);
1208
1209 ads784x_hwmon_unregister(spi, ts);
1210 input_unregister_device(ts->input);
1211
1212 ads7846_suspend(spi, PMSG_SUSPEND);
1213
1214 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
1215
1216 free_irq(ts->spi->irq, ts);
1217
1218 enable_irq(ts->spi->irq);
1219
1220 if (ts->gpio_pendown != -1)
1221 gpio_free(ts->gpio_pendown);
1222
1223 if (ts->filter_cleanup)
1224 ts->filter_cleanup(ts->filter_data);
1225
1226 kfree(ts->packet);
1227 kfree(ts);
1228
1229 dev_dbg(&spi->dev, "unregistered touchscreen\n");
1230 return 0;
1231}
1232
1233static struct spi_driver ads7846_driver = {
1234 .driver = {
1235 .name = "ads7846",
1236 .bus = &spi_bus_type,
1237 .owner = THIS_MODULE,
1238 },
1239 .probe = ads7846_probe,
1240 .remove = __devexit_p(ads7846_remove),
1241 .suspend = ads7846_suspend,
1242 .resume = ads7846_resume,
1243};
1244
1245static int __init ads7846_init(void)
1246{
1247 return spi_register_driver(&ads7846_driver);
1248}
1249module_init(ads7846_init);
1250
1251static void __exit ads7846_exit(void)
1252{
1253 spi_unregister_driver(&ads7846_driver);
1254}
1255module_exit(ads7846_exit);
1256
1257MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1258MODULE_LICENSE("GPL");
1259MODULE_ALIAS("spi:ads7846");
1260