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