Commit | Line | Data |
---|---|---|
ffa458c1 DB |
1 | /* |
2 | * ADS7846 based touchscreen and sensor driver | |
3 | * | |
4 | * Copyright (c) 2005 David Brownell | |
5 | * | |
6 | * Using code from: | |
7 | * - corgi_ts.c | |
8 | * Copyright (C) 2004-2005 Richard Purdie | |
9 | * - omap_ts.[hc], ads7846.h, ts_osk.c | |
10 | * Copyright (C) 2002 MontaVista Software | |
11 | * Copyright (C) 2004 Texas Instruments | |
12 | * Copyright (C) 2005 Dirk Behme | |
13 | * | |
14 | * This program is free software; you can redistribute it and/or modify | |
15 | * it under the terms of the GNU General Public License version 2 as | |
16 | * published by the Free Software Foundation. | |
17 | */ | |
18 | #include <linux/device.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/delay.h> | |
21 | #include <linux/input.h> | |
22 | #include <linux/interrupt.h> | |
23 | #include <linux/slab.h> | |
24 | #include <linux/spi/spi.h> | |
25 | #include <linux/spi/ads7846.h> | |
26 | ||
27 | #ifdef CONFIG_ARM | |
28 | #include <asm/mach-types.h> | |
29 | #ifdef CONFIG_ARCH_OMAP | |
30 | #include <asm/arch/gpio.h> | |
31 | #endif | |
ffa458c1 DB |
32 | #endif |
33 | ||
34 | ||
35 | /* | |
36 | * This code has been lightly tested on an ads7846. | |
37 | * Support for ads7843 and ads7845 has only been stubbed in. | |
38 | * | |
39 | * Not yet done: investigate the values reported. Are x/y/pressure | |
40 | * event values sane enough for X11? How accurate are the temperature | |
41 | * and voltage readings? (System-specific calibration should support | |
42 | * accuracy of 0.3 degrees C; otherwise it's 2.0 degrees.) | |
43 | * | |
44 | * app note sbaa036 talks in more detail about accurate sampling... | |
45 | * that ought to help in situations like LCDs inducing noise (which | |
46 | * can also be helped by using synch signals) and more generally. | |
47 | */ | |
48 | ||
49 | #define TS_POLL_PERIOD msecs_to_jiffies(10) | |
50 | ||
51 | struct ts_event { | |
52 | /* For portability, we can't read 12 bit values using SPI (which | |
53 | * would make the controller deliver them as native byteorder u16 | |
54 | * with msbs zeroed). Instead, we read them as two 8-byte values, | |
55 | * which need byteswapping then range adjustment. | |
56 | */ | |
57 | __be16 x; | |
58 | __be16 y; | |
59 | __be16 z1, z2; | |
60 | }; | |
61 | ||
62 | struct ads7846 { | |
63 | struct input_dev input; | |
64 | char phys[32]; | |
65 | ||
66 | struct spi_device *spi; | |
67 | u16 model; | |
68 | u16 vref_delay_usecs; | |
69 | u16 x_plate_ohms; | |
70 | ||
71 | struct ts_event tc; | |
72 | ||
73 | struct spi_transfer xfer[8]; | |
74 | struct spi_message msg; | |
75 | ||
76 | spinlock_t lock; | |
77 | struct timer_list timer; /* P: lock */ | |
78 | unsigned pendown:1; /* P: lock */ | |
79 | unsigned pending:1; /* P: lock */ | |
80 | // FIXME remove "irq_disabled" | |
81 | unsigned irq_disabled:1; /* P: lock */ | |
82 | }; | |
83 | ||
84 | /* leave chip selected when we're done, for quicker re-select? */ | |
85 | #if 0 | |
86 | #define CS_CHANGE(xfer) ((xfer).cs_change = 1) | |
87 | #else | |
88 | #define CS_CHANGE(xfer) ((xfer).cs_change = 0) | |
89 | #endif | |
90 | ||
91 | /*--------------------------------------------------------------------------*/ | |
92 | ||
93 | /* The ADS7846 has touchscreen and other sensors. | |
94 | * Earlier ads784x chips are somewhat compatible. | |
95 | */ | |
96 | #define ADS_START (1 << 7) | |
97 | #define ADS_A2A1A0_d_y (1 << 4) /* differential */ | |
98 | #define ADS_A2A1A0_d_z1 (3 << 4) /* differential */ | |
99 | #define ADS_A2A1A0_d_z2 (4 << 4) /* differential */ | |
100 | #define ADS_A2A1A0_d_x (5 << 4) /* differential */ | |
101 | #define ADS_A2A1A0_temp0 (0 << 4) /* non-differential */ | |
102 | #define ADS_A2A1A0_vbatt (2 << 4) /* non-differential */ | |
103 | #define ADS_A2A1A0_vaux (6 << 4) /* non-differential */ | |
104 | #define ADS_A2A1A0_temp1 (7 << 4) /* non-differential */ | |
105 | #define ADS_8_BIT (1 << 3) | |
106 | #define ADS_12_BIT (0 << 3) | |
107 | #define ADS_SER (1 << 2) /* non-differential */ | |
108 | #define ADS_DFR (0 << 2) /* differential */ | |
109 | #define ADS_PD10_PDOWN (0 << 0) /* lowpower mode + penirq */ | |
110 | #define ADS_PD10_ADC_ON (1 << 0) /* ADC on */ | |
111 | #define ADS_PD10_REF_ON (2 << 0) /* vREF on + penirq */ | |
112 | #define ADS_PD10_ALL_ON (3 << 0) /* ADC + vREF on */ | |
113 | ||
114 | #define MAX_12BIT ((1<<12)-1) | |
115 | ||
116 | /* leave ADC powered up (disables penirq) between differential samples */ | |
117 | #define READ_12BIT_DFR(x) (ADS_START | ADS_A2A1A0_d_ ## x \ | |
118 | | ADS_12_BIT | ADS_DFR) | |
119 | ||
120 | static const u8 read_y = READ_12BIT_DFR(y) | ADS_PD10_ADC_ON; | |
121 | static const u8 read_z1 = READ_12BIT_DFR(z1) | ADS_PD10_ADC_ON; | |
122 | static const u8 read_z2 = READ_12BIT_DFR(z2) | ADS_PD10_ADC_ON; | |
123 | static const u8 read_x = READ_12BIT_DFR(x) | ADS_PD10_PDOWN; /* LAST */ | |
124 | ||
125 | /* single-ended samples need to first power up reference voltage; | |
126 | * we leave both ADC and VREF powered | |
127 | */ | |
128 | #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \ | |
129 | | ADS_12_BIT | ADS_SER) | |
130 | ||
131 | static const u8 ref_on = READ_12BIT_DFR(x) | ADS_PD10_ALL_ON; | |
132 | static const u8 ref_off = READ_12BIT_DFR(y) | ADS_PD10_PDOWN; | |
133 | ||
134 | /*--------------------------------------------------------------------------*/ | |
135 | ||
136 | /* | |
137 | * Non-touchscreen sensors only use single-ended conversions. | |
138 | */ | |
139 | ||
140 | struct ser_req { | |
141 | u8 command; | |
142 | u16 scratch; | |
143 | __be16 sample; | |
144 | struct spi_message msg; | |
145 | struct spi_transfer xfer[6]; | |
146 | }; | |
147 | ||
148 | static int ads7846_read12_ser(struct device *dev, unsigned command) | |
149 | { | |
150 | struct spi_device *spi = to_spi_device(dev); | |
151 | struct ads7846 *ts = dev_get_drvdata(dev); | |
152 | struct ser_req *req = kzalloc(sizeof *req, SLAB_KERNEL); | |
153 | int status; | |
154 | int sample; | |
8275c642 | 155 | int i; |
ffa458c1 DB |
156 | |
157 | if (!req) | |
158 | return -ENOMEM; | |
159 | ||
8275c642 VW |
160 | INIT_LIST_HEAD(&req->msg.transfers); |
161 | ||
ffa458c1 DB |
162 | /* activate reference, so it has time to settle; */ |
163 | req->xfer[0].tx_buf = &ref_on; | |
164 | req->xfer[0].len = 1; | |
165 | req->xfer[1].rx_buf = &req->scratch; | |
166 | req->xfer[1].len = 2; | |
167 | ||
168 | /* | |
169 | * for external VREF, 0 usec (and assume it's always on); | |
170 | * for 1uF, use 800 usec; | |
171 | * no cap, 100 usec. | |
172 | */ | |
173 | req->xfer[1].delay_usecs = ts->vref_delay_usecs; | |
174 | ||
175 | /* take sample */ | |
176 | req->command = (u8) command; | |
177 | req->xfer[2].tx_buf = &req->command; | |
178 | req->xfer[2].len = 1; | |
179 | req->xfer[3].rx_buf = &req->sample; | |
180 | req->xfer[3].len = 2; | |
181 | ||
182 | /* REVISIT: take a few more samples, and compare ... */ | |
183 | ||
184 | /* turn off reference */ | |
185 | req->xfer[4].tx_buf = &ref_off; | |
186 | req->xfer[4].len = 1; | |
187 | req->xfer[5].rx_buf = &req->scratch; | |
188 | req->xfer[5].len = 2; | |
189 | ||
190 | CS_CHANGE(req->xfer[5]); | |
191 | ||
192 | /* group all the transfers together, so we can't interfere with | |
193 | * reading touchscreen state; disable penirq while sampling | |
194 | */ | |
8275c642 VW |
195 | for (i = 0; i < 6; i++) |
196 | spi_message_add_tail(&req->xfer[i], &req->msg); | |
ffa458c1 DB |
197 | |
198 | disable_irq(spi->irq); | |
199 | status = spi_sync(spi, &req->msg); | |
200 | enable_irq(spi->irq); | |
201 | ||
202 | if (req->msg.status) | |
203 | status = req->msg.status; | |
204 | sample = be16_to_cpu(req->sample); | |
205 | sample = sample >> 4; | |
206 | kfree(req); | |
207 | ||
208 | return status ? status : sample; | |
209 | } | |
210 | ||
211 | #define SHOW(name) static ssize_t \ | |
212 | name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \ | |
213 | { \ | |
214 | ssize_t v = ads7846_read12_ser(dev, \ | |
215 | READ_12BIT_SER(name) | ADS_PD10_ALL_ON); \ | |
216 | if (v < 0) \ | |
217 | return v; \ | |
218 | return sprintf(buf, "%u\n", (unsigned) v); \ | |
219 | } \ | |
220 | static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL); | |
221 | ||
222 | SHOW(temp0) | |
223 | SHOW(temp1) | |
224 | SHOW(vaux) | |
225 | SHOW(vbatt) | |
226 | ||
227 | /*--------------------------------------------------------------------------*/ | |
228 | ||
229 | /* | |
230 | * PENIRQ only kicks the timer. The timer only reissues the SPI transfer, | |
231 | * to retrieve touchscreen status. | |
232 | * | |
233 | * The SPI transfer completion callback does the real work. It reports | |
234 | * touchscreen events and reactivates the timer (or IRQ) as appropriate. | |
235 | */ | |
236 | ||
237 | static void ads7846_rx(void *ads) | |
238 | { | |
239 | struct ads7846 *ts = ads; | |
240 | unsigned Rt; | |
241 | unsigned sync = 0; | |
242 | u16 x, y, z1, z2; | |
243 | unsigned long flags; | |
244 | ||
245 | /* adjust: 12 bit samples (left aligned), built from | |
246 | * two 8 bit values writen msb-first. | |
247 | */ | |
248 | x = be16_to_cpu(ts->tc.x) >> 4; | |
249 | y = be16_to_cpu(ts->tc.y) >> 4; | |
250 | z1 = be16_to_cpu(ts->tc.z1) >> 4; | |
251 | z2 = be16_to_cpu(ts->tc.z2) >> 4; | |
252 | ||
253 | /* range filtering */ | |
254 | if (x == MAX_12BIT) | |
255 | x = 0; | |
256 | ||
257 | if (x && z1 && ts->spi->dev.power.power_state.event == PM_EVENT_ON) { | |
258 | /* compute touch pressure resistance using equation #2 */ | |
259 | Rt = z2; | |
260 | Rt -= z1; | |
261 | Rt *= x; | |
262 | Rt *= ts->x_plate_ohms; | |
263 | Rt /= z1; | |
264 | Rt = (Rt + 2047) >> 12; | |
265 | } else | |
266 | Rt = 0; | |
267 | ||
268 | /* NOTE: "pendown" is inferred from pressure; we don't rely on | |
269 | * being able to check nPENIRQ status, or "friendly" trigger modes | |
270 | * (both-edges is much better than just-falling or low-level). | |
271 | * | |
272 | * REVISIT: some boards may require reading nPENIRQ; it's | |
273 | * needed on 7843. and 7845 reads pressure differently... | |
274 | * | |
275 | * REVISIT: the touchscreen might not be connected; this code | |
276 | * won't notice that, even if nPENIRQ never fires ... | |
277 | */ | |
278 | if (!ts->pendown && Rt != 0) { | |
279 | input_report_key(&ts->input, BTN_TOUCH, 1); | |
280 | sync = 1; | |
281 | } else if (ts->pendown && Rt == 0) { | |
282 | input_report_key(&ts->input, BTN_TOUCH, 0); | |
283 | sync = 1; | |
284 | } | |
285 | ||
286 | if (Rt) { | |
287 | input_report_abs(&ts->input, ABS_X, x); | |
288 | input_report_abs(&ts->input, ABS_Y, y); | |
289 | input_report_abs(&ts->input, ABS_PRESSURE, Rt); | |
290 | sync = 1; | |
291 | } | |
292 | if (sync) | |
293 | input_sync(&ts->input); | |
294 | ||
295 | #ifdef VERBOSE | |
296 | if (Rt || ts->pendown) | |
297 | pr_debug("%s: %d/%d/%d%s\n", ts->spi->dev.bus_id, | |
298 | x, y, Rt, Rt ? "" : " UP"); | |
299 | #endif | |
300 | ||
301 | /* don't retrigger while we're suspended */ | |
302 | spin_lock_irqsave(&ts->lock, flags); | |
303 | ||
304 | ts->pendown = (Rt != 0); | |
305 | ts->pending = 0; | |
306 | ||
307 | if (ts->spi->dev.power.power_state.event == PM_EVENT_ON) { | |
308 | if (ts->pendown) | |
309 | mod_timer(&ts->timer, jiffies + TS_POLL_PERIOD); | |
310 | else if (ts->irq_disabled) { | |
311 | ts->irq_disabled = 0; | |
312 | enable_irq(ts->spi->irq); | |
313 | } | |
314 | } | |
315 | ||
316 | spin_unlock_irqrestore(&ts->lock, flags); | |
317 | } | |
318 | ||
319 | static void ads7846_timer(unsigned long handle) | |
320 | { | |
321 | struct ads7846 *ts = (void *)handle; | |
322 | int status = 0; | |
323 | unsigned long flags; | |
324 | ||
325 | spin_lock_irqsave(&ts->lock, flags); | |
326 | if (!ts->pending) { | |
327 | ts->pending = 1; | |
328 | if (!ts->irq_disabled) { | |
329 | ts->irq_disabled = 1; | |
330 | disable_irq(ts->spi->irq); | |
331 | } | |
332 | status = spi_async(ts->spi, &ts->msg); | |
333 | if (status) | |
334 | dev_err(&ts->spi->dev, "spi_async --> %d\n", | |
335 | status); | |
336 | } | |
337 | spin_unlock_irqrestore(&ts->lock, flags); | |
338 | } | |
339 | ||
340 | static irqreturn_t ads7846_irq(int irq, void *handle, struct pt_regs *regs) | |
341 | { | |
342 | ads7846_timer((unsigned long) handle); | |
343 | return IRQ_HANDLED; | |
344 | } | |
345 | ||
346 | /*--------------------------------------------------------------------------*/ | |
347 | ||
ffa458c1 | 348 | static int |
2e5a7bd9 | 349 | ads7846_suspend(struct spi_device *spi, pm_message_t message) |
ffa458c1 | 350 | { |
2e5a7bd9 | 351 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); |
ffa458c1 DB |
352 | unsigned long flags; |
353 | ||
354 | spin_lock_irqsave(&ts->lock, flags); | |
355 | ||
2e5a7bd9 | 356 | spi->dev.power.power_state = message; |
ffa458c1 DB |
357 | |
358 | /* are we waiting for IRQ, or polling? */ | |
359 | if (!ts->pendown) { | |
360 | if (!ts->irq_disabled) { | |
361 | ts->irq_disabled = 1; | |
362 | disable_irq(ts->spi->irq); | |
363 | } | |
364 | } else { | |
365 | /* polling; force a final SPI completion; | |
366 | * that will clean things up neatly | |
367 | */ | |
368 | if (!ts->pending) | |
369 | mod_timer(&ts->timer, jiffies); | |
370 | ||
371 | while (ts->pendown || ts->pending) { | |
372 | spin_unlock_irqrestore(&ts->lock, flags); | |
373 | udelay(10); | |
374 | spin_lock_irqsave(&ts->lock, flags); | |
375 | } | |
376 | } | |
377 | ||
378 | /* we know the chip's in lowpower mode since we always | |
379 | * leave it that way after every request | |
380 | */ | |
381 | ||
382 | spin_unlock_irqrestore(&ts->lock, flags); | |
383 | return 0; | |
384 | } | |
385 | ||
2e5a7bd9 | 386 | static int ads7846_resume(struct spi_device *spi) |
ffa458c1 | 387 | { |
2e5a7bd9 | 388 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); |
ffa458c1 DB |
389 | |
390 | ts->irq_disabled = 0; | |
391 | enable_irq(ts->spi->irq); | |
2e5a7bd9 | 392 | spi->dev.power.power_state = PMSG_ON; |
ffa458c1 DB |
393 | return 0; |
394 | } | |
395 | ||
2e5a7bd9 | 396 | static int __devinit ads7846_probe(struct spi_device *spi) |
ffa458c1 | 397 | { |
ffa458c1 | 398 | struct ads7846 *ts; |
2e5a7bd9 | 399 | struct ads7846_platform_data *pdata = spi->dev.platform_data; |
ffa458c1 | 400 | struct spi_transfer *x; |
8275c642 | 401 | int i; |
ffa458c1 DB |
402 | |
403 | if (!spi->irq) { | |
2e5a7bd9 | 404 | dev_dbg(&spi->dev, "no IRQ?\n"); |
ffa458c1 DB |
405 | return -ENODEV; |
406 | } | |
407 | ||
408 | if (!pdata) { | |
2e5a7bd9 | 409 | dev_dbg(&spi->dev, "no platform data?\n"); |
ffa458c1 DB |
410 | return -ENODEV; |
411 | } | |
412 | ||
413 | /* don't exceed max specified sample rate */ | |
414 | if (spi->max_speed_hz > (125000 * 16)) { | |
2e5a7bd9 | 415 | dev_dbg(&spi->dev, "f(sample) %d KHz?\n", |
ffa458c1 DB |
416 | (spi->max_speed_hz/16)/1000); |
417 | return -EINVAL; | |
418 | } | |
419 | ||
420 | /* We'd set the wordsize to 12 bits ... except that some controllers | |
421 | * will then treat the 8 bit command words as 12 bits (and drop the | |
422 | * four MSBs of the 12 bit result). Result: inputs must be shifted | |
423 | * to discard the four garbage LSBs. | |
424 | */ | |
425 | ||
426 | if (!(ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL))) | |
427 | return -ENOMEM; | |
428 | ||
2e5a7bd9 | 429 | dev_set_drvdata(&spi->dev, ts); |
ffa458c1 DB |
430 | |
431 | ts->spi = spi; | |
432 | spi->dev.power.power_state = PMSG_ON; | |
433 | ||
434 | init_timer(&ts->timer); | |
435 | ts->timer.data = (unsigned long) ts; | |
436 | ts->timer.function = ads7846_timer; | |
437 | ||
438 | ts->model = pdata->model ? : 7846; | |
439 | ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100; | |
440 | ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; | |
441 | ||
442 | init_input_dev(&ts->input); | |
443 | ||
2e5a7bd9 | 444 | ts->input.dev = &spi->dev; |
ffa458c1 | 445 | ts->input.name = "ADS784x Touchscreen"; |
2e5a7bd9 | 446 | snprintf(ts->phys, sizeof ts->phys, "%s/input0", spi->dev.bus_id); |
ffa458c1 DB |
447 | ts->input.phys = ts->phys; |
448 | ||
449 | ts->input.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS); | |
450 | ts->input.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH); | |
451 | input_set_abs_params(&ts->input, ABS_X, | |
452 | pdata->x_min ? : 0, | |
453 | pdata->x_max ? : MAX_12BIT, | |
454 | 0, 0); | |
455 | input_set_abs_params(&ts->input, ABS_Y, | |
456 | pdata->y_min ? : 0, | |
457 | pdata->y_max ? : MAX_12BIT, | |
458 | 0, 0); | |
459 | input_set_abs_params(&ts->input, ABS_PRESSURE, | |
460 | pdata->pressure_min, pdata->pressure_max, 0, 0); | |
461 | ||
462 | input_register_device(&ts->input); | |
463 | ||
464 | /* set up the transfers to read touchscreen state; this assumes we | |
465 | * use formula #2 for pressure, not #3. | |
466 | */ | |
467 | x = ts->xfer; | |
468 | ||
469 | /* y- still on; turn on only y+ (and ADC) */ | |
470 | x->tx_buf = &read_y; | |
471 | x->len = 1; | |
472 | x++; | |
473 | x->rx_buf = &ts->tc.y; | |
474 | x->len = 2; | |
475 | x++; | |
476 | ||
477 | /* turn y+ off, x- on; we'll use formula #2 */ | |
478 | if (ts->model == 7846) { | |
479 | x->tx_buf = &read_z1; | |
480 | x->len = 1; | |
481 | x++; | |
482 | x->rx_buf = &ts->tc.z1; | |
483 | x->len = 2; | |
484 | x++; | |
485 | ||
486 | x->tx_buf = &read_z2; | |
487 | x->len = 1; | |
488 | x++; | |
489 | x->rx_buf = &ts->tc.z2; | |
490 | x->len = 2; | |
491 | x++; | |
492 | } | |
493 | ||
494 | /* turn y- off, x+ on, then leave in lowpower */ | |
495 | x->tx_buf = &read_x; | |
496 | x->len = 1; | |
497 | x++; | |
498 | x->rx_buf = &ts->tc.x; | |
499 | x->len = 2; | |
500 | x++; | |
501 | ||
502 | CS_CHANGE(x[-1]); | |
503 | ||
8275c642 VW |
504 | for (i = 0; i < x - ts->xfer; i++) |
505 | spi_message_add_tail(&ts->xfer[i], &ts->msg); | |
ffa458c1 DB |
506 | ts->msg.complete = ads7846_rx; |
507 | ts->msg.context = ts; | |
508 | ||
f43aaba1 RK |
509 | if (request_irq(spi->irq, ads7846_irq, |
510 | SA_SAMPLE_RANDOM | SA_TRIGGER_FALLING, | |
511 | spi->dev.bus_id, ts)) { | |
2e5a7bd9 | 512 | dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq); |
ffa458c1 DB |
513 | input_unregister_device(&ts->input); |
514 | kfree(ts); | |
515 | return -EBUSY; | |
516 | } | |
ffa458c1 | 517 | |
2e5a7bd9 | 518 | dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq); |
ffa458c1 DB |
519 | |
520 | /* take a first sample, leaving nPENIRQ active; avoid | |
521 | * the touchscreen, in case it's not connected. | |
522 | */ | |
2e5a7bd9 | 523 | (void) ads7846_read12_ser(&spi->dev, |
ffa458c1 DB |
524 | READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON); |
525 | ||
526 | /* ads7843/7845 don't have temperature sensors, and | |
527 | * use the other sensors a bit differently too | |
528 | */ | |
529 | if (ts->model == 7846) { | |
2e5a7bd9 DB |
530 | device_create_file(&spi->dev, &dev_attr_temp0); |
531 | device_create_file(&spi->dev, &dev_attr_temp1); | |
ffa458c1 DB |
532 | } |
533 | if (ts->model != 7845) | |
2e5a7bd9 DB |
534 | device_create_file(&spi->dev, &dev_attr_vbatt); |
535 | device_create_file(&spi->dev, &dev_attr_vaux); | |
ffa458c1 DB |
536 | |
537 | return 0; | |
538 | } | |
539 | ||
2e5a7bd9 | 540 | static int __devexit ads7846_remove(struct spi_device *spi) |
ffa458c1 | 541 | { |
2e5a7bd9 | 542 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); |
ffa458c1 | 543 | |
2e5a7bd9 | 544 | ads7846_suspend(spi, PMSG_SUSPEND); |
ffa458c1 DB |
545 | free_irq(ts->spi->irq, ts); |
546 | if (ts->irq_disabled) | |
547 | enable_irq(ts->spi->irq); | |
548 | ||
549 | if (ts->model == 7846) { | |
2e5a7bd9 DB |
550 | device_remove_file(&spi->dev, &dev_attr_temp0); |
551 | device_remove_file(&spi->dev, &dev_attr_temp1); | |
ffa458c1 DB |
552 | } |
553 | if (ts->model != 7845) | |
2e5a7bd9 DB |
554 | device_remove_file(&spi->dev, &dev_attr_vbatt); |
555 | device_remove_file(&spi->dev, &dev_attr_vaux); | |
ffa458c1 DB |
556 | |
557 | input_unregister_device(&ts->input); | |
558 | kfree(ts); | |
559 | ||
2e5a7bd9 | 560 | dev_dbg(&spi->dev, "unregistered touchscreen\n"); |
ffa458c1 DB |
561 | return 0; |
562 | } | |
563 | ||
2e5a7bd9 DB |
564 | static struct spi_driver ads7846_driver = { |
565 | .driver = { | |
566 | .name = "ads7846", | |
567 | .bus = &spi_bus_type, | |
568 | .owner = THIS_MODULE, | |
569 | }, | |
ffa458c1 | 570 | .probe = ads7846_probe, |
2e5a7bd9 | 571 | .remove = __devexit_p(ads7846_remove), |
ffa458c1 DB |
572 | .suspend = ads7846_suspend, |
573 | .resume = ads7846_resume, | |
574 | }; | |
575 | ||
576 | static int __init ads7846_init(void) | |
577 | { | |
578 | /* grr, board-specific init should stay out of drivers!! */ | |
579 | ||
580 | #ifdef CONFIG_ARCH_OMAP | |
581 | if (machine_is_omap_osk()) { | |
582 | /* GPIO4 = PENIRQ; GPIO6 = BUSY */ | |
583 | omap_request_gpio(4); | |
584 | omap_set_gpio_direction(4, 1); | |
585 | omap_request_gpio(6); | |
586 | omap_set_gpio_direction(6, 1); | |
587 | } | |
588 | // also TI 1510 Innovator, bitbanging through FPGA | |
589 | // also Nokia 770 | |
590 | // also Palm Tungsten T2 | |
591 | #endif | |
592 | ||
593 | // PXA: | |
594 | // also Dell Axim X50 | |
595 | // also HP iPaq H191x/H192x/H415x/H435x | |
2e5a7bd9 | 596 | // also Intel Lubbock (additional to UCB1400; as temperature sensor) |
ffa458c1 DB |
597 | // also Sharp Zaurus C7xx, C8xx (corgi/sheperd/husky) |
598 | ||
2e5a7bd9 DB |
599 | // Atmel at91sam9261-EK uses ads7843 |
600 | ||
ffa458c1 DB |
601 | // also various AMD Au1x00 devel boards |
602 | ||
2e5a7bd9 | 603 | return spi_register_driver(&ads7846_driver); |
ffa458c1 DB |
604 | } |
605 | module_init(ads7846_init); | |
606 | ||
607 | static void __exit ads7846_exit(void) | |
608 | { | |
2e5a7bd9 | 609 | spi_unregister_driver(&ads7846_driver); |
ffa458c1 DB |
610 | |
611 | #ifdef CONFIG_ARCH_OMAP | |
612 | if (machine_is_omap_osk()) { | |
613 | omap_free_gpio(4); | |
614 | omap_free_gpio(6); | |
615 | } | |
616 | #endif | |
617 | ||
618 | } | |
619 | module_exit(ads7846_exit); | |
620 | ||
621 | MODULE_DESCRIPTION("ADS7846 TouchScreen Driver"); | |
622 | MODULE_LICENSE("GPL"); |