Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/input/touchscreen/tps6507x-ts.c

  1 /*
  2  * Touchscreen driver for the tps6507x chip.
  3  *
  4  * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
  5  *
  6  * Credits:
  7  *
  8  *    Using code from tsc2007, MtekVision Co., Ltd.
  9  *
 10  * For licencing details see kernel-base/COPYING
 11  *
 12  * TPS65070, TPS65073, TPS650731, and TPS650732 support
 13  * 10 bit touch screen interface.
 14  */
 15 
 16 #include <linux/module.h>
 17 #include <linux/workqueue.h>
 18 #include <linux/slab.h>
 19 #include <linux/input.h>
 20 #include <linux/input-polldev.h>
 21 #include <linux/platform_device.h>
 22 #include <linux/mfd/tps6507x.h>
 23 #include <linux/input/tps6507x-ts.h>
 24 #include <linux/delay.h>
 25 
 26 #define TSC_DEFAULT_POLL_PERIOD 30 /* ms */
 27 #define TPS_DEFAULT_MIN_PRESSURE 0x30
 28 #define MAX_10BIT ((1 << 10) - 1)
 29 
 30 #define TPS6507X_ADCONFIG_CONVERT_TS (TPS6507X_ADCONFIG_AD_ENABLE | \
 31                                          TPS6507X_ADCONFIG_START_CONVERSION | \
 32                                          TPS6507X_ADCONFIG_INPUT_REAL_TSC)
 33 #define TPS6507X_ADCONFIG_POWER_DOWN_TS (TPS6507X_ADCONFIG_INPUT_REAL_TSC)
 34 
 35 struct ts_event {
 36         u16     x;
 37         u16     y;
 38         u16     pressure;
 39 };
 40 
 41 struct tps6507x_ts {
 42         struct device           *dev;
 43         struct input_polled_dev *poll_dev;
 44         struct tps6507x_dev     *mfd;
 45         char                    phys[32];
 46         struct ts_event         tc;
 47         u16                     min_pressure;
 48         bool                    pendown;
 49 };
 50 
 51 static int tps6507x_read_u8(struct tps6507x_ts *tsc, u8 reg, u8 *data)
 52 {
 53         int err;
 54 
 55         err = tsc->mfd->read_dev(tsc->mfd, reg, 1, data);
 56 
 57         if (err)
 58                 return err;
 59 
 60         return 0;
 61 }
 62 
 63 static int tps6507x_write_u8(struct tps6507x_ts *tsc, u8 reg, u8 data)
 64 {
 65         return tsc->mfd->write_dev(tsc->mfd, reg, 1, &data);
 66 }
 67 
 68 static s32 tps6507x_adc_conversion(struct tps6507x_ts *tsc,
 69                                    u8 tsc_mode, u16 *value)
 70 {
 71         s32 ret;
 72         u8 adc_status;
 73         u8 result;
 74 
 75         /* Route input signal to A/D converter */
 76 
 77         ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE, tsc_mode);
 78         if (ret) {
 79                 dev_err(tsc->dev, "TSC mode read failed\n");
 80                 goto err;
 81         }
 82 
 83         /* Start A/D conversion */
 84 
 85         ret = tps6507x_write_u8(tsc, TPS6507X_REG_ADCONFIG,
 86                                 TPS6507X_ADCONFIG_CONVERT_TS);
 87         if (ret) {
 88                 dev_err(tsc->dev, "ADC config write failed\n");
 89                 return ret;
 90         }
 91 
 92         do {
 93                 ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADCONFIG,
 94                                        &adc_status);
 95                 if (ret) {
 96                         dev_err(tsc->dev, "ADC config read failed\n");
 97                         goto err;
 98                 }
 99         } while (adc_status & TPS6507X_ADCONFIG_START_CONVERSION);
