?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit
[linux-ginger.git] / drivers / spi / tsc210x.c
blob1d2ac94084c477590d151a38fe96c3f2090ea56c
1 /*
2 * tsc210x.c - TSC2101/2102/... driver core
3 *
4 * Copyright (c) 2005-2007 Andrzej Zaborowski <balrog@zabor.org>
5 *
6 * This package is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This package is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this package; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/errno.h>
24 #include <linux/platform_device.h>
25 #include <linux/suspend.h>
26 #include <linux/interrupt.h>
27 #include <linux/clk.h>
28 #include <linux/err.h>
29 #include <linux/mutex.h>
30 #include <linux/workqueue.h>
31 #include <linux/completion.h>
32 #include <linux/autoconf.h>
33 #include <linux/spi/spi.h>
34 #include <linux/spi/tsc210x.h>
35
36
37 /* NOTE: It should be straightforward to make this driver framework handle
38 * tsc2100 and tsc2111 chips, and maybe others too. The main differences
39 * are in the audio codec capabilities, but there are also some differences
40 * in how the various sensors (including touchscreen) are handled.
41 */
42
43 /* Bit field definitions for chip registers */
44
45 /* Scan X, Y, Z1, Z2, chip controlled, 12-bit, 16 samples, 500 usec */
46 #define TSC210X_ADC_TS_CONTROL 0x8bf4
47 /* Scan BAT1, BAT2, AUX1, AUX2, 12-bit, 16 samples, 500 usec */
48 #define TSC210X_ADC_SCAN_CONTROL 0x2ff4
49 /* Scan TEMP1, 12-bit, 16 samples, 500 usec */
50 #define TSC210X_ADC_T1_CONTROL 0x2bf4
51 /* Scan TEMP2, 12-bit, 16 samples, 500 usec */
52 #define TSC210X_ADC_T2_CONTROL 0x33f4
53 /* PINT/DAV acts as DAV */
54 #define TSC210X_ADC_DAV 0x4000
55 /* Internal reference, 100 usec delay, 1.25 V reference */
56 #define TSC210X_ADC_INT_REF 0x0016
57 /* External reference, 100 usec delay, 1.25 V reference */
58 #define TSC210X_ADC_EXT_REF 0x0002
59 /* 84 usec precharge time, 32 usec sense time */
60 #define TSC210X_CONFIG_TIMES 0x0008
61 /* The reset sequence */
62 #define TSC210X_RESET 0xbb00
63 /* Pen Status bit */
64 #define TSC210X_ADC_PSTCM (1 << 15)
65 /* A/D Status bit */
66 #define TSC210X_ADC_ADST (1 << 14)
67 /* (At least) One of X, Y, Z1, Z2 contains data */
68 #define TSC210X_TS_DAV 0x0780
69 /* (At least) One of BAT1, BAT2, AUX1, AUX2 contains data */
70 #define TSC210X_PS_DAV 0x0078
71 /* TEMP1 contains data */
72 #define TSC210X_T1_DAV 0x0004
73 /* TEMP2 contains data */
74 #define TSC210X_T2_DAV 0x0002
75 #define TSC2101_DAC_ON 0x0000
76 #define TSC2101_DAC_OFF 0xe7fc
77 #define TSC2102_DAC_ON 0x3ba0
78 #define TSC2102_DAC_OFF 0xafa0
79 #define TSC210X_FS44K (1 << 13)
80 #define TSC210X_PLL1_OFF 0x0000
81 #define TSC210X_PLL1_44K 0x811c
82 #define TSC210X_PLL1_48K 0x8120
83 #define TSC210X_PLL2_44K (5462 << 2)
84 #define TSC210X_PLL2_48K (1920 << 2)
85 #define TSC210X_SLVMS (1 << 11)
86 #define TSC210X_DEEMPF (1 << 0)
87 #define TSC2102_BASSBC (1 << 1)
88 #define TSC210X_KEYCLICK_OFF 0x0000
89
90 #define CS_CHANGE(val) 0
91
92 struct tsc210x_spi_req {
93 struct spi_device *dev;
94 u16 command;
95 u16 data;
96 struct spi_message message;
97 };
98
99 struct tsc210x_dev {
100 enum tsc_type {
101 tsc2101,
102 tsc2102,
103 } kind;
104 struct tsc210x_config *pdata;
105 struct clk *bclk_ck;
106
107 struct workqueue_struct *queue;
108 struct delayed_work ts_worker; /* Poll-wait for PEN UP */
109 struct delayed_work sensor_worker; /* Scan the ADC inputs */
110 struct mutex queue_lock;
111 struct completion data_avail;
112
113 tsc210x_touch_t touch_cb;
114 void *touch_cb_ctx;
115
116 tsc210x_coords_t coords_cb;
117 void *coords_cb_ctx;
118
119 tsc210x_ports_t ports_cb;
120 void *ports_cb_ctx;
121
122 tsc210x_temp_t temp1_cb;
123 void *temp2_cb_ctx;
124
125 tsc210x_temp_t temp2_cb;
126 void *temp1_cb_ctx;
127
128 struct spi_device *spi;
129 struct spi_transfer *transfers;
130 struct tsc210x_spi_req req_adc;
131 struct tsc210x_spi_req req_status;
132 struct tsc210x_spi_req req_mode;
133 struct tsc210x_spi_req req_stop;
134
135 int pendown;
136 int flushing; /* Queue flush in progress */
137 u16 status;
138 u16 adc_data[4];
139 int bat[2], aux[2], temp[2];
140 };
141
142 static struct {
143 unsigned int ts_msecs; /* Interval for .ts_timer */
144 unsigned int mode_msecs; /* Interval for .mode_timer */
145 } settings;
146
147 module_param_named(touch_check_msecs, settings.ts_msecs, uint, 0);
148 MODULE_PARM_DESC(touch_check_msecs, "Pen-up polling interval in msecs");
149
150 module_param_named(sensor_scan_msecs, settings.mode_msecs, uint, 0);
151 MODULE_PARM_DESC(sensor_scan_msecs, "Temperature & battery scan interval");
152
153 int tsc210x_write_sync(struct tsc210x_dev *dev,
154 int page, u8 address, u16 data)
155 {
156 static struct tsc210x_spi_req req;
157 static struct spi_transfer transfer[2];
158 int ret;
159
160 spi_message_init(&req.message);
161
162 /* Address */
163 req.command = (page << 11) | (address << 5);
164 transfer[0].tx_buf = &req.command;
165 transfer[0].rx_buf = NULL;
166 transfer[0].len = 2;
167 spi_message_add_tail(&transfer[0], &req.message);
168
169 /* Data */
170 transfer[1].tx_buf = &data;
171 transfer[1].rx_buf = NULL;
172 transfer[1].len = 2;
173 transfer[1].cs_change = CS_CHANGE(1);
174 spi_message_add_tail(&transfer[1], &req.message);
175
176 ret = spi_sync(dev->spi, &req.message);
177 if (!ret && req.message.status)
178 ret = req.message.status;
179 if (ret)
180 dev_dbg(&dev->spi->dev, "write_sync --> %d\n", ret);
181
182 return ret;
183 }
184 EXPORT_SYMBOL(tsc210x_write_sync);
185
186 int tsc210x_reads_sync(struct tsc210x_dev *dev,
187 int page, u8 startaddress, u16 *data, int numregs)
188 {
189 static struct tsc210x_spi_req req;
190 static struct spi_transfer transfer[6];
191 int ret, i, j;
192
193 if (numregs + 1 > ARRAY_SIZE(transfer))
194 return -EINVAL;
195
196 spi_message_init(&req.message);
197 i = 0;
198 j = 0;
199
200 /* Address */
201 req.command = 0x8000 | (page << 11) | (startaddress << 5);
202 transfer[i].tx_buf = &req.command;
203 transfer[i].rx_buf = NULL;
204 transfer[i].len = 2;
205 spi_message_add_tail(&transfer[i ++], &req.message);
206
207 /* Data */
208 while (j < numregs) {
209 transfer[i].tx_buf = NULL;
210 transfer[i].rx_buf = &data[j ++];
211 transfer[i].len = 2;
212 transfer[i].cs_change = CS_CHANGE(j == numregs);
213 spi_message_add_tail(&transfer[i ++], &req.message);
214 }
215
216 ret = spi_sync(dev->spi, &req.message);
217 if (!ret && req.message.status)
218 ret = req.message.status;
219 if (ret)
220 dev_dbg(&dev->spi->dev, "reads_sync --> %d\n", ret);
221
222 return ret;
223 }
224 EXPORT_SYMBOL(tsc210x_reads_sync);
225
226 int tsc210x_read_sync(struct tsc210x_dev *dev, int page, u8 address)
227 {
228 u16 ret;
229 int status;
230
231 status = tsc210x_reads_sync(dev, page, address, &ret, 1);
232 return status ? : ret;
233 }
234 EXPORT_SYMBOL(tsc210x_read_sync);
235
236
237 static void tsc210x_submit_async(struct tsc210x_spi_req *spi)
238 {
239 int ret;
240
241 ret = spi_async(spi->dev, &spi->message);
242 if (ret)
243 dev_dbg(&spi->dev->dev, "%s: error %i in SPI request\n",
244 __FUNCTION__, ret);
245 }
246
247 static void tsc210x_request_alloc(struct tsc210x_dev *dev,
248 struct tsc210x_spi_req *spi, int direction,
249 int page, u8 startaddress, int numregs, u16 *data,
250 void (*complete)(struct tsc210x_dev *context),
251 struct spi_transfer **transfer)
252 {
253 spi->dev = dev->spi;
254
255 if (direction == 1) /* Write */
256 numregs = 2;
257 else /* Read */
258 numregs += 1;
259
260 spi_message_init(&spi->message);
261 spi->message.complete = (void (*)(void *)) complete;
262 spi->message.context = dev;
263
264 /* Address */
265 spi->command = (page << 11) | (startaddress << 5);
266 if (direction != 1)
267 spi->command |= 1 << 15;
268
269 (*transfer)->tx_buf = &spi->command;
270 (*transfer)->rx_buf = NULL;
271 (*transfer)->len = 2;
272 spi_message_add_tail((*transfer) ++, &spi->message);
273
274 /* Data */
275 while (-- numregs) {
276 if (direction == 1)
277 (*transfer)->tx_buf = &spi->data;
278 else
279 (*transfer)->rx_buf = data++;
280 (*transfer)->len = 2;
281 (*transfer)->cs_change = CS_CHANGE(numregs != 1);
282 spi_message_add_tail((*transfer) ++, &spi->message);
283 }
284 }
285
286 #define tsc210x_cb_register_func(cb, cb_t) \
287 int tsc210x_ ## cb(struct device *dev, cb_t handler, void *context) \
288 { \
289 struct tsc210x_dev *tsc = dev_get_drvdata(dev); \
290 \
291 /* Lock the module */ \
292 if (handler && !tsc->cb) \
293 if (!try_module_get(THIS_MODULE)) { \
294 dev_err(dev, "Failed to get TSC module\n"); \
295 } \
296 if (!handler && tsc->cb) \
297 module_put(THIS_MODULE); \
298 \
299 tsc->cb = handler; \
300 tsc->cb ## _ctx = context; \
301 return 0; \
302 } \
303 EXPORT_SYMBOL(tsc210x_ ## cb);
304
305 tsc210x_cb_register_func(touch_cb, tsc210x_touch_t)
306 tsc210x_cb_register_func(coords_cb, tsc210x_coords_t)
307 tsc210x_cb_register_func(ports_cb, tsc210x_ports_t)
308 tsc210x_cb_register_func(temp1_cb, tsc210x_temp_t)
309 tsc210x_cb_register_func(temp2_cb, tsc210x_temp_t)
310
311 #ifdef DEBUG
312 static void tsc210x_print_dav(struct tsc210x_dev *dev)
313 {
314 int status = tsc210x_read_sync(dev, TSC210X_TS_STATUS_CTRL);
315
316 if (status < 0) {
317 dev_dbg(&dev->spi->dev, "status %d\n", status);
318 return;
319 }
320
321 if (!(status & 0x0fff))
322 return;
323
324 dev_dbg(&dev->spi->dev, "data in %s%s%s%s%s%s%s%s%s%s%s\n",
325 (status & 0x0400) ? " X" : "",
326 (status & 0x0200) ? " Y" : "",
327 (status & 0x0100) ? " Z1" : "",
328 (status & 0x0080) ? " Z2" : "",
329 (status & 0x0040) ? " BAT1" : "",
330 (status & 0x0020) ? " BAT2" : "",
331 (status & 0x0010) ? " AUX1" : "",
332 (status & 0x0008) ? " AUX2" : "",
333 (status & 0x0004) ? " TEMP1" : "",
334 (status & 0x0002) ? " TEMP2" : "",
335 (status & 0x0001) ? " KP" : "");
336 }
337 #endif
338
339 static void tsc210x_complete_dummy(struct tsc210x_dev *dev)
340 {
341 }
342
343 static inline void tsc210x_touchscreen_mode(struct tsc210x_dev *dev)
344 {
345 /* Scan X, Y, Z1, Z2, chip controlled, 12-bit, 16 samples, 500 usec */
346 dev->req_mode.data = TSC210X_ADC_TS_CONTROL;
347 tsc210x_submit_async(&dev->req_mode);
348 }
349
350 static inline void tsc210x_portscan_mode(struct tsc210x_dev *dev)
351 {
352 /* Scan BAT1, BAT2, AUX1, AUX2, 12-bit, 16 samples, 500 usec */
353 dev->req_mode.data = TSC210X_ADC_SCAN_CONTROL;
354 tsc210x_submit_async(&dev->req_mode);
355 }
356
357 static inline void tsc210x_temp1_mode(struct tsc210x_dev *dev)
358 {
359 /* Scan TEMP1, 12-bit, 16 samples, 500 usec */
360 dev->req_mode.data = TSC210X_ADC_T1_CONTROL;
361 tsc210x_submit_async(&dev->req_mode);
362 }
363
364 static inline void tsc210x_temp2_mode(struct tsc210x_dev *dev)
365 {
366 /* Scan TEMP2, 12-bit, 16 samples, 500 usec */
367 dev->req_mode.data = TSC210X_ADC_T2_CONTROL;
368 tsc210x_submit_async(&dev->req_mode);
369 }
370
371 /* Abort current conversion if any */
372 static void tsc210x_new_mode(struct tsc210x_dev *dev)
373 {
374 dev->req_stop.data = TSC210X_ADC_ADST;
375 tsc210x_submit_async(&dev->req_stop);
376 }
377
378 static void tsc210x_queue_scan(struct tsc210x_dev *dev)
379 {
380 if (dev->pdata->monitor)
381 if (!queue_delayed_work(dev->queue,
382 &dev->sensor_worker,
383 msecs_to_jiffies(settings.mode_msecs)))
384 dev_err(&dev->spi->dev,
385 "%s: can't queue measurements\n",
386 __FUNCTION__);
387 }
388
389 static void tsc210x_queue_penup(struct tsc210x_dev *dev)
390 {
391 if (!queue_delayed_work(dev->queue,
392 &dev->ts_worker,
393 msecs_to_jiffies(settings.ts_msecs)))
394 dev_err(&dev->spi->dev,
395 "%s: can't queue pen-up poll\n",
396 __FUNCTION__);
397 }
398
399 static void tsc210x_status_report(struct tsc210x_dev *dev)
400 {
401 /*
402 * Read all converted data from corresponding registers
403 * so that the ADC can move on to a new conversion.
404 */
405 if (dev->status & TSC210X_TS_DAV) {
406 if (!dev->pendown && !dev->flushing) {
407 dev->pendown = 1;
408 if (dev->touch_cb)
409 dev->touch_cb(dev->touch_cb_ctx, 1);
410
411 tsc210x_queue_penup(dev);
412 }
413
414 tsc210x_submit_async(&dev->req_adc);
415 }
416
417 if (dev->status & (TSC210X_PS_DAV | TSC210X_T1_DAV | TSC210X_T2_DAV))
418 complete(&dev->data_avail);
419 }
420
421 static void tsc210x_data_report(struct tsc210x_dev *dev)
422 {
423 u16 adc_data[4];
424
425 if (dev->status & TSC210X_PS_DAV) {
426 tsc210x_reads_sync(dev, TSC210X_TS_BAT1, adc_data, 4);
427 /* NOTE: reads_sync() could fail */
428
429 dev->bat[0] = adc_data[0];
430 dev->bat[1] = adc_data[1];
431 dev->aux[0] = adc_data[2];
432 dev->aux[1] = adc_data[3];
433 if (dev->ports_cb)
434 dev->ports_cb(dev->ports_cb_ctx, dev->bat, dev->aux);
435 }
436
437 if (dev->status & TSC210X_T1_DAV) {
438 dev->temp[0] = tsc210x_read_sync(dev, TSC210X_TS_TEMP1);
439
440 if (dev->temp[0] >= 0 && dev->temp1_cb)
441 dev->temp1_cb(dev->temp1_cb_ctx, dev->temp[0]);
442 }
443
444 if (dev->status & TSC210X_T2_DAV) {
445 dev->temp[1] = tsc210x_read_sync(dev, TSC210X_TS_TEMP2);
446
447 if (dev->temp[1] >= 0 && dev->temp2_cb)
448 dev->temp2_cb(dev->temp2_cb_ctx, dev->temp[1]);
449 }
450 }
451
452 static void tsc210x_coords_report(struct tsc210x_dev *dev)
453 {
454 if (dev->coords_cb)
455 dev->coords_cb(dev->coords_cb_ctx,
456 dev->adc_data[0], dev->adc_data[1],
457 dev->adc_data[2], dev->adc_data[3]);
458 }
459
460 /*
461 * There are at least three ways to check for pen-up:
462 * - the PINT/DAV pin state,
463 * - reading PSTCM bit in ADC Control register (D15, offset 0x00),
464 * - reading ADST bit in ADC Control register (D14, offset 0x00),
465 * ADC idle would indicate no screen touch.
466 * Unfortunately none of them seems to be 100% accurate and you will
467 * find they are totally inconsistent, i.e. you get to see any arbitrary
468 * combination of values in these three bits. So we will busy-wait
469 * for a moment when the latter two indicate a pen-up, using a queue,
470 * before we report a pen-up.
471 */
472 static void tsc210x_pressure(struct work_struct *work)
473 {
474 struct tsc210x_dev *dev =
475 container_of(work, struct tsc210x_dev, ts_worker.work);
476 int adc_status;
477
478 WARN_ON(!dev->pendown);
479
480 adc_status = tsc210x_read_sync(dev, TSC210X_TS_ADC_CTRL);
481 if (adc_status < 0) {
482 dev_dbg(&dev->spi->dev, "pressure, err %d\n", adc_status);
483 return;
484 }
485
486 if ((adc_status & TSC210X_ADC_PSTCM) != 0
487 || !(adc_status & TSC210X_ADC_ADST))
488 tsc210x_queue_penup(dev);
489 else {
490 dev->pendown = 0;
491 if (dev->touch_cb)
492 dev->touch_cb(dev->touch_cb_ctx, 0);
493 }
494 }
495
496 static void tsc210x_wait_data(struct tsc210x_dev *dev)
497 {
498 wait_for_completion(&dev->data_avail);
499
500 tsc210x_data_report(dev);
501 }
502
503 static void tsc210x_input_scan(struct work_struct *work)
504 {
505 struct tsc210x_dev *dev = (struct tsc210x_dev *)
506 container_of(work, struct tsc210x_dev, sensor_worker.work);
507
508 tsc210x_new_mode(dev);
509
510 if (dev->pdata->monitor &
511 (TSC_BAT1 | TSC_BAT2 | TSC_AUX1 | TSC_AUX2)) {
512 tsc210x_portscan_mode(dev);
513 tsc210x_wait_data(dev);
514 }
515
516 if (dev->pdata->monitor & TSC_TEMP) {
517 tsc210x_temp1_mode(dev);
518 tsc210x_wait_data(dev);
519
520 tsc210x_temp2_mode(dev);
521 tsc210x_wait_data(dev);
522 }
523
524 tsc210x_touchscreen_mode(dev);
525
526 mutex_lock(&dev->queue_lock);
527 if (!dev->flushing)
528 tsc210x_queue_scan(dev);
529 mutex_unlock(&dev->queue_lock);
530 }
531
532 /* ADC has finished a new conversion for us. */
533 static irqreturn_t tsc210x_handler(int irq, void *dev_id)
534 {
535 struct tsc210x_dev *dev = (struct tsc210x_dev *) dev_id;
536
537 /* See what data became available. */
538 tsc210x_submit_async(&dev->req_status);
539
540 return IRQ_HANDLED;
541 }
542
543 #if defined(CONFIG_SOUND) || defined(CONFIG_SOUND_MODULE)
544
545 /*
546 * FIXME the audio support shouldn't be included in upstream patches
547 * until it's ready. They might be better as utility functions linked
548 * with a chip-specific tsc21xx audio module ... e.g. chips with input
549 * channels need more, as will ones with multiple output channels and
550 * so on. Each of these functions should probably return a fault code,
551 * and will need to be exported so the sound drier can be modular.
552 */
553
554 /*
555 * Volume level values should be in the range [0, 127].
556 * Higher values mean lower volume.
557 */
558 void tsc210x_set_dac_volume(struct device *dev, u8 left_ch, u8 right_ch)
559 {
560 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
561 int val;
562
563 if (tsc->kind == tsc2102) {
564 /* All 0's or all 1's */
565 if (left_ch == 0x00 || left_ch == 0x7f)
566 left_ch ^= 0x7f;
567 if (right_ch == 0x00 || right_ch == 0x7f)
568 right_ch ^= 0x7f;
569 }
570
571 val = tsc210x_read_sync(tsc, TSC210X_DAC_GAIN_CTRL);
572 if (val < 0) {
573 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
574 return;
575 }
576
577 val &= 0x8080; /* Preserve mute-bits */
578 val |= (left_ch << 8) | right_ch;
579
580 tsc210x_write_sync(tsc, TSC210X_DAC_GAIN_CTRL, val);
581 /* NOTE: write_sync() could fail */
582 }
583
584 void tsc210x_set_dac_mute(struct device *dev, int left_ch, int right_ch)
585 {
586 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
587 int val;
588
589 val = tsc210x_read_sync(tsc, TSC210X_DAC_GAIN_CTRL);
590 if (val < 0) {
591 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
592 return;
593 }
594
595 val &= 0x7f7f; /* Preserve volume settings */
596 val |= (left_ch << 15) | (right_ch << 7);
597
598 tsc210x_write_sync(tsc, TSC210X_DAC_GAIN_CTRL, val);
599 /* NOTE: write_sync() could fail */
600 }
601
602 void tsc210x_get_dac_mute(struct device *dev, int *left_ch, int *right_ch)
603 {
604 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
605 int val;
606
607 val = tsc210x_read_sync(tsc, TSC210X_DAC_GAIN_CTRL);
608 if (val < 0) {
609 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
610 return;
611 }
612
613 *left_ch = !!(val & (1 << 15));
614 *right_ch = !!(val & (1 << 7));
615 }
616
617 void tsc210x_set_deemphasis(struct device *dev, int enable)
618 {
619 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
620 int val;
621
622 val = tsc210x_read_sync(tsc, TSC210X_POWER_CTRL);
623 if (val < 0) {
624 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
625 return;
626 }
627
628 if (enable)
629 val &= ~TSC210X_DEEMPF;
630 else
631 val |= TSC210X_DEEMPF;
632
633 tsc210x_write_sync(tsc, TSC210X_POWER_CTRL, val);
634 /* NOTE: write_sync() could fail */
635 }
636
637 void tsc2102_set_bassboost(struct device *dev, int enable)
638 {
639 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
640 int val;
641
642 val = tsc210x_read_sync(tsc, TSC210X_POWER_CTRL);
643 if (val < 0) {
644 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
645 return;
646 }
647
648 if (enable)
649 val &= ~TSC2102_BASSBC;
650 else
651 val |= TSC2102_BASSBC;
652
653 tsc210x_write_sync(tsc, TSC210X_POWER_CTRL, val);
654 /* NOTE: write_sync() could fail */
655 }
656
657 /* {rate, dsor, fsref} */
658 static const struct tsc210x_rate_info_s tsc2101_rates[] = {
659 /* Fsref / 6.0 */
660 {7350, 7, 1},
661 {8000, 7, 0},
662 /* Fsref / 5.5 */
663 {8018, 6, 1},
664 {8727, 6, 0},
665 /* Fsref / 5.0 */
666 {8820, 5, 1},
667 {9600, 5, 0},
668 /* Fsref / 4.0 */
669 {11025, 4, 1},
670 {12000, 4, 0},
671 /* Fsref / 3.0 */
672 {14700, 3, 1},
673 {16000, 3, 0},
674 /* Fsref / 2.0 */
675 {22050, 2, 1},
676 {24000, 2, 0},
677 /* Fsref / 1.5 */
678 {29400, 1, 1},
679 {32000, 1, 0},
680 /* Fsref */
681 {44100, 0, 1},
682 {48000, 0, 0},
683
684 {0, 0, 0},
685 };
686
687 /* {rate, dsor, fsref} */
688 static const struct tsc210x_rate_info_s tsc2102_rates[] = {
689 /* Fsref / 6.0 */
690 {7350, 63, 1},
691 {8000, 63, 0},
692 /* Fsref / 6.0 */
693 {7350, 54, 1},
694 {8000, 54, 0},
695 /* Fsref / 5.0 */
696 {8820, 45, 1},
697 {9600, 45, 0},
698 /* Fsref / 4.0 */
699 {11025, 36, 1},
700 {12000, 36, 0},
701 /* Fsref / 3.0 */
702 {14700, 27, 1},
703 {16000, 27, 0},
704 /* Fsref / 2.0 */
705 {22050, 18, 1},
706 {24000, 18, 0},
707 /* Fsref / 1.5 */
708 {29400, 9, 1},
709 {32000, 9, 0},
710 /* Fsref */
711 {44100, 0, 1},
712 {48000, 0, 0},
713
714 {0, 0, 0},
715 };
716
717 int tsc210x_set_rate(struct device *dev, int rate)
718 {
719 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
720 int i;
721 int val;
722 const struct tsc210x_rate_info_s *rates;
723
724 if (tsc->kind == tsc2101)
725 rates = tsc2101_rates;
726 else
727 rates = tsc2102_rates;
728
729 for (i = 0; rates[i].sample_rate; i ++)
730 if (rates[i].sample_rate == rate)
731 break;
732 if (rates[i].sample_rate == 0) {
733 dev_err(dev, "Unknown sampling rate %i.0 Hz\n", rate);
734 return -EINVAL;
735 }
736
737 if (tsc->kind == tsc2101) {
738 val = tsc210x_read_sync(tsc, TSC210X_AUDIO1_CTRL);
739 if (val < 0) {
740 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
741 return val;
742 }
743 val &= ~((7 << 3) | (7 << 0));
744 val |= rates[i].divisor << 3;
745 val |= rates[i].divisor << 0;
746 } else
747 val = rates[i].divisor;
748
749 tsc210x_write_sync(tsc, TSC210X_AUDIO1_CTRL, val);
750 /* NOTE: write_sync() could fail */
751
752 val = tsc210x_read_sync(tsc, TSC210X_AUDIO3_CTRL);
753 if (val < 0) {
754 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
755 return val;
756 }
757
758 if (tsc2102_rates[i].fs_44k) {
759 tsc210x_write_sync(tsc,
760 TSC210X_AUDIO3_CTRL, val | TSC210X_FS44K);
761 /* Enable Phase-locked-loop, set up clock dividers */
762 tsc210x_write_sync(tsc, TSC210X_PLL1_CTRL, TSC210X_PLL1_44K);
763 tsc210x_write_sync(tsc, TSC210X_PLL2_CTRL, TSC210X_PLL2_44K);
764 } else {
765 tsc210x_write_sync(tsc,
766 TSC210X_AUDIO3_CTRL, val & ~TSC210X_FS44K);
767 /* Enable Phase-locked-loop, set up clock dividers */
768 tsc210x_write_sync(tsc, TSC210X_PLL1_CTRL, TSC210X_PLL1_48K);
769 tsc210x_write_sync(tsc, TSC210X_PLL2_CTRL, TSC210X_PLL2_48K);
770 }
771
772 return 0;
773 }
774
775 /*
776 * Perform basic set-up with default values and power the DAC/ADC on.
777 */
778 void tsc210x_dac_power(struct device *dev, int on)
779 {
780 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
781
782 /* NOTE: write_sync() could fail */
783 if (on) {
784 /* 16-bit words, DSP mode, sample at Fsref */
785 tsc210x_write_sync(tsc,
786 TSC210X_AUDIO1_CTRL, 0x0100);
787 /* Keyclicks off, soft-stepping at normal rate */
788 tsc210x_write_sync(tsc,
789 TSC210X_AUDIO2_CTRL, TSC210X_KEYCLICK_OFF);
790 /* 44.1 kHz Fsref, continuous transfer mode, master DAC */
791 tsc210x_write_sync(tsc,
792 TSC210X_AUDIO3_CTRL, 0x2000);
793 /* Soft-stepping enabled, 1 dB MIX AGC hysteresis */
794 tsc210x_write_sync(tsc,
795 TSC210X_AUDIO4_CTRL, 0x0000);
796
797 /* PLL generates 44.1 kHz */
798 tsc210x_write_sync(tsc,
799 TSC210X_PLL1_CTRL, TSC210X_PLL1_44K);
800 tsc210x_write_sync(tsc,
801 TSC210X_PLL2_CTRL, TSC210X_PLL2_44K);
802
803 /* Codec & DAC power up, virtual ground disabled */
804 tsc210x_write_sync(tsc,
805 TSC210X_POWER_CTRL, (tsc->kind == tsc2101) ?
806 TSC2101_DAC_ON : TSC2102_DAC_ON);
807 } else {
808 /* All off */
809 tsc210x_write_sync(tsc,
810 TSC210X_AUDIO2_CTRL, TSC210X_KEYCLICK_OFF);
811 tsc210x_write_sync(tsc,
812 TSC210X_PLL1_CTRL, TSC210X_PLL1_OFF);
813 #if 0
814 tsc210x_write_sync(tsc,
815 TSC210X_POWER_CTRL, (tsc->kind == tsc2101) ?
816 TSC2102_DAC_OFF : TSC2102_DAC_OFF);
817 #endif
818 }
819 }
820
821 void tsc210x_set_i2s_master(struct device *dev, int state)
822 {
823 struct tsc210x_dev *tsc = dev_get_drvdata(dev);
824 int val;
825
826 val = tsc210x_read_sync(tsc, TSC210X_AUDIO3_CTRL);
827 if (val < 0) {
828 dev_dbg(dev, "%s, err %d\n", __FUNCTION__, val);
829 return;
830 }
831
832 /* NOTE: write_sync() could fail */
833 if (state)
834 tsc210x_write_sync(tsc, TSC210X_AUDIO3_CTRL,
835 val | TSC210X_SLVMS);
836 else
837 tsc210x_write_sync(tsc, TSC210X_AUDIO3_CTRL,
838 val & ~TSC210X_SLVMS);
839 }
840 #endif /* CONFIG_SOUND */
841
842 static int tsc210x_configure(struct tsc210x_dev *dev)
843 {
844 /* NOTE: write_sync() could fail */
845
846 /* Reset the chip */
847 tsc210x_write_sync(dev, TSC210X_TS_RESET_CTRL, TSC210X_RESET);
848
849 /* Reference mode */
850 if (dev->pdata->use_internal)
851 tsc210x_write_sync(dev,
852 TSC210X_TS_REF_CTRL, TSC210X_ADC_INT_REF);
853 else
854 tsc210x_write_sync(dev,
855 TSC210X_TS_REF_CTRL, TSC210X_ADC_EXT_REF);
856
857 /* Precharge and sense delays, pen touch detection on */
858 tsc210x_write_sync(dev, TSC210X_TS_CONFIG_CTRL, TSC210X_CONFIG_TIMES);
859
860 /* PINT/DAV acts as DAV */
861 tsc210x_write_sync(dev, TSC210X_TS_STATUS_CTRL, TSC210X_ADC_DAV);
862
863 tsc210x_queue_scan(dev);
864 return 0;
865 }
866
867 void tsc210x_keyclick(struct tsc210x_dev *dev,
868 int amplitude, int freq, int length)
869 {
870 int val;
871
872 val = tsc210x_read_sync(dev, TSC210X_AUDIO2_CTRL);
873 if (val < 0) {
874 dev_dbg(&dev->spi->dev, "%s, err %d\n",
875 __FUNCTION__, val);
876 return;
877 }
878 val &= 0x800f;
879
880 /* Set amplitude */
881 switch (amplitude) {
882 case 1:
883 val |= 4 << 12;
884 break;
885 case 2:
886 val |= 7 << 12;
887 break;
888 default:
889 break;
890 }
891
892 /* Frequency */
893 val |= (freq & 0x7) << 8;
894
895 /* Round to nearest supported length */
896 if (dev->kind == tsc2101)
897 val = (min(length - 1, 31) >> 1) << 4;
898 else {
899 if (length > 20)
900 val |= 4 << 4;
901 else if (length > 6)
902 val |= 3 << 4;
903 else if (length > 4)
904 val |= 2 << 4;
905 else if (length > 2)
906 val |= 1 << 4;
907 }
908
909 /* Enable keyclick */
910 val |= 0x8000;
911
912 /* NOTE: write_sync() could fail */
913 tsc210x_write_sync(dev, TSC210X_AUDIO2_CTRL, val);
914 }
915 EXPORT_SYMBOL(tsc210x_keyclick);
916
917 #ifdef CONFIG_PM
918 /*
919 * Suspend the chip.
920 */
921 static int
922 tsc210x_suspend(struct spi_device *spi, pm_message_t state)
923 {
924 struct tsc210x_dev *dev = dev_get_drvdata(&spi->dev);
925
926 if (!dev)
927 return -ENODEV;
928
929 /* Stop the inputs scan loop */
930 mutex_lock(&dev->queue_lock);
931 dev->flushing = 1;
932 cancel_delayed_work(&dev->sensor_worker);
933 mutex_unlock(&dev->queue_lock);
934 flush_workqueue(dev->queue);
935
936 /* Wait until pen-up happens */
937 while (dev->pendown)
938 flush_workqueue(dev->queue);
939
940 /* Abort current conversion and power down the ADC */
941 tsc210x_write_sync(dev, TSC210X_TS_ADC_CTRL, TSC210X_ADC_ADST);
942 /* NOTE: write_sync() could fail */
943
944 return 0;
945 }
946
947 /*
948 * Resume chip operation.
949 */
950 static int tsc210x_resume(struct spi_device *spi)
951 {
952 struct tsc210x_dev *dev = dev_get_drvdata(&spi->dev);
953 int err;
954
955 if (!dev)
956 return 0;
957
958 mutex_lock(&dev->queue_lock);
959 err = tsc210x_configure(dev);
960
961 dev->flushing = 0;
962 mutex_unlock(&dev->queue_lock);
963
964 return err;
965 }
966 #else
967 #define tsc210x_suspend NULL
968 #define tsc210x_resume NULL
969 #endif
970
971 /* REVISIT don't make these static */
972 static struct platform_device tsc210x_ts_device = {
973 .name = "tsc210x-ts",
974 .id = -1,
975 };
976
977 static struct platform_device tsc210x_hwmon_device = {
978 .name = "tsc210x-hwmon",
979 .id = -1,
980 };
981
982 static struct platform_device tsc210x_alsa_device = {
983 .name = "tsc210x-alsa",
984 .id = -1,
985 };
986
987 static int tsc210x_probe(struct spi_device *spi, enum tsc_type type)
988 {
989 struct tsc210x_config *pdata = spi->dev.platform_data;
990 struct spi_transfer *spi_buffer;
991 struct tsc210x_dev *dev;
992 int reg;
993 int err = 0;
994
995 if (!pdata) {
996 dev_dbg(&spi->dev, "Platform data not supplied\n");
997 return -ENOENT;
998 }
999
1000 if (!spi->irq) {
1001 dev_dbg(&spi->dev, "Invalid irq value\n");
1002 return -EINVAL;
1003 }
1004
1005 dev = (struct tsc210x_dev *)
1006 kzalloc(sizeof(struct tsc210x_dev), GFP_KERNEL);
1007 if (!dev) {
1008 dev_dbg(&spi->dev, "No memory\n");
1009 return -ENOMEM;
1010 }
1011
1012 dev->pdata = pdata;
1013 dev->pendown = 0;
1014 dev->spi = spi;
1015 dev->kind = type;
1016 dev->queue = create_singlethread_workqueue(spi->dev.driver->name);
1017 if (!dev->queue) {
1018 dev_dbg(&spi->dev, "Can't make a workqueue\n");
1019 err = -ENOMEM;
1020 goto err_queue;
1021 }
1022
1023 mutex_init(&dev->queue_lock);
1024 init_completion(&dev->data_avail);
1025
1026 /* Allocate enough struct spi_transfer's for all requests */
1027 spi_buffer = kzalloc(sizeof(struct spi_transfer) * 16, GFP_KERNEL);
1028 if (!spi_buffer) {
1029 dev_dbg(&spi->dev, "No memory for SPI buffers\n");
1030 err = -ENOMEM;
1031 goto err_buffers;
1032 }
1033
1034 dev->transfers = spi_buffer;
1035 tsc210x_request_alloc(dev, &dev->req_adc, 0,
1036 TSC210X_TS_X, 4, dev->adc_data,
1037 tsc210x_coords_report, &spi_buffer);
1038 tsc210x_request_alloc(dev, &dev->req_status, 0,
1039 TSC210X_TS_STATUS_CTRL, 1, &dev->status,
1040 tsc210x_status_report, &spi_buffer);
1041 tsc210x_request_alloc(dev, &dev->req_mode, 1,
1042 TSC210X_TS_ADC_CTRL, 1, NULL,
1043 tsc210x_complete_dummy, &spi_buffer);
1044 tsc210x_request_alloc(dev, &dev->req_stop, 1,
1045 TSC210X_TS_ADC_CTRL, 1, NULL,
1046 tsc210x_complete_dummy, &spi_buffer);
1047
1048 if (pdata->bclk) {
1049 /* Get the BCLK */
1050 dev->bclk_ck = clk_get(&spi->dev, pdata->bclk);
1051 if (IS_ERR(dev->bclk_ck)) {
1052 err = PTR_ERR(dev->bclk_ck);
1053 dev_dbg(&spi->dev, "Unable to get '%s': %i\n",
1054 pdata->bclk, err);
1055 goto err_clk;
1056 }
1057
1058 clk_enable(dev->bclk_ck);
1059 }
1060
1061 INIT_DELAYED_WORK(&dev->ts_worker, tsc210x_pressure);
1062 INIT_DELAYED_WORK(&dev->sensor_worker, tsc210x_input_scan);
1063
1064 /* Setup the communication bus */
1065 dev_set_drvdata(&spi->dev, dev);
1066 spi->mode = SPI_MODE_1;
1067 spi->bits_per_word = 16;
1068 err = spi_setup(spi);
1069 if (err)
1070 goto err_spi;
1071
1072 /* Now try to detect the chip, make first contact. These chips
1073 * don't self-identify, but we can expect that the status register
1074 * reports the ADC is idle and use that as a sanity check. (It'd
1075 * be even better if we did a soft reset first...)
1076 */
1077 reg = tsc210x_read_sync(dev, TSC210X_TS_ADC_CTRL);
1078 if (reg < 0) {
1079 err = reg;
1080 dev_dbg(&dev->spi->dev, "adc_ctrl, err %d\n", err);
1081 goto err_spi;
1082 }
1083 if (!(reg & (1 << 14))) {
1084 err = -EIO;
1085 dev_dbg(&dev->spi->dev, "adc_ctrl, busy? - %04x\n", reg);
1086 goto err_spi;
1087 }
1088
1089 reg = tsc210x_read_sync(dev, TSC210X_AUDIO3_CTRL);
1090 if (reg < 0) {
1091 err = reg;
1092 dev_dbg(&dev->spi->dev, "revision, err %d\n", err);
1093 goto err_spi;
1094 }
1095 if (reg == 0xffff) {
1096 err = -ENODEV;
1097 dev_dbg(&dev->spi->dev, "no device, err %d\n", err);
1098 goto err_spi;
1099 }
1100 dev_info(&spi->dev, "rev %d, irq %d\n", reg & 0x0007, spi->irq);
1101
1102 err = tsc210x_configure(dev);
1103 if (err)
1104 goto err_spi;
1105
1106 /* We want no interrupts before configuration succeeds. */
1107 mutex_lock(&dev->queue_lock);
1108 dev->flushing = 1;
1109
1110 if (request_irq(spi->irq, tsc210x_handler, IRQF_SAMPLE_RANDOM |
1111 IRQF_TRIGGER_FALLING, spi->dev.driver->name,
1112 dev)) {
1113 dev_dbg(&spi->dev, "Could not allocate touchscreen IRQ!\n");
1114 err = -EINVAL;
1115 goto err_irq;
1116 }
1117
1118 /* Register subdevices controlled by the TSC 2101/2102 */
1119 tsc210x_ts_device.dev.platform_data = dev;
1120 tsc210x_ts_device.dev.parent = &spi->dev;
1121 err = platform_device_register(&tsc210x_ts_device);
1122 if (err)
1123 goto err_irq;
1124
1125 tsc210x_hwmon_device.dev.platform_data = pdata;
1126 tsc210x_hwmon_device.dev.parent = &spi->dev;
1127 err = platform_device_register(&tsc210x_hwmon_device);
1128 if (err)
1129 goto err_hwmon;
1130
1131 tsc210x_alsa_device.dev.platform_data = pdata->alsa_config;
1132 tsc210x_alsa_device.dev.parent = &spi->dev;
1133 err = platform_device_register(&tsc210x_alsa_device);
1134 if (err)
1135 goto err_alsa;
1136
1137 dev->flushing = 0;
1138 mutex_unlock(&dev->queue_lock);
1139 return 0;
1140
1141 err_alsa:
1142 platform_device_unregister(&tsc210x_hwmon_device);
1143 err_hwmon:
1144 platform_device_unregister(&tsc210x_ts_device);
1145 err_irq:
1146 mutex_unlock(&dev->queue_lock);
1147 err_spi:
1148 dev_set_drvdata(&spi->dev, NULL);
1149 clk_disable(dev->bclk_ck);
1150 clk_put(dev->bclk_ck);
1151 err_clk:
1152 kfree(dev->transfers);
1153 err_buffers:
1154 destroy_workqueue(dev->queue);
1155 err_queue:
1156 kfree(dev);
1157 return err;
1158 }
1159
1160 static int tsc2101_probe(struct spi_device *spi)
1161 {
1162 return tsc210x_probe(spi, tsc2101);
1163 }
1164
1165 static int tsc2102_probe(struct spi_device *spi)
1166 {
1167 return tsc210x_probe(spi, tsc2102);
1168 }
1169
1170 static int tsc210x_remove(struct spi_device *spi)
1171 {
1172 struct tsc210x_dev *dev = dev_get_drvdata(&spi->dev);
1173
1174 /* Stop the inputs scan loop */
1175 mutex_lock(&dev->queue_lock);
1176 dev->flushing = 1;
1177 cancel_delayed_work(&dev->sensor_worker);
1178 mutex_unlock(&dev->queue_lock);
1179 flush_workqueue(dev->queue);
1180
1181 /* Wait for pen-up */
1182 while (dev->pendown)
1183 flush_workqueue(dev->queue);
1184
1185 /* Abort current conversion and power down the ADC */
1186 tsc210x_write_sync(dev, TSC210X_TS_ADC_CTRL, TSC210X_ADC_ADST);
1187 /* NOTE: write_sync() could fail */
1188
1189 destroy_workqueue(dev->queue);
1190
1191 platform_device_unregister(&tsc210x_ts_device);
1192 platform_device_unregister(&tsc210x_hwmon_device);
1193 platform_device_unregister(&tsc210x_alsa_device);
1194
1195 dev_set_drvdata(&spi->dev, NULL);
1196
1197 /* Release the BCLK */
1198 clk_disable(dev->bclk_ck);
1199 clk_put(dev->bclk_ck);
1200
1201 kfree(dev->transfers);
1202 kfree(dev);
1203
1204 return 0;
1205 }
1206
1207 static struct spi_driver tsc2101_driver = {
1208 .probe = tsc2101_probe,
1209 .remove = tsc210x_remove,
1210 .suspend = tsc210x_suspend,
1211 .resume = tsc210x_resume,
1212 .driver = {
1213 .name = "tsc2101",
1214 .owner = THIS_MODULE,
1215 .bus = &spi_bus_type,
1216 },
1217 };
1218
1219 static struct spi_driver tsc2102_driver = {
1220 .probe = tsc2102_probe,
1221 .remove = tsc210x_remove,
1222 .suspend = tsc210x_suspend,
1223 .resume = tsc210x_resume,
1224 .driver = {
1225 .name = "tsc2102",
1226 .owner = THIS_MODULE,
1227 .bus = &spi_bus_type,
1228 },
1229 };
1230
1231 static char __initdata banner[] = KERN_INFO "TI TSC210x driver initializing\n";
1232
1233 static int __init tsc210x_init(void)
1234 {
1235 int err;
1236 printk(banner);
1237
1238 settings.ts_msecs = 20;
1239 settings.mode_msecs = 1000;
1240
1241 err = spi_register_driver(&tsc2101_driver);
1242 if (err != 0)
1243 return err;
1244
1245 err = spi_register_driver(&tsc2102_driver);
1246 if (err != 0)
1247 spi_unregister_driver(&tsc2101_driver);
1248
1249 return err;
1250 }
1251 module_init(tsc210x_init);
1252
1253 static void __exit tsc210x_exit(void)
1254 {
1255 spi_unregister_driver(&tsc2101_driver);
1256 spi_unregister_driver(&tsc2102_driver);
1257 }
1258 module_exit(tsc210x_exit);
1259
1260 MODULE_AUTHOR("Andrzej Zaborowski");
1261 MODULE_DESCRIPTION("Interface driver for TI TSC210x chips.");
1262 MODULE_LICENSE("GPL");
Linux for Ginger Game Console