xburst: switch to 3.3 and add broken flag
[openwrt/svn-archive/archive.git] / target / linux / xburst / patches-2.6.37 / 061-touchscreen.patch
1 From d231cea1dca0c1b04d11cbf996077cf59612e3c4 Mon Sep 17 00:00:00 2001
2 From: Lars-Peter Clausen <lars@metafoo.de>
3 Date: Sun, 5 Sep 2010 20:45:08 +0200
4 Subject: [PATCH 14/23] input: Add touchscreen driver for the JZ4740 SoC
5
6 This patch adds a touchscreen driver for the Ingenic JZ4740 SoC.
7 The touchscreen controller is part of the ADC unit and thus this driver is a mfd
8 cell from the jz4740-adc driver.
9
10 Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
11 ---
12 drivers/input/touchscreen/Kconfig | 12 ++
13 drivers/input/touchscreen/Makefile | 1 +
14 drivers/input/touchscreen/jz4740-ts.c | 330 +++++++++++++++++++++++++++++++++
15 3 files changed, 343 insertions(+), 0 deletions(-)
16 create mode 100644 drivers/input/touchscreen/jz4740-ts.c
17
18 --- a/drivers/input/touchscreen/Kconfig
19 +++ b/drivers/input/touchscreen/Kconfig
20 @@ -681,4 +681,16 @@ config TOUCHSCREEN_STMPE
21 To compile this driver as a module, choose M here: the
22 module will be called stmpe-ts.
23
24 +config TOUCHSCREEN_JZ4740
25 + tristate "JZ4740 touchscreen support"
26 + depends on MFD_JZ4740_ADC
27 + help
28 + Say Y here if you want support for the touchscreen controller found on
29 + Ingenic JZ4740 SoCs.
30 +
31 + If unsure, say N.
32 +
33 + To compile this driver as a module, choose M here: the
34 + module will be called jz4740-ts.
35 +
36 endif
37 --- a/drivers/input/touchscreen/Makefile
38 +++ b/drivers/input/touchscreen/Makefile
39 @@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_FUJITSU) += fuj
40 obj-$(CONFIG_TOUCHSCREEN_INEXIO) += inexio.o
41 obj-$(CONFIG_TOUCHSCREEN_INTEL_MID) += intel-mid-touch.o
42 obj-$(CONFIG_TOUCHSCREEN_LPC32XX) += lpc32xx_ts.o
43 +obj-$(CONFIG_TOUCHSCREEN_JZ4740) += jz4740-ts.o
44 obj-$(CONFIG_TOUCHSCREEN_MC13783) += mc13783_ts.o
45 obj-$(CONFIG_TOUCHSCREEN_MCS5000) += mcs5000_ts.o
46 obj-$(CONFIG_TOUCHSCREEN_MIGOR) += migor_ts.o
47 --- /dev/null
48 +++ b/drivers/input/touchscreen/jz4740-ts.c
49 @@ -0,0 +1,330 @@
50 +/*
51 + * Touchscreen driver for Ingenic JZ SoCs.
52 + *
53 + * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
54 + *
55 + * This program is free software; you can redistribute it and/or modify
56 + * it under the terms of the GNU General Public License version 2 as
57 + * published by the Free Software Foundation.
58 + *
59 + */
60 +
61 +#include <linux/interrupt.h>
62 +#include <linux/kernel.h>
63 +#include <linux/module.h>
64 +#include <linux/platform_device.h>
65 +#include <linux/slab.h>
66 +
67 +#include <linux/delay.h>
68 +#include <linux/mfd/core.h>
69 +#include <linux/input.h>
70 +#include <linux/bitops.h>
71 +#include <linux/jz4740-adc.h>
72 +
73 +struct jz4740_ts {
74 + struct platform_device *pdev;
75 +
76 + struct resource *mem;
77 + void __iomem *base;
78 +
79 + int irq_penup;
80 + int irq_pendown;
81 + int irq_data_ready;
82 +
83 + struct mfd_cell *cell;
84 + struct input_dev *input;
85 +
86 + bool is_open;
87 +};
88 +
89 +static irqreturn_t jz4740_ts_data_ready_irq_handler(int irq, void *devid)
90 +{
91 + struct jz4740_ts *jz4740_ts = devid;
92 + uint32_t data;
93 + unsigned long x, y, z1, z2, pressure;
94 +
95 + data = readl(jz4740_ts->base + 0x08);
96 + x = data & 0xfff;
97 + y = (data >> 16) & 0xfff;
98 +
99 + data = readl(jz4740_ts->base + 0x08);
100 + z1 = data & 0xfff;
101 + z2 = (data >> 16) & 0xfff;
102 + if (z1 == 0) {
103 + pressure = 4095UL;
104 + } else if (z1 > z2) {
105 + pressure = 0;
106 + } else {
107 + if (data & 0x8000)
108 + pressure = (((480UL * x * z2) / z1) - 480UL * x) / 4096UL;
109 + else
110 + pressure = (((272UL * y * z2) / z1) - 272UL * y) / 4096UL;
111 + if (pressure >= 4096UL)
112 + pressure = 4095UL;
113 + pressure = 4095UL - pressure;
114 + }
115 +
116 + input_report_abs(jz4740_ts->input, ABS_X, y);
117 + input_report_abs(jz4740_ts->input, ABS_Y, 4095 - x);
118 + input_report_abs(jz4740_ts->input, ABS_PRESSURE, pressure);
119 + input_report_key(jz4740_ts->input, BTN_TOUCH, 1);
120 + input_sync(jz4740_ts->input);
121 +
122 + return IRQ_HANDLED;
123 +}
124 +
125 +static irqreturn_t jz4740_ts_pen_irq_handler(int irq, void *devid)
126 +{
127 + struct jz4740_ts *jz4740_ts = devid;
128 + int is_pressed;
129 +
130 + if (irq == jz4740_ts->irq_penup) {
131 + enable_irq(jz4740_ts->irq_pendown);
132 + is_pressed = 0;
133 + } else {
134 + enable_irq(jz4740_ts->irq_penup);
135 + is_pressed = 1;
136 + }
137 + disable_irq_nosync(irq);
138 +
139 + printk("pen irq: %d\n", irq);
140 + input_report_key(jz4740_ts->input, BTN_TOUCH, is_pressed);
141 + if (is_pressed == 0)
142 + input_report_abs(jz4740_ts->input, ABS_PRESSURE, 0);
143 + input_sync(jz4740_ts->input);
144 +
145 + return IRQ_HANDLED;
146 +}
147 +
148 +static int jz4740_ts_open(struct input_dev *input)
149 +{
150 + struct jz4740_ts *jz4740_ts = input_get_drvdata(input);
151 +
152 + jz4740_ts->is_open = true;
153 + jz4740_ts->cell->enable(jz4740_ts->pdev);
154 +
155 + return 0;
156 +}
157 +
158 +static void jz4740_ts_close(struct input_dev *input)
159 +{
160 + struct jz4740_ts *jz4740_ts = input_get_drvdata(input);
161 +
162 + jz4740_ts->cell->disable(jz4740_ts->pdev);
163 + jz4740_ts->is_open = false;
164 +}
165 +
166 +static int __devinit jz4740_ts_probe(struct platform_device *pdev)
167 +{
168 + int ret = 0;
169 + struct jz4740_ts *jz4740_ts;
170 + struct input_dev *input;
171 +
172 + jz4740_ts = kzalloc(sizeof(*jz4740_ts), GFP_KERNEL);
173 + if (!jz4740_ts) {
174 + dev_err(&pdev->dev, "Failed to allocate driver structure\n");
175 + return -ENOMEM;
176 + }
177 +
178 + jz4740_ts->pdev = pdev;
179 + jz4740_ts->cell = pdev->dev.platform_data;
180 +
181 + jz4740_ts->irq_data_ready = platform_get_irq(pdev, 0);
182 + if (jz4740_ts->irq_data_ready < 0) {
183 + ret = jz4740_ts->irq_data_ready;
184 + dev_err(&pdev->dev, "Failed to get platform irq: %d\n", ret);
185 + goto err_free;
186 + }
187 +
188 + jz4740_ts->irq_penup = platform_get_irq(pdev, 1);
189 + if (jz4740_ts->irq_penup < 0) {
190 + ret = jz4740_ts->irq_penup;
191 + dev_err(&pdev->dev, "Failed to get platform irq: %d\n", ret);
192 + goto err_free;
193 + }
194 +
195 + jz4740_ts->irq_pendown = platform_get_irq(pdev, 2);
196 + if (jz4740_ts->irq_pendown < 0) {
197 + ret = jz4740_ts->irq_pendown;
198 + dev_err(&pdev->dev, "Failed to get platform irq: %d\n", ret);
199 + goto err_free;
200 + }
201 +
202 + jz4740_ts->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
203 + if (!jz4740_ts->mem) {
204 + ret = -ENOENT;
205 + dev_err(&pdev->dev, "Failed to get platform mmio resource\n");
206 + goto err_free;
207 + }
208 +
209 + jz4740_ts->mem = request_mem_region(jz4740_ts->mem->start,
210 + resource_size(jz4740_ts->mem), pdev->name);
211 + if (!jz4740_ts->mem) {
212 + ret = -EBUSY;
213 + dev_err(&pdev->dev, "Failed to request mmio memory region\n");
214 + goto err_free;
215 + }
216 +
217 + jz4740_ts->base = ioremap_nocache(jz4740_ts->mem->start,
218 + resource_size(jz4740_ts->mem));
219 + if (!jz4740_ts->base) {
220 + ret = -EBUSY;
221 + dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
222 + goto err_release_mem_region;
223 + }
224 +
225 + input = input_allocate_device();
226 + if (!input) {
227 + dev_err(&pdev->dev, "Failed to allocate input device\n");
228 + ret = -ENOMEM;
229 + goto err_iounmap;
230 + }
231 +
232 + input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
233 + __set_bit(BTN_TOUCH, input->keybit);
234 +
235 + input_set_abs_params(input, ABS_X, 150, 3920, 0, 0);
236 + input_set_abs_params(input, ABS_Y, 270, 3700, 0, 0);
237 + input_set_abs_params(input, ABS_PRESSURE, 0, 4096, 0, 0);
238 +
239 + input->name = pdev->name;
240 + input->phys = "jz4740";
241 + input->id.bustype = BUS_HOST;
242 + input->dev.parent = &pdev->dev;
243 +
244 + input->open = jz4740_ts_open;
245 + input->close = jz4740_ts_close;
246 +
247 + input_set_drvdata(input, jz4740_ts);
248 +
249 + ret = input_register_device(input);
250 + if (ret) {
251 + dev_err(&pdev->dev, "Failed to register input device: %d\n", ret);
252 + input_free_device(input);
253 + goto err_iounmap;
254 + }
255 + jz4740_ts->input = input;
256 +
257 + ret = request_irq(jz4740_ts->irq_data_ready, jz4740_ts_data_ready_irq_handler, 0, pdev->name,
258 + jz4740_ts);
259 + if (ret) {
260 + dev_err(&pdev->dev, "Failed to request irq %d\n", ret);
261 + goto err_input_unregister_device;
262 + }
263 + ret = request_irq(jz4740_ts->irq_penup, jz4740_ts_pen_irq_handler, 0, pdev->name,
264 + jz4740_ts);
265 + if (ret) {
266 + dev_err(&pdev->dev, "Failed to request irq %d\n", ret);
267 + goto err_free_irq_data_ready;
268 + }
269 + disable_irq(jz4740_ts->irq_penup);
270 + ret = request_irq(jz4740_ts->irq_pendown, jz4740_ts_pen_irq_handler, 0, pdev->name,
271 + jz4740_ts);
272 + if (ret) {
273 + dev_err(&pdev->dev, "Failed to request irq %d\n", ret);
274 + goto err_free_irq_penup;
275 + }
276 + platform_set_drvdata(pdev, jz4740_ts);
277 +
278 + jz4740_adc_set_config(pdev->dev.parent,
279 + JZ_ADC_CONFIG_EX_IN | JZ_ADC_CONFIG_XYZ_OFFSET(2) | JZ_ADC_CONFIG_DNUM(7),
280 + JZ_ADC_CONFIG_EX_IN | JZ_ADC_CONFIG_XYZ_MASK | JZ_ADC_CONFIG_DNUM_MASK);
281 +
282 +
283 + writel(0x15e, jz4740_ts->base);
284 + writel(0x32, jz4740_ts->base + 0x04);
285 +
286 + return 0;
287 +
288 +err_free_irq_penup:
289 + free_irq(jz4740_ts->irq_penup, jz4740_ts);
290 +err_free_irq_data_ready:
291 + free_irq(jz4740_ts->irq_data_ready, jz4740_ts);
292 +err_input_unregister_device:
293 + input_unregister_device(jz4740_ts->input);
294 +err_iounmap:
295 + platform_set_drvdata(pdev, NULL);
296 + iounmap(jz4740_ts->base);
297 +err_release_mem_region:
298 + release_mem_region(jz4740_ts->mem->start, resource_size(jz4740_ts->mem));
299 +err_free:
300 + kfree(jz4740_ts);
301 + return ret;
302 +}
303 +
304 +static int __devexit jz4740_ts_remove(struct platform_device *pdev)
305 +{
306 + struct jz4740_ts *jz4740_ts = platform_get_drvdata(pdev);
307 +
308 +
309 + free_irq(jz4740_ts->irq_pendown, jz4740_ts);
310 + free_irq(jz4740_ts->irq_penup, jz4740_ts);
311 + free_irq(jz4740_ts->irq_data_ready, jz4740_ts);
312 +
313 + input_unregister_device(jz4740_ts->input);
314 +
315 + iounmap(jz4740_ts->base);
316 + release_mem_region(jz4740_ts->mem->start, resource_size(jz4740_ts->mem));
317 +
318 + kfree(jz4740_ts);
319 +
320 + return 0;
321 +}
322 +
323 +#ifdef CONFIG_PM
324 +static int jz4740_ts_suspend(struct device *dev)
325 +{
326 + struct jz4740_ts *jz4740_ts = dev_get_drvdata(dev);
327 +
328 + if (jz4740_ts->is_open);
329 + jz4740_ts->cell->disable(jz4740_ts->pdev);
330 +
331 + return 0;
332 +}
333 +
334 +static int jz4740_ts_resume(struct device *dev)
335 +{
336 + struct jz4740_ts *jz4740_ts = dev_get_drvdata(dev);
337 +
338 + if (jz4740_ts->is_open);
339 + jz4740_ts->cell->enable(jz4740_ts->pdev);
340 +
341 + return 0;
342 +}
343 +
344 +static const struct dev_pm_ops jz4740_ts_pm_ops = {
345 + .suspend = jz4740_ts_suspend,
346 + .resume = jz4740_ts_resume,
347 +};
348 +
349 +#define JZ4740_TS_PM_OPS (&jz4740_ts_pm_ops)
350 +#else
351 +#define JZ4740_TS_PM_OPS NULL
352 +#endif
353 +
354 +static struct platform_driver jz4740_ts_driver = {
355 + .probe = jz4740_ts_probe,
356 + .remove = __devexit_p(jz4740_ts_remove),
357 + .driver = {
358 + .name = "jz4740-ts",
359 + .owner = THIS_MODULE,
360 + .pm = JZ4740_TS_PM_OPS,
361 + },
362 +};
363 +
364 +static int __init jz4740_ts_init(void)
365 +{
366 + return platform_driver_register(&jz4740_ts_driver);
367 +}
368 +module_init(jz4740_ts_init);
369 +
370 +static void __exit jz4740_ts_exit(void)
371 +{
372 + platform_driver_unregister(&jz4740_ts_driver);
373 +}
374 +module_exit(jz4740_ts_exit);
375 +
376 +MODULE_ALIAS("platform:jz4740-ts");
377 +MODULE_LICENSE("GPL");
378 +MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
379 +MODULE_DESCRIPTION("JZ4740 SoC battery driver");