100 
101         ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_2, &result);
102         if (ret) {
103                 dev_err(tsc->dev, "ADC result 2 read failed\n");
104                 goto err;
105         }
106 
107         *value = (result & TPS6507X_REG_ADRESULT_2_MASK) << 8;
108 
109         ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_1, &result);
110         if (ret) {
111                 dev_err(tsc->dev, "ADC result 1 read failed\n");
112                 goto err;
113         }
114 
115         *value |= result;
116 
117         dev_dbg(tsc->dev, "TSC channel %d = 0x%X\n", tsc_mode, *value);
118 
119 err:
120         return ret;
121 }
122 
123 /* Need to call tps6507x_adc_standby() after using A/D converter for the
124  * touch screen interrupt to work properly.
125  */
126 
127 static s32 tps6507x_adc_standby(struct tps6507x_ts *tsc)
128 {
129         s32 ret;
130         s32 loops = 0;
131         u8 val;
132 
133         ret = tps6507x_write_u8(tsc,  TPS6507X_REG_ADCONFIG,
134                                 TPS6507X_ADCONFIG_INPUT_TSC);
135         if (ret)
136                 return ret;
137 
138         ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE,
139                                 TPS6507X_TSCMODE_STANDBY);
140         if (ret)
141                 return ret;
142 
143         ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
144         if (ret)
145                 return ret;
146 
147         while (val & TPS6507X_REG_TSC_INT) {
148                 mdelay(10);
149                 ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
150                 if (ret)
151                         return ret;
152                 loops++;
153         }
154 
155         return ret;
156 }
157 
158 static void tps6507x_ts_poll(struct input_polled_dev *poll_dev)
159 {
160         struct tps6507x_ts *tsc = poll_dev->private;
161         struct input_dev *input_dev = poll_dev->input;
162         bool pendown;
163         s32 ret;
164 
165         ret = tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_PRESSURE,
166                                       &tsc->tc.pressure);
167         if (ret)
168                 goto done;
169 
170         pendown = tsc->tc.pressure > tsc->min_pressure;
171 
172         if (unlikely(!pendown && tsc->pendown)) {
173                 dev_dbg(tsc->dev, "UP\n");
174                 input_report_key(input_dev, BTN_TOUCH, 0);
175                 input_report_abs(input_dev, ABS_PRESSURE, 0);
176                 input_sync(input_dev);
177                 tsc->pendown = false;
178         }
179 
180         if (pendown) {
181 
182                 if (!tsc->pendown) {
183                         dev_dbg(tsc->dev, "DOWN\n");
184                         input_report_key(input_dev, BTN_TOUCH, 1);
185                 } else
186                         dev_dbg(tsc->dev, "still down\n");
187 
188                 ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_X_POSITION,
189                                                &tsc->tc.x);
190                 if (ret)
191                         goto done;
192 
193                 ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_Y_POSITION,
194                                                &tsc->tc.y);
195                 if (ret)
196                         goto done;
197 
198                 input_report_abs(input_dev, ABS_X, tsc->tc.x);
199                 input_report_abs(input_dev, ABS_Y, tsc->tc.y);
200                 input_report_abs(input_dev, ABS_PRESSURE, tsc->tc.pressure);
201                 input_sync(input_dev);
202                 tsc->pendown = true;
203         }
204 
205 done:
206         tps6507x_adc_standby(tsc);
207 }
208 
209 static int tps6507x_ts_probe(struct platform_device *pdev)
210 {
211         struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
212         const struct tps6507x_board *tps_board;
213         const struct touchscreen_init_data *init_data;
214         struct tps6507x_ts *tsc;
215         struct input_polled_dev *poll_dev;
216         struct input_dev *input_dev;
217         int error;
218 
219         /*
220          * tps_board points to pmic related constants
221          * coming from the board-evm file.
222          */
223         tps_board = dev_get_platdata(tps6507x_dev->dev);
224         if (!tps_board) {
225                 dev_err(tps6507x_dev->dev,
226                         "Could not find tps6507x platform data\n");
227                 return -ENODEV;
228         }
229 
230         /*
231          * init_data points to array of regulator_init structures
232          * coming from the board-evm file.
233          */
234         init_data = tps_board->tps6507x_ts_init_data;
235 
236         tsc = kzalloc(sizeof(struct tps6507x_ts), GFP_KERNEL);
237         if (!tsc) {
238                 dev_err(tps6507x_dev->dev, "failed to allocate driver data\n");
239                 return -ENOMEM;
240         }
241 
242         tsc->mfd = tps6507x_dev;
243         tsc->dev = tps6507x_dev->dev;
244         tsc->min_pressure = init_data ?
245                         init_data->min_pressure : TPS_DEFAULT_MIN_PRESSURE;
246 
247         snprintf(tsc->phys, sizeof(tsc->phys),
248                  "%s/input0", dev_name(tsc->dev));
249 
250         poll_dev = input_allocate_polled_device();
251         if (!poll_dev) {
252                 dev_err(tsc->dev, "Failed to allocate polled input device.\n");
253                 error = -ENOMEM;
254                 goto err_free_mem;
255         }
256 
257         tsc->poll_dev = poll_dev;
258 
259         poll_dev->private = tsc;
260         poll_dev->poll = tps6507x_ts_poll;
261         poll_dev->poll_interval = init_data ?
262                         init_data->poll_period : TSC_DEFAULT_POLL_PERIOD;
263 
264         input_dev = poll_dev->input;
265         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
266         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
267 
268         input_set_abs_params(input_dev, ABS_X, 0, MAX_10BIT, 0, 0);
269         input_set_abs_params(input_dev, ABS_Y, 0, MAX_10BIT, 0, 0);
270         input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_10BIT, 0, 0);
271 
272         input_dev->name = "TPS6507x Touchscreen";
273         input_dev->phys = tsc->phys;
274         input_dev->dev.parent = tsc->dev;
275         input_dev->id.bustype = BUS_I2C;
276         if (init_data) {
277                 input_dev->id.vendor = init_data->vendor;
278                 input_dev->id.product = init_data->product;
279                 input_dev->id.version = init_data->version;
280         }
281 
282         error = tps6507x_adc_standby(tsc);
283         if (error)
284                 goto err_free_polled_dev;
285 
286         error = input_register_polled_device(poll_dev);
287         if (error)
288                 goto err_free_polled_dev;
289 
290         platform_set_drvdata(pdev, tsc);
291 
292         return 0;
293 
294 err_free_polled_dev:
295         input_free_polled_device(poll_dev);
296 err_free_mem:
297         kfree(tsc);
298         return error;
299 }
300 
301 static int tps6507x_ts_remove(struct platform_device *pdev)
302 {
303         struct tps6507x_ts *tsc = platform_get_drvdata(pdev);
304         struct input_polled_dev *poll_dev = tsc->poll_dev;
305 
306         input_unregister_polled_device(poll_dev);
307         input_free_polled_device(poll_dev);
308 
309         kfree(tsc);
310 
311         return 0;
312 }
313 
314 static struct platform_driver tps6507x_ts_driver = {
315         .driver = {
316                 .name = "tps6507x-ts",
317                 .owner = THIS_MODULE,
318         },
319         .probe = tps6507x_ts_probe,
320         .remove = tps6507x_ts_remove,
321 };
322 module_platform_driver(tps6507x_ts_driver);
323 
324 MODULE_AUTHOR("Todd Fischer <todd.fischer@ridgerun.com>");
325 MODULE_DESCRIPTION("TPS6507x - TouchScreen driver");
326 MODULE_LICENSE("GPL v2");
327 MODULE_ALIAS("platform:tps6507x-ts");
328 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